Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/qa-lab/src/bus-state.test.ts

@@ -0,0 +1,241 @@
+// Qa Lab tests cover bus state plugin behavior.
+import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { createQaBusState } from "./bus-state.js";
+
+describe("qa-bus state", () => {
+  it("records inbound and outbound traffic in cursor order", () => {
+    const state = createQaBusState();
+
+    const inbound = state.addInboundMessage({
+      conversation: { id: "alice", kind: "direct" },
+      senderId: "alice",
+      text: "hello",
+    });
+    const outbound = state.addOutboundMessage({
+      to: "dm:alice",
+      text: "hi",
+    });
+
+    const snapshot = state.getSnapshot();
+    expect(snapshot.cursor).toBe(2);
+    expect(snapshot.events.map((event) => event.kind)).toEqual([
+      "inbound-message",
+      "outbound-message",
+    ]);
+    expect(snapshot.messages.map((message) => message.id)).toEqual([inbound.id, outbound.id]);
+  });
+
+  it("creates threads and mutates message state", () => {
+    const state = createQaBusState();
+
+    const thread = state.createThread({
+      conversationId: "qa-room",
+      title: "QA thread",
+    });
+    const message = state.addOutboundMessage({
+      to: `thread:qa-room/${thread.id}`,
+      text: "inside thread",
+      threadId: thread.id,
+    });
+
+    state.reactToMessage({
+      messageId: message.id,
+      emoji: "eyes",
+      senderId: "alice",
+    });
+    state.editMessage({
+      messageId: message.id,
+      text: "inside thread (edited)",
+    });
+    state.deleteMessage({
+      messageId: message.id,
+    });
+
+    const snapshot = state.getSnapshot();
+    expect(snapshot.threads).toHaveLength(1);
+    expect(snapshot.threads[0]?.id).toBe(thread.id);
+    expect(snapshot.threads[0]?.conversationId).toBe("qa-room");
+    expect(snapshot.threads[0]?.title).toBe("QA thread");
+    expect(snapshot.messages[0]?.id).toBe(message.id);
+    expect(snapshot.messages[0]?.text).toBe("inside thread (edited)");
+    expect(snapshot.messages[0]?.deleted).toBe(true);
+    expect(snapshot.messages[0]?.reactions).toHaveLength(1);
+    expect(snapshot.messages[0]?.reactions[0]?.emoji).toBe("eyes");
+    expect(snapshot.messages[0]?.reactions[0]?.senderId).toBe("alice");
+    expect(typeof snapshot.messages[0]?.reactions[0]?.timestamp).toBe("number");
+  });
+
+  it("waits for a text match and rejects on timeout", async () => {
+    const state = createQaBusState();
+    const pending = state.waitFor({
+      kind: "message-text",
+      textIncludes: "needle",
+      timeoutMs: 500,
+    });
+
+    setTimeout(() => {
+      state.addOutboundMessage({
+        to: "dm:alice",
+        text: "haystack + needle",
+      });
+    }, 20);
+
+    const matched = await pending;
+    expect("text" in matched && matched.text).toContain("needle");
+
+    await expect(
+      state.waitFor({
+        kind: "message-text",
+        textIncludes: "missing",
+        timeoutMs: 20,
+      }),
+    ).rejects.toThrow("qa-bus wait timeout");
+  });
+
+  it("caps oversized wait timers", async () => {
+    vi.useFakeTimers();
+    const timeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    try {
+      const state = createQaBusState();
+      const pendingMessage = state.waitFor({
+        kind: "message-text",
+        textIncludes: "missing",
+        timeoutMs: Number.MAX_SAFE_INTEGER,
+      });
+      const pendingCursor = state.waitForCursorAdvance(0, Number.MAX_SAFE_INTEGER);
+
+      expect(timeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);
+      expect(timeoutSpy).toHaveBeenCalledTimes(2);
+
+      pendingMessage.catch(() => undefined);
+      pendingCursor.catch(() => undefined);
+    } finally {
+      timeoutSpy.mockRestore();
+      vi.useRealTimers();
+    }
+  });
+
+  it("keeps account-scoped cursor waits blocked on unrelated account traffic", async () => {
+    const state = createQaBusState();
+    const pending = state.waitForCursorAdvance(0, 500, (snapshot) => {
+      return snapshot.events.some((event) => event.accountId === "acct-a" && event.cursor > 0);
+    });
+
+    state.addInboundMessage({
+      accountId: "acct-b",
+      conversation: { id: "other", kind: "direct" },
+      senderId: "acct-b-user",
+      text: "unrelated",
+    });
+
+    const beforeMatch = await Promise.race([
+      pending.then(() => "resolved"),
+      new Promise((resolve) => {
+        setTimeout(() => resolve("still-waiting"), 20);
+      }),
+    ]);
+    expect(beforeMatch).toBe("still-waiting");
+
+    state.addInboundMessage({
+      accountId: "acct-a",
+      conversation: { id: "target", kind: "direct" },
+      senderId: "acct-a-user",
+      text: "matched",
+    });
+
+    await expect(pending).resolves.toBeUndefined();
+  });
+
+  it("wakes default-account cursor waits when accountId is omitted", async () => {
+    const state = createQaBusState();
+    const pending = state.waitForCursorAdvance(0, 500, (snapshot) => {
+      return snapshot.events.some((event) => event.accountId === "default" && event.cursor > 0);
+    });
+
+    state.addInboundMessage({
+      conversation: { id: "target", kind: "direct" },
+      senderId: "default-user",
+      text: "matched",
+    });
+
+    await expect(pending).resolves.toBeUndefined();
+  });
+
+  it("preserves inline attachments and lets search match attachment metadata", () => {
+    const state = createQaBusState();
+
+    const outbound = state.addOutboundMessage({
+      to: "dm:alice",
+      text: "artifact attached",
+      attachments: [
+        {
+          id: "image-1",
+          kind: "image",
+          mimeType: "image/png",
+          fileName: "qa-screenshot.png",
+          altText: "QA dashboard screenshot",
+          contentBase64: "aGVsbG8=",
+        },
+      ],
+    });
+
+    const readback = state.readMessage({ messageId: outbound.id });
+    expect(readback.attachments).toHaveLength(1);
+    const attachment = readback.attachments?.[0];
+    expect(attachment?.kind).toBe("image");
+    expect(attachment?.fileName).toBe("qa-screenshot.png");
+    expect(attachment?.altText).toBe("QA dashboard screenshot");
+
+    const byFilename = state.searchMessages({
+      query: "screenshot",
+    });
+    expect(byFilename.map((message) => message.id)).toContain(outbound.id);
+
+    const byAltText = state.searchMessages({
+      query: "dashboard",
+    });
+    expect(byAltText.map((message) => message.id)).toContain(outbound.id);
+  });
+
+  it("preserves sanitized tool-call traces on bus messages", () => {
+    const state = createQaBusState();
+
+    const outbound = state.addOutboundMessage({
+      to: "dm:alice",
+      text: "used a tool",
+      toolCalls: [
+        {
+          name: "exec",
+          arguments: {
+            command: "pwd",
+            apiToken: "secret-token",
+          },
+        },
+      ],
+    });
+
+    const readback = state.readMessage({ messageId: outbound.id });
+    expect(readback.toolCalls).toEqual([
+      {
+        name: "exec",
+        arguments: {
+          command: "[redacted]",
+          apiToken: "[redacted]",
+        },
+      },
+    ]);
+    expect(state.searchMessages({ query: "exec" }).map((message) => message.id)).toContain(
+      outbound.id,
+    );
+
+    const readbackArguments = readback.toolCalls?.[0]?.arguments;
+    if (!readbackArguments) {
+      throw new Error("expected tool-call arguments");
+    }
+    readbackArguments.command = "mutated";
+    expect(state.readMessage({ messageId: outbound.id }).toolCalls?.[0]?.arguments?.command).toBe(
+      "[redacted]",
+    );
+  });
+});