@calltelemetry/openclaw-linear 0.7.0 → 0.8.0

package/index.ts

@@ -7,11 +7,15 @@ import { handleLinearWebhook } from "./src/pipeline/webhook.js";
 import { handleOAuthCallback } from "./src/api/oauth-callback.js";
 import { LinearAgentApi, resolveLinearToken } from "./src/api/linear-api.js";
 import { createDispatchService } from "./src/pipeline/dispatch-service.js";
+import { registerDispatchMethods } from "./src/gateway/dispatch-methods.js";
 import { readDispatchState, lookupSessionMapping, getActiveDispatch } from "./src/pipeline/dispatch-state.js";
 import { triggerAudit, processVerdict, type HookContext } from "./src/pipeline/pipeline.js";
 import { createNotifierFromConfig, type NotifyFn } from "./src/infra/notify.js";
 import { readPlanningState, setPlanningCache } from "./src/pipeline/planning-state.js";
 import { createPlannerTools } from "./src/tools/planner-tools.js";
+import { registerDispatchCommands } from "./src/infra/commands.js";
+import { createDispatchHistoryTool } from "./src/tools/dispatch-history-tool.js";
+import { readDispatchState as readStateForHook, listActiveDispatches as listActiveForHook } from "./src/pipeline/dispatch-state.js";
 
 export default function register(api: OpenClawPluginApi) {
   const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
@@ -41,6 +45,12 @@ export default function register(api: OpenClawPluginApi) {
   // Register planner tools (context injected at runtime via setActivePlannerContext)
   api.registerTool(() => createPlannerTools());
 
+  // Register dispatch_history tool for agent context
+  api.registerTool(() => createDispatchHistoryTool(api, pluginConfig));
+
+  // Register zero-LLM slash commands for dispatch ops
+  registerDispatchCommands(api);
+
   // Register Linear webhook handler on a dedicated route
   api.registerHttpRoute({
     path: "/linear/webhook",
@@ -68,6 +78,9 @@ export default function register(api: OpenClawPluginApi) {
   // Register dispatch monitor service (stale detection, session hydration, cleanup)
   api.registerService(createDispatchService(api));
 
+  // Register dispatch gateway RPC methods (list, get, retry, escalate, cancel, stats)
+  registerDispatchMethods(api);
+
   // Hydrate planning state on startup
   readPlanningState(pluginConfig?.planningStatePath as string | undefined).then((state) => {
     for (const session of Object.values(state.sessions)) {
@@ -83,7 +96,7 @@ export default function register(api: OpenClawPluginApi) {
   // ---------------------------------------------------------------------------
 
   // Instantiate notifier (Discord, Slack, or both — config-driven)
-  const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime);
+  const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime, api);
 
   // Register agent_end hook — safety net for sessions_spawn sub-agents.
   // In the current implementation, the worker→audit→verdict flow runs inline
@@ -159,6 +172,32 @@ export default function register(api: OpenClawPluginApi) {
     }
   });
 
+  // Inject recent dispatch history as context for worker/audit agents
+  api.on("before_agent_start", async (event: any, ctx: any) => {
+    try {
+      const sessionKey = ctx?.sessionKey ?? "";
+      if (!sessionKey.startsWith("linear-worker-") && !sessionKey.startsWith("linear-audit-")) return;
+
+      const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+      const state = await readStateForHook(statePath);
+      const active = listActiveForHook(state);
+
+      // Include up to 3 recent active dispatches as context
+      const recent = active.slice(0, 3);
+      if (recent.length === 0) return;
+
+      const lines = recent.map(d =>
+        `- **${d.issueIdentifier}** (${d.tier}): ${d.status}, attempt ${d.attempt}`
+      );
+
+      return {
+        prependContext: `<dispatch-history>\nActive dispatches:\n${lines.join("\n")}\n</dispatch-history>\n\n`,
+      };
+    } catch {
+      // Never block agent start for telemetry
+    }
+  });
+
   // Narration Guard: catch short "Let me explore..." responses that narrate intent
   // without actually calling tools, and append a warning for the user.
   const NARRATION_PATTERNS = [

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-linear",
   "name": "Linear Agent",
   "description": "Linear integration with OAuth support, agent pipeline, and webhook-driven AI agent lifecycle",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -15,10 +15,9 @@
       "defaultAgentId": { "type": "string", "description": "OpenClaw agent ID to use for pipeline stages" },
       "enableAudit": { "type": "boolean", "description": "Run auditor stage after implementation", "default": true },
       "codexBaseRepo": { "type": "string", "description": "Path to git repo for Codex worktrees", "default": "/home/claw/ai-workspace" },
-      "codexModel": { "type": "string", "description": "Default Codex model (optional — uses Codex default if omitted)" },
-      "codexTimeoutMs": { "type": "number", "description": "Default Codex timeout in milliseconds", "default": 600000 },
       "enableOrchestration": { "type": "boolean", "description": "Allow agents to spawn sub-agents via spawn_agent/ask_agent tools", "default": true },
       "worktreeBaseDir": { "type": "string", "description": "Base directory for persistent git worktrees (default: ~/.openclaw/worktrees)" },
+      "repos": { "type": "object", "description": "Multi-repo map (name → path, e.g. {\"api\": \"/home/claw/api\", \"frontend\": \"/home/claw/frontend\"})", "additionalProperties": { "type": "string" } },
       "dispatchStatePath": { "type": "string", "description": "Path to dispatch state JSON file (default: ~/.openclaw/linear-dispatch-state.json)" },
       "planningStatePath": { "type": "string", "description": "Path to planning state JSON file (default: ~/.openclaw/linear-planning-state.json)" },
       "notifications": {
@@ -51,7 +50,8 @@
               "stuck": { "type": "boolean" },
               "watchdog_kill": { "type": "boolean" }
             }
-          }
+          },
+          "richFormat": { "type": "boolean", "description": "Send rich embeds (Discord) and HTML (Telegram) instead of plain text", "default": false }
         }
       },
       "promptsPath": { "type": "string", "description": "Override path for prompts.yaml (default: ships with plugin)" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",
@@ -45,6 +45,7 @@
     ]
   },
   "dependencies": {
+    "cockatiel": "^3.2.1",
     "yaml": "^2.8.2"
   }
 }

package/prompts.yaml

@@ -28,10 +28,13 @@ worker:
 
     Instructions:
     1. Read the issue body carefully — it defines what needs to be done
-    2. Plan your approach
-    3. Implement the solution in the worktree
-    4. Run tests to verify your changes
-    5. Return a text summary of what you changed, what tests you ran, and any notes
+    2. If the description is vague or missing, implement a reasonable interpretation and note your assumptions
+    3. Plan your approach
+    4. Implement the solution in the worktree
+    5. Run tests to verify your changes
+    6. If tests fail, diagnose and fix the failures before returning — do not return with failing tests unless you've exhausted your ability to fix them
+    7. Commit your work with a clear commit message
+    8. Return a text summary: what you changed, what tests passed, any assumptions you made, and any open questions
 
     Your text output will be captured automatically. Do NOT use linearis or attempt to post comments.
 
@@ -67,6 +70,9 @@ audit:
     - Post your audit findings as a comment: `linearis comments create {{identifier}} --body "..."`
     - If PASS: update status: `linearis issues update {{identifier}} --status "Done"`
 
+    When posting your audit comment, include a brief assessment: what was done well,
+    what the gaps are (if any), and what the user should look at next.
+
     You MUST return a JSON verdict as the last line of your response:
     {"pass": true/false, "criteria": ["list of criteria found"], "gaps": ["list of unmet criteria"], "testResults": "summary of test output"}
 
@@ -75,7 +81,8 @@ rework:
     PREVIOUS AUDIT FAILED (attempt {{attempt}}). The auditor found these gaps:
     {{gaps}}
 
-    Address these specific issues in your rework. Focus on the gaps listed above.
+    Address these specific issues in your rework. Focus ONLY on the gaps listed above.
+    Do NOT undo or rewrite parts that already work — preserve correct code from prior attempts.
     Remember: you do NOT have linearis access. Just fix the code and return a text summary.
 
 planner:
@@ -97,6 +104,8 @@ planner:
     - After each user response, create or update issues to capture what you learned.
     - Briefly summarize what you added before asking your next question.
     - When the plan feels complete, invite the user to say "finalize plan".
+    - If the user is vague ("make it better", "you decide"), propose concrete options and ask them to pick.
+    - If you've gathered enough info after several turns with no new details, suggest: "This looks ready — say **finalize plan** when you're happy with it."
 
   interview: |
     ## Project: {{projectName}} ({{rootIdentifier}})
@@ -123,4 +132,9 @@ planner:
     features you want to build, then structure everything into Linear issues with proper
     epic hierarchy and dependency chains.
 
+    **How this works:**
+    - I'll ask questions one at a time and create issues as we go
+    - When you're happy with the plan, say **"finalize plan"** — I'll validate it and start dispatching
+    - If you want to stop, say **"abandon planning"**
+
     Let's start — what is this project about, and what are the main feature areas?

package/src/__test__/fixtures/linear-responses.ts

@@ -0,0 +1,75 @@
+/**
+ * Factory functions for Linear GraphQL response shapes.
+ *
+ * Matches the return types of LinearAgentApi methods.
+ */
+
+export function makeIssueDetails(overrides?: Record<string, unknown>) {
+  return {
+    id: "issue-1",
+    identifier: "ENG-123",
+    title: "Fix webhook routing",
+    description: "The webhook handler needs fixing.",
+    estimate: 3,
+    state: { name: "In Progress" },
+    assignee: { name: "Agent" },
+    labels: { nodes: [] as Array<{ id: string; name: string }> },
+    team: { id: "team-1", name: "Engineering", issueEstimationType: "notUsed" },
+    comments: { nodes: [] as Array<{ body: string; user: { name: string } | null; createdAt: string }> },
+    project: null as { id: string; name: string } | null,
+    parent: null as { id: string; identifier: string } | null,
+    relations: { nodes: [] as Array<{ type: string; relatedIssue: { id: string; identifier: string; title: string } }> },
+    ...overrides,
+  };
+}
+
+export function makeProjectIssue(
+  identifier: string,
+  opts?: {
+    title?: string;
+    description?: string;
+    estimate?: number;
+    priority?: number;
+    state?: { name: string; type: string };
+    parentIdentifier?: string;
+    labels?: string[];
+    relations?: Array<{ type: string; relatedIdentifier: string; relatedTitle?: string }>;
+  },
+) {
+  return {
+    id: `id-${identifier}`,
+    identifier,
+    title: opts?.title ?? `Issue ${identifier}`,
+    description: opts?.description ?? null,
+    estimate: opts?.estimate ?? null,
+    priority: opts?.priority ?? 0,
+    state: opts?.state ?? { name: "Backlog", type: "backlog" },
+    parent: opts?.parentIdentifier
+      ? { id: `id-${opts.parentIdentifier}`, identifier: opts.parentIdentifier }
+      : null,
+    labels: {
+      nodes: (opts?.labels ?? []).map((name) => ({ id: `label-${name}`, name })),
+    },
+    relations: {
+      nodes: (opts?.relations ?? []).map((r) => ({
+        type: r.type,
+        relatedIssue: {
+          id: `id-${r.relatedIdentifier}`,
+          identifier: r.relatedIdentifier,
+          title: r.relatedTitle ?? `Issue ${r.relatedIdentifier}`,
+        },
+      })),
+    },
+  };
+}
+
+export function makeProject(overrides?: Record<string, unknown>) {
+  return {
+    id: "proj-1",
+    name: "Test Project",
+    description: "A test project",
+    state: "started",
+    teams: { nodes: [{ id: "team-1", name: "Engineering" }] },
+    ...overrides,
+  };
+}

package/src/__test__/fixtures/webhook-payloads.ts

@@ -0,0 +1,113 @@
+/**
+ * Factory functions for Linear webhook event payloads.
+ *
+ * Matches the shapes received at /linear/webhook from both
+ * workspace webhooks and OAuth app webhooks.
+ */
+
+export function makeAgentSessionCreated(overrides?: Record<string, unknown>) {
+  return {
+    type: "AgentSession",
+    action: "create",
+    data: {
+      id: "sess-1",
+      context: { commentBody: "Please investigate this issue" },
+    },
+    issue: {
+      id: "issue-1",
+      identifier: "ENG-123",
+      title: "Fix webhook routing",
+    },
+    ...overrides,
+  };
+}
+
+export function makeAgentSessionPrompted(overrides?: Record<string, unknown>) {
+  return {
+    type: "AgentSession",
+    action: "prompted",
+    data: {
+      id: "sess-prompted",
+      context: { prompt: "Looks good, approved!" },
+    },
+    issue: {
+      id: "issue-2",
+      identifier: "ENG-124",
+      title: "Approved issue",
+    },
+    ...overrides,
+  };
+}
+
+export function makeCommentCreate(overrides?: Record<string, unknown>) {
+  return {
+    type: "Comment",
+    action: "create",
+    data: {
+      id: "comment-1",
+      body: "This needs work",
+      user: { id: "user-1", name: "Test User" },
+      issue: {
+        id: "issue-1",
+        identifier: "ENG-123",
+        title: "Fix webhook routing",
+        team: { id: "team-1" },
+        assignee: { id: "viewer-1" },
+        project: null,
+      },
+      createdAt: new Date().toISOString(),
+    },
+    ...overrides,
+  };
+}
+
+export function makeIssueUpdate(overrides?: Record<string, unknown>) {
+  return {
+    type: "Issue",
+    action: "update",
+    data: {
+      id: "issue-1",
+      identifier: "ENG-123",
+      title: "Fix webhook routing",
+      state: { name: "In Progress", type: "started" },
+      assignee: { id: "viewer-1", name: "Agent" },
+      team: { id: "team-1" },
+      project: null,
+    },
+    ...overrides,
+  };
+}
+
+export function makeIssueCreate(overrides?: Record<string, unknown>) {
+  return {
+    type: "Issue",
+    action: "create",
+    data: {
+      id: "issue-new",
+      identifier: "ENG-200",
+      title: "New issue",
+      state: { name: "Backlog", type: "backlog" },
+      assignee: null,
+      team: { id: "team-1" },
+      project: null,
+    },
+    ...overrides,
+  };
+}
+
+export function makeAppUserNotification(overrides?: Record<string, unknown>) {
+  return {
+    type: "AppUserNotification",
+    action: "create",
+    data: {
+      type: "issueAssigned",
+      issue: {
+        id: "issue-1",
+        identifier: "ENG-123",
+        title: "Fix webhook routing",
+      },
+      user: { id: "user-1", name: "Test User" },
+    },
+    ...overrides,
+  };
+}

package/src/__test__/helpers.ts

@@ -0,0 +1,133 @@
+/**
+ * Shared test helpers for E2E and integration tests.
+ *
+ * Provides reusable mock factories that consolidate patterns scattered across
+ * unit test files. Existing unit tests keep their local factories; new E2E
+ * tests use these from the start.
+ */
+import { vi } from "vitest";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { HookContext } from "../pipeline/pipeline.js";
+import type { NotifyFn } from "../infra/notify.js";
+
+// ---------------------------------------------------------------------------
+// Mock OpenClaw Plugin API
+// ---------------------------------------------------------------------------
+
+export function createMockApi(overrides?: Partial<{
+  logger: Partial<OpenClawPluginApi["logger"]>;
+  pluginConfig: Record<string, unknown>;
+  runtime: Record<string, unknown>;
+}>): OpenClawPluginApi {
+  return {
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+      ...overrides?.logger,
+    },
+    pluginConfig: overrides?.pluginConfig ?? {},
+    runtime: {
+      channel: {
+        discord: { sendMessageDiscord: vi.fn().mockResolvedValue(undefined) },
+        slack: { sendMessageSlack: vi.fn().mockResolvedValue(undefined) },
+        telegram: { sendMessageTelegram: vi.fn().mockResolvedValue(undefined) },
+        signal: { sendMessageSignal: vi.fn().mockResolvedValue(undefined) },
+      },
+      ...overrides?.runtime,
+    },
+  } as unknown as OpenClawPluginApi;
+}
+
+// ---------------------------------------------------------------------------
+// Mock Linear API
+// ---------------------------------------------------------------------------
+
+export interface MockLinearApi {
+  getIssueDetails: ReturnType<typeof vi.fn>;
+  createComment: ReturnType<typeof vi.fn>;
+  emitActivity: ReturnType<typeof vi.fn>;
+  updateSession: ReturnType<typeof vi.fn>;
+  getProject: ReturnType<typeof vi.fn>;
+  getProjectIssues: ReturnType<typeof vi.fn>;
+  getTeamStates: ReturnType<typeof vi.fn>;
+  getTeamLabels: ReturnType<typeof vi.fn>;
+  createIssue: ReturnType<typeof vi.fn>;
+  updateIssue: ReturnType<typeof vi.fn>;
+  updateIssueExtended: ReturnType<typeof vi.fn>;
+  createIssueRelation: ReturnType<typeof vi.fn>;
+  getViewerId: ReturnType<typeof vi.fn>;
+}
+
+export function createMockLinearApi(overrides?: Partial<MockLinearApi>): MockLinearApi {
+  return {
+    getIssueDetails: vi.fn().mockResolvedValue(null),
+    createComment: vi.fn().mockResolvedValue("comment-id"),
+    emitActivity: vi.fn().mockResolvedValue(undefined),
+    updateSession: vi.fn().mockResolvedValue(undefined),
+    getProject: vi.fn().mockResolvedValue({
+      id: "proj-1",
+      name: "Test Project",
+      description: "",
+      state: "started",
+      teams: { nodes: [{ id: "team-1", name: "Team" }] },
+    }),
+    getProjectIssues: vi.fn().mockResolvedValue([]),
+    getTeamStates: vi.fn().mockResolvedValue([
+      { id: "st-1", name: "Backlog", type: "backlog" },
+      { id: "st-2", name: "In Progress", type: "started" },
+      { id: "st-3", name: "Done", type: "completed" },
+    ]),
+    getTeamLabels: vi.fn().mockResolvedValue([]),
+    createIssue: vi.fn().mockResolvedValue({ id: "new-issue-id", identifier: "PROJ-NEW" }),
+    updateIssue: vi.fn().mockResolvedValue(undefined),
+    updateIssueExtended: vi.fn().mockResolvedValue(undefined),
+    createIssueRelation: vi.fn().mockResolvedValue(undefined),
+    getViewerId: vi.fn().mockResolvedValue("viewer-1"),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mock HookContext
+// ---------------------------------------------------------------------------
+
+export function createMockHookCtx(opts: {
+  configPath?: string;
+  planningStatePath?: string;
+  pluginConfig?: Record<string, unknown>;
+  linearApi?: MockLinearApi;
+  notify?: NotifyFn;
+}): HookContext {
+  const configPath = opts.configPath ?? tmpStatePath("claw-hook-");
+  return {
+    api: createMockApi({
+      pluginConfig: {
+        dispatchStatePath: configPath,
+        planningStatePath: opts.planningStatePath ?? configPath,
+        ...opts.pluginConfig,
+      },
+    }),
+    linearApi: (opts.linearApi ?? createMockLinearApi()) as any,
+    notify: opts.notify ?? vi.fn().mockResolvedValue(undefined),
+    pluginConfig: {
+      dispatchStatePath: configPath,
+      planningStatePath: opts.planningStatePath ?? configPath,
+      ...opts.pluginConfig,
+    },
+    configPath,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Temp path helper
+// ---------------------------------------------------------------------------
+
+export function tmpStatePath(prefix = "claw-test-"): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  return join(dir, "state.json");
+}

package/src/agent/agent.test.ts

@@ -61,6 +61,149 @@ function createApi(): OpenClawPluginApi {
   } as unknown as OpenClawPluginApi;
 }
 
+describe("runAgent subprocess", () => {
+  it("extracts text from JSON payloads", async () => {
+    const api = createApi();
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: JSON.stringify({ result: { payloads: [{ text: "hello" }, { text: "world" }] } }),
+      stderr: "",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test-agent",
+      sessionId: "session-1",
+      message: "do something",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("hello");
+    expect(result.output).toContain("world");
+  });
+
+  it("uses raw stdout when JSON parsing fails", async () => {
+    const api = createApi();
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: "plain text output",
+      stderr: "",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test-agent",
+      sessionId: "session-1",
+      message: "do something",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe("plain text output");
+  });
+
+  it("uses stderr when command fails with no stdout", async () => {
+    const api = createApi();
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 1,
+      stdout: "",
+      stderr: "error from stderr",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test-agent",
+      sessionId: "session-1",
+      message: "do something",
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("error from stderr");
+  });
+
+  it("includes agentId in command arguments", async () => {
+    const api = createApi();
+    const runCmd = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: "ok",
+      stderr: "",
+    });
+    (api.runtime.system as any).runCommandWithTimeout = runCmd;
+
+    await runAgent({
+      api,
+      agentId: "my-agent",
+      sessionId: "session-1",
+      message: "test",
+    });
+
+    const args = runCmd.mock.calls[0][0];
+    expect(args).toContain("my-agent");
+    expect(args).toContain("--agent");
+  });
+
+  it("passes timeout in seconds to subprocess", async () => {
+    const api = createApi();
+    const runCmd = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: "ok",
+      stderr: "",
+    });
+    (api.runtime.system as any).runCommandWithTimeout = runCmd;
+
+    await runAgent({
+      api,
+      agentId: "test",
+      sessionId: "session-1",
+      message: "test",
+      timeoutMs: 60_000,
+    });
+
+    const args: string[] = runCmd.mock.calls[0][0];
+    const timeoutIdx = args.indexOf("--timeout");
+    expect(timeoutIdx).toBeGreaterThan(-1);
+    expect(args[timeoutIdx + 1]).toBe("60");
+  });
+
+  it("handles empty payloads array", async () => {
+    const api = createApi();
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: JSON.stringify({ result: { payloads: [] } }),
+      stderr: "",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test",
+      sessionId: "s1",
+      message: "test",
+    });
+
+    expect(result.success).toBe(true);
+    // Falls back to raw stdout when no payload text
+    expect(result.output).toBeTruthy();
+  });
+
+  it("handles null payloads text", async () => {
+    const api = createApi();
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: JSON.stringify({ result: { payloads: [{ text: null }, { text: "real" }] } }),
+      stderr: "",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test",
+      sessionId: "s1",
+      message: "test",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("real");
+  });
+});
+
 describe("runAgent retry wrapper", () => {
   it("returns success on first attempt when no watchdog kill", async () => {
     const api = createApi();