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/scenario-runtime-api.test.ts

@@ -0,0 +1,226 @@
+// Qa Lab tests cover scenario runtime api plugin behavior.
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { createQaBusState } from "./bus-state.js";
+import type { QaTransportAdapter } from "./qa-transport.js";
+import {
+  createQaScenarioRuntimeApi,
+  type QaScenarioRuntimeConstants,
+  type QaScenarioRuntimeDeps,
+} from "./scenario-runtime-api.js";
+
+function createDeps(overrides?: Partial<QaScenarioRuntimeDeps>): QaScenarioRuntimeDeps {
+  const fn = vi.fn();
+  return {
+    fs,
+    path,
+    sleep: vi.fn(async () => undefined),
+    randomUUID,
+    runScenario: fn,
+    waitForOutboundMessage: fn,
+    waitForTransportOutboundMessage: fn,
+    waitForChannelOutboundMessage: fn,
+    waitForNoOutbound: fn,
+    waitForNoTransportOutbound: fn,
+    recentOutboundSummary: fn,
+    formatConversationTranscript: fn,
+    readTransportTranscript: fn,
+    formatTransportTranscript: fn,
+    fetchJson: fn,
+    waitForGatewayHealthy: fn,
+    waitForTransportReady: fn,
+    waitForQaChannelReady: fn,
+    browserRequest: fn,
+    waitForBrowserReady: fn,
+    browserOpenTab: fn,
+    browserSnapshot: fn,
+    browserAct: fn,
+    webOpenPage: fn,
+    webWait: fn,
+    webType: fn,
+    webSnapshot: fn,
+    webEvaluate: fn,
+    waitForConfigRestartSettle: fn,
+    patchConfig: fn,
+    applyConfig: fn,
+    readConfigSnapshot: fn,
+    createSession: fn,
+    readEffectiveTools: fn,
+    readSkillStatus: fn,
+    readRawQaSessionStore: fn,
+    readGatewayLogs: fn,
+    markGatewayLogCursor: fn,
+    scanGatewayLogSentinels: fn,
+    assertNoGatewayLogSentinels: fn,
+    readSessionTranscriptSummary: fn,
+    runQaCli: fn,
+    extractMediaPathFromText: fn,
+    resolveGeneratedImagePath: fn,
+    startAgentRun: fn,
+    waitForAgentRun: fn,
+    waitForAgentHistoryReply: fn,
+    listCronJobs: fn,
+    waitForCronRunCompletion: fn,
+    findManagedDreamingCronJob: fn,
+    readDoctorMemoryStatus: fn,
+    forceMemoryIndex: fn,
+    findSkill: fn,
+    writeWorkspaceSkill: fn,
+    callPluginToolsMcp: fn,
+    runAgentPrompt: fn,
+    ensureImageGenerationConfigured: fn,
+    handleQaAction: fn,
+    runRuntimeToolFixture: fn,
+    extractQaToolPayload: fn,
+    formatMemoryDreamingDay: fn,
+    resolveSessionTranscriptsDirForAgent: fn,
+    activeMemoryToggleKey: fn,
+    setActiveMemorySessionDisabled: fn,
+    buildAgentSessionKey: fn,
+    normalizeLowercaseStringOrEmpty: fn,
+    formatErrorMessage: fn,
+    liveTurnTimeoutMs: fn,
+    resolveQaLiveTurnTimeoutMs: fn,
+    splitModelRef: fn,
+    qaChannelPlugin: { id: "qa-channel" },
+    hasDiscoveryLabels: fn,
+    reportsDiscoveryScopeLeak: fn,
+    reportsMissingDiscoveryFiles: fn,
+    hasModelSwitchContinuitySignal: fn,
+    ...overrides,
+  };
+}
+
+const constants: QaScenarioRuntimeConstants = {
+  imageUnderstandingPngBase64: "png-small",
+  imageUnderstandingLargePngBase64: "png-large",
+  imageUnderstandingValidPngBase64: "png-valid",
+};
+
+const browserAndWebRuntimeTools = [
+  "browserRequest",
+  "waitForBrowserReady",
+  "browserOpenTab",
+  "browserSnapshot",
+  "browserAct",
+  "webOpenPage",
+  "webWait",
+  "webType",
+  "webSnapshot",
+  "webEvaluate",
+] as const;
+
+describe("createQaScenarioRuntimeApi", () => {
+  it("builds a markdown-flow runtime surface from the transport adapter", async () => {
+    const state = createQaBusState();
+    const resetSpy = vi.spyOn(state, "reset");
+    const inboundSpy = vi.spyOn(state, "addInboundMessage");
+    const outboundSpy = vi.spyOn(state, "addOutboundMessage");
+    const readSpy = vi.spyOn(state, "readMessage");
+    const waitForCondition: QaTransportAdapter["waitForCondition"] = async <T>(
+      check: () => T | Promise<T | null | undefined> | null | undefined,
+    ): Promise<T> => {
+      const value = await check();
+      if (value === null || value === undefined) {
+        throw new Error("waitForCondition test check did not return a value");
+      }
+      return value;
+    };
+    const sleep = vi.fn(async () => undefined);
+    const env = {
+      lab: { baseUrl: "http://127.0.0.1:1234" },
+      transport: {
+        state,
+        reset: async () => {
+          state.reset();
+        },
+        sendInbound: async (input: Parameters<typeof state.addInboundMessage>[0]) =>
+          state.addInboundMessage(input),
+        sendNativeCommand: async (
+          input: Omit<Parameters<typeof state.addInboundMessage>[0], "nativeCommand" | "text"> & {
+            command: string;
+          },
+        ) => {
+          const { command, ...message } = input;
+          state.addInboundMessage({
+            ...message,
+            text: `/${command}`,
+            nativeCommand: { name: command },
+          });
+        },
+        waitForNoOutbound: vi.fn(async () => undefined),
+        waitForOutbound: vi.fn(async () => {
+          throw new Error("not used");
+        }),
+        waitForOutboundSequence: vi.fn(async () => {
+          throw new Error("not used");
+        }),
+        waitForCondition,
+      },
+    };
+    const scenario = {
+      id: "generic-flow",
+      title: "Generic Flow",
+      surface: "test",
+      objective: "test",
+      successCriteria: ["works"],
+      sourcePath: "qa/scenarios/generic-flow.yaml",
+      execution: {
+        kind: "flow" as const,
+        config: { expected: "value" },
+        flow: {
+          steps: [{ name: "noop", actions: [{ assert: "true" }] }],
+        },
+      },
+    };
+    const deps = createDeps({ sleep });
+
+    const api = createQaScenarioRuntimeApi({
+      env,
+      scenario,
+      deps,
+      constants,
+    });
+
+    expect(api.lab).toBe(env.lab);
+    expect(api.state).toBe(state);
+    expect(api.config).toEqual({ expected: "value" });
+    expect(api.waitForCondition).toBe(waitForCondition);
+    expect(api.waitForChannelReady).toBe(api.waitForTransportReady);
+    expect(api.waitForAgentHistoryReply).toBe(deps.waitForAgentHistoryReply);
+    expect(api.markGatewayLogCursor).toBe(deps.markGatewayLogCursor);
+    expect(api.assertNoGatewayLogSentinels).toBe(deps.assertNoGatewayLogSentinels);
+    expect(api.readSessionTranscriptSummary).toBe(deps.readSessionTranscriptSummary);
+    for (const toolName of browserAndWebRuntimeTools) {
+      expect(api[toolName]).toBe(deps[toolName]);
+    }
+    expect(api.getTransportSnapshot()).toEqual(state.getSnapshot());
+    expect(api.imageUnderstandingPngBase64).toBe("png-small");
+
+    const inbound = api.injectInboundMessage({
+      accountId: "qa-channel",
+      conversation: { id: "qa-operator", kind: "direct" },
+      senderId: "qa-operator",
+      text: "hello",
+    });
+    const outbound = api.injectOutboundMessage({
+      accountId: "qa-channel",
+      to: "dm:qa-operator",
+      text: "hi",
+    });
+    expect(inbound.id.trim()).not.toBe("");
+    expect(outbound.id.trim()).not.toBe("");
+    api.readTransportMessage({ accountId: "qa-channel", messageId: outbound.id });
+    await api.reset();
+    await api.resetBus();
+    await api.resetTransport();
+
+    expect(inboundSpy).toHaveBeenCalledTimes(1);
+    expect(outboundSpy).toHaveBeenCalledTimes(1);
+    expect(readSpy).toHaveBeenCalledTimes(1);
+    expect(resetSpy).toHaveBeenCalledTimes(3);
+    expect(sleep).toHaveBeenCalledTimes(3);
+  });
+});