@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tests/opencode-adapter.test.ts

@@ -10,6 +10,7 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Event as OpencodeEvent } from "@opencode-ai/sdk";
+import { resolveProviderOutput, trackAssistantText } from "../commands/runner";
 import type {
   ProviderEvent,
   ProviderResult,
@@ -927,6 +928,122 @@ describe("OpencodeSession — context_usage emission (phase 9 fix)", () => {
 
 // ── DES-300: per-task isolation ────────────────────────────────────────────────
 
+describe("OpencodeSession — assistant text for final-message validation", () => {
+  beforeEach(() => {
+    mock.restore();
+  });
+
+  const SESSION = "sess-abc-123";
+
+  function messageUpdated(
+    id: string,
+    role: "assistant" | "user",
+    completed: boolean,
+  ): OpencodeEvent {
+    const now = Date.now();
+    return {
+      type: "message.updated",
+      properties: {
+        info: {
+          id,
+          sessionID: SESSION,
+          role,
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          time: completed ? { created: now, completed: now + 1 } : { created: now },
+          parentID: "",
+          modelID: "m",
+          providerID: "p",
+          mode: "live",
+          path: { cwd: "/", root: "/" },
+        } as never,
+      },
+    };
+  }
+
+  function textPart(
+    messageID: string,
+    id: string,
+    text: string,
+    extra: { synthetic?: boolean; ignored?: boolean } = {},
+  ): OpencodeEvent {
+    return {
+      type: "message.part.updated",
+      properties: {
+        part: { id, sessionID: SESSION, messageID, type: "text", text, ...extra } as never,
+      },
+    };
+  }
+
+  const idle: OpencodeEvent = { type: "session.idle", properties: { sessionID: SESSION } };
+
+  function assistantTexts(emitted: ProviderEvent[]): string[] {
+    return emitted.flatMap((e) =>
+      e.type === "message" && e.role === "assistant" ? [e.content] : [],
+    );
+  }
+
+  test("the runner's final-message buffer holds the last step's text, ready for outputSchema validation", async () => {
+    const final = JSON.stringify({ verdict: "pass", score: 3 });
+    const { emitted } = await driveSession([
+      messageUpdated("m1", "assistant", false),
+      textPart("m1", "p1", "Checking the page first."),
+      messageUpdated("m1", "assistant", true),
+      // Step 2 is tool-free and carries the answer.
+      messageUpdated("m2", "assistant", false),
+      textPart("m2", "p2", final),
+      messageUpdated("m2", "assistant", true),
+      idle,
+    ]);
+
+    expect(assistantTexts(emitted)).toEqual(["Checking the page first.", final]);
+
+    const holder: { value?: string } = {};
+    for (const e of emitted) trackAssistantText(holder, e);
+    expect(resolveProviderOutput({ output: undefined }, holder)).toBe(final);
+  });
+
+  test("user-message text and synthetic or ignored parts are never emitted as assistant text", async () => {
+    const { emitted } = await driveSession([
+      messageUpdated("u1", "user", true),
+      textPart("u1", "pu", "the task prompt"),
+      messageUpdated("m1", "assistant", false),
+      textPart("m1", "p-synth", "injected reminder", { synthetic: true }),
+      textPart("m1", "p-ign", "ignored text", { ignored: true }),
+      textPart("m1", "p1", "real answer"),
+      messageUpdated("m1", "assistant", true),
+      idle,
+    ]);
+
+    expect(assistantTexts(emitted)).toEqual(["real answer"]);
+  });
+
+  test("streamed snapshots and replayed finalized updates emit the message once, with its full text", async () => {
+    const { emitted } = await driveSession([
+      messageUpdated("m1", "assistant", false),
+      textPart("m1", "p1", '{"a"'),
+      textPart("m1", "p1", '{"a": 1}'),
+      messageUpdated("m1", "assistant", true),
+      messageUpdated("m1", "assistant", true),
+      idle,
+    ]);
+
+    expect(assistantTexts(emitted)).toEqual(['{"a": 1}']);
+  });
+
+  test("a text part that lands after its message finalized re-emits the fuller text", async () => {
+    const { emitted } = await driveSession([
+      messageUpdated("m1", "assistant", false),
+      textPart("m1", "p1", "first half. "),
+      messageUpdated("m1", "assistant", true),
+      textPart("m1", "p2", "second half."),
+      idle,
+    ]);
+
+    expect(assistantTexts(emitted)).toEqual(["first half.", "first half. second half."]);
+  });
+});
+
 describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
   let prevOpencodeSkillsDir: string | undefined;
 
@@ -1038,6 +1155,37 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
     }
   });
 
+  test("swarm MCP headers carry the task id and context key", async () => {
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    await driveSession(
+      events,
+      testConfig({ taskId: "task-1", contextKey: "task:slack:C1:1700000000.000100" }),
+    );
+
+    const opts = lastCreateOpencodeConfig as {
+      config?: { mcp?: Record<string, { headers?: Record<string, string> }> };
+    };
+    const headers = opts.config?.mcp?.swarm?.headers;
+    expect(headers?.["X-Source-Task-Id"]).toBe("task-1");
+    expect(headers?.["X-Context-Key"]).toBe("task:slack:C1:1700000000.000100");
+  });
+
+  test("swarm MCP headers omit the context key when the task has none", async () => {
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    await driveSession(events, testConfig({ taskId: "task-1" }));
+
+    const opts = lastCreateOpencodeConfig as {
+      config?: { mcp?: Record<string, { headers?: Record<string, string> }> };
+    };
+    const headers = opts.config?.mcp?.swarm?.headers;
+    expect(headers?.["X-Source-Task-Id"]).toBe("task-1");
+    expect(headers?.["X-Context-Key"]).toBeUndefined();
+  });
+
   test("swarm MCP headers omit the runtime identity when unset", async () => {
     const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
     delete process.env.SWARM_RUNTIME_INSTANCE_ID;
@@ -1076,7 +1224,7 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
   });
 
   test("per-task config file is written as valid JSON", async () => {
-    const cfg = testConfig({ taskId: "task-cfg-json" });
+    const cfg = testConfig({ taskId: "task-cfg-json", contextKey: "task:api:ctx-1" });
     await inspectSessionBeforeIdle(cfg, async () => {
       const configFile = Bun.file("/tmp/opencode-task-cfg-json.json");
       const exists = await configFile.exists();
@@ -1084,9 +1232,16 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
       if (exists) {
         const text = await configFile.text();
         expect(() => JSON.parse(text)).not.toThrow();
-        const parsed = JSON.parse(text) as { mcp?: unknown; permission?: unknown };
+        const parsed = JSON.parse(text) as {
+          mcp?: { swarm?: { headers?: Record<string, string> } };
+          permission?: unknown;
+        };
         expect(parsed.mcp).toBeDefined();
         expect(parsed.permission).toBeDefined();
+        // The per-task file must carry the task identity too: `opencode serve`
+        // reads this file (via OPENCODE_CONFIG), not the in-process object.
+        expect(parsed.mcp?.swarm?.headers?.["X-Source-Task-Id"]).toBe("task-cfg-json");
+        expect(parsed.mcp?.swarm?.headers?.["X-Context-Key"]).toBe("task:api:ctx-1");
       }
     });
 

package/src/tests/package-publish.test.ts

@@ -1,47 +1,148 @@
-import { afterAll, describe, expect, setDefaultTimeout, test } from "bun:test";
-import { execSync } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { chmod, mkdir, mkdtemp, realpath, rm, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc.ts";
 
 const REPO_ROOT = join(import.meta.dir, "../..");
-const tempDir = mkdtempSync(join(tmpdir(), "agent-swarm-pack-"));
+const tempDir = await realpath(await mkdtemp(join(tmpdir(), "agent-swarm-pack-")));
+const unpackDir = join(tempDir, "unpacked");
+const cliPath = join(unpackDir, "package", "dist", "cli.js");
+const nodePath = Bun.which("node")!;
+const emptyPath = join(tempDir, "empty-path");
 
-setDefaultTimeout(30_000);
+beforeAll(async () => {
+  const tarballPath = join(tempDir, "agent-swarm.tgz");
+  expectChildOk(
+    await runChild(["bun", "pm", "pack", "--filename", tarballPath], { cwd: REPO_ROOT }),
+    "pack CLI",
+  );
+  await mkdir(unpackDir);
+  await mkdir(emptyPath);
+  expectChildOk(await runChild(["tar", "-xzf", tarballPath, "-C", unpackDir]), "unpack CLI");
+  // Reuse installed dependencies without a network install.
+  await symlink(join(REPO_ROOT, "node_modules"), join(unpackDir, "package", "node_modules"));
+}, CHILD_PROCESS_TEST_BUDGET_MS);
 
-afterAll(() => {
-  rmSync(tempDir, { force: true, recursive: true });
+afterAll(async () => {
+  await rm(tempDir, { force: true, recursive: true });
 });
 
 describe("published package", () => {
-  test("version command works from the packaged node bin", () => {
-    const tarballPath = join(tempDir, "agent-swarm.tgz");
-    const unpackDir = join(tempDir, "unpacked");
-
-    execSync(`bun pm pack --filename ${JSON.stringify(tarballPath)}`, {
-      cwd: REPO_ROOT,
-      stdio: "pipe",
-    });
-    execSync(
-      `mkdir -p ${JSON.stringify(unpackDir)} && tar -xzf ${JSON.stringify(tarballPath)} -C ${JSON.stringify(unpackDir)}`,
-      {
-        cwd: REPO_ROOT,
-        stdio: "pipe",
-      },
-    );
-
-    // Symlink repo node_modules so top-level imports resolve without a network install
-    execSync(
-      `ln -s ${JSON.stringify(join(REPO_ROOT, "node_modules"))} ${JSON.stringify(join(unpackDir, "package", "node_modules"))}`,
-      { stdio: "pipe" },
-    );
-
-    const output = execSync(`node ./package/dist/cli.js version`, {
-      cwd: unpackDir,
-      encoding: "utf-8",
-      stdio: "pipe",
-    });
-
-    expect(output).toContain("agent-swarm v");
+  test("runtime dependencies never reference a private workspace package", async () => {
+    // The release step runs plain `npm publish`, which does not rewrite `workspace:*`, and a
+    // private workspace package is never on the registry: either one breaks `npm i` / `npx`.
+    // Workspace code the CLI needs is bundled into dist/cli.js, so it belongs in devDependencies.
+    const workspaceNames = new Set<string>();
+    for (const pattern of ["packages/*/package.json", "apps/*/package.json"]) {
+      for await (const file of new Bun.Glob(pattern).scan({ cwd: REPO_ROOT })) {
+        workspaceNames.add((await Bun.file(join(REPO_ROOT, file)).json()).name);
+      }
+    }
+    expect(workspaceNames.has("@desplega/model-catalog")).toBe(true);
+
+    const offenders: string[] = [];
+    for (const manifestPath of [
+      join(REPO_ROOT, "package.json"),
+      join(unpackDir, "package", "package.json"),
+    ]) {
+      const manifest = await Bun.file(manifestPath).json();
+      for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+        for (const [name, spec] of Object.entries<string>(manifest[field] ?? {})) {
+          if (spec.startsWith("workspace:") || workspaceNames.has(name)) {
+            offenders.push(`${manifestPath} ${field} ${name}@${spec}`);
+          }
+        }
+      }
+    }
+    expect(offenders).toEqual([]);
   });
+
+  test(
+    "version and help work without Bun installed",
+    async () => {
+      for (const args of [["version"], ["onboard", "--help"], ["codex-login", "--help"]]) {
+        const result = expectChildOk(
+          await runChild([nodePath, cliPath, ...args], {
+            cwd: unpackDir,
+            env: { ...process.env, PATH: emptyPath },
+          }),
+          args.join(" "),
+        );
+        expect(result.stdout).toContain("agent-swarm");
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "onboard restarts with Bun and preserves arguments, environment, streams, and exit status",
+    async () => {
+      const binDir = join(tempDir, "fake-bin");
+      await mkdir(binDir);
+      const bunPath = join(binDir, "bun");
+      await Bun.write(
+        bunPath,
+        `#!${process.execPath}
+console.log(JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd(), marker: process.env.ONBOARD_TEST_MARKER, bun: !!process.versions.bun }));
+console.error("test stderr");
+process.exit(37);
+`,
+      );
+      await chmod(bunPath, 0o755);
+      const args = ["onboard", "--dry-run", "--preset", "value with spaces"];
+      const result = await runChild([nodePath, cliPath, ...args], {
+        cwd: unpackDir,
+        env: { ...process.env, PATH: binDir, ONBOARD_TEST_MARKER: "preserved" },
+      });
+      expect(result.exitCode).toBe(37);
+      expect(JSON.parse(result.stdout)).toEqual({
+        args: [cliPath, ...args],
+        cwd: unpackDir,
+        marker: "preserved",
+        bun: true,
+      });
+      expect(result.stderr).toContain("test stderr");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "onboard reports a Bun installation requirement when Bun is unavailable",
+    async () => {
+      const result = await runChild([nodePath, cliPath, "onboard"], {
+        cwd: unpackDir,
+        env: { ...process.env, PATH: emptyPath },
+      });
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain("Onboarding requires Bun.");
+      expect(result.stderr).toContain("https://bun.sh");
+      expect(result.stdout + result.stderr).not.toContain("Bun is not defined");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "onboard completes a dry run under Node and Bun",
+    async () => {
+      for (const runtime of [nodePath, process.execPath]) {
+        const result = expectChildOk(
+          await runChild([runtime, cliPath, "onboard", "--yes", "--preset=solo", "--dry-run"], {
+            cwd: unpackDir,
+            env: {
+              ...process.env,
+              HARNESS_PROVIDER: "claude",
+              ANTHROPIC_API_KEY: "test-onboard-key",
+            },
+          }),
+          "onboard dry run",
+        );
+        expect(result.stdout).toContain("DRY-RUN MODE");
+        expect(result.stdout + result.stderr).not.toContain("Bun is not defined");
+      }
+      expect(await Bun.file(join(unpackDir, "docker-compose.yml")).exists()).toBe(false);
+      expect(await Bun.file(join(unpackDir, ".env")).exists()).toBe(false);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
 });

package/src/tests/pi-codemode.test.ts

@@ -0,0 +1,246 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type {
+  AgentSession,
+  ExtensionAPI,
+  ExtensionFactory,
+  ExtensionToolContext,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import {
+  type CodemodeLimits,
+  createBoundedCodemodeExtension,
+  isPiCodemodeEnabled,
+  PiMonoAdapter,
+  piDefaultToolAdditions,
+  piExtensionFactories,
+} from "../providers/pi-mono-adapter";
+
+describe("PI_CODEMODE flag", () => {
+  test("off by default and for false values", () => {
+    expect(isPiCodemodeEnabled({})).toBe(false);
+    expect(isPiCodemodeEnabled({ PI_CODEMODE: "false" })).toBe(false);
+  });
+
+  test("on when true", () => {
+    expect(isPiCodemodeEnabled({ PI_CODEMODE: "true" })).toBe(true);
+  });
+});
+
+describe("pi extension factories and default tools — codemode", () => {
+  const swarm: ExtensionFactory = () => {};
+
+  test("codemode adds its extension and +codemode", () => {
+    expect(piExtensionFactories(swarm, { toolDeferral: false, codemode: true })).toHaveLength(2);
+    expect(piDefaultToolAdditions({ toolDeferral: false, codemode: true })).toEqual(["+codemode"]);
+  });
+
+  test("all features together", () => {
+    const features = { toolDeferral: true, installedMcp: true, codemode: true };
+    expect(piExtensionFactories(swarm, features)).toHaveLength(4);
+    expect(piDefaultToolAdditions(features)).toEqual(["+tool_search", "+codemode"]);
+  });
+});
+
+describe("PiMonoAdapter.createSession — codemode", () => {
+  const envKeys = [
+    "PI_CODEMODE",
+    "PI_TOOL_DEFERRAL",
+    "PI_CODING_AGENT_DIR",
+    "OPENROUTER_API_KEY",
+    "OPENROUTER_BASE_URL",
+  ];
+  const saved: Record<string, string | undefined> = {};
+  let dir = "";
+
+  beforeEach(() => {
+    for (const key of envKeys) saved[key] = process.env[key];
+    dir = mkdtempSync(join(tmpdir(), "pi-codemode-"));
+    process.env.PI_CODING_AGENT_DIR = join(dir, "agent");
+    process.env.OPENROUTER_API_KEY = "example-test-key";
+    // The session prompts on creation; keep that request off the network.
+    process.env.OPENROUTER_BASE_URL = "http://127.0.0.1:9/api/v1";
+    delete process.env.PI_CODEMODE;
+    delete process.env.PI_TOOL_DEFERRAL;
+  });
+  afterEach(() => {
+    for (const key of envKeys) {
+      if (saved[key] === undefined) delete process.env[key];
+      else process.env[key] = saved[key];
+    }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  async function activeTools(): Promise<string[]> {
+    const server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname !== "/mcp") return Response.json({ servers: [] });
+        const body = (await req.json()) as { id?: number; method?: string };
+        const result =
+          body.method === "tools/list"
+            ? {
+                tools: [
+                  { name: "store-progress", inputSchema: { type: "object" } },
+                  { name: "create-page", inputSchema: { type: "object" } },
+                ],
+              }
+            : { protocolVersion: "2025-03-26", capabilities: {} };
+        return Response.json({ jsonrpc: "2.0", id: body.id ?? 1, result });
+      },
+    });
+    let session: AgentSession | undefined;
+    try {
+      const provider = await new PiMonoAdapter().createSession({
+        prompt: "hello",
+        systemPrompt: "",
+        model: "openrouter/google/gemini-3-flash-preview",
+        role: "worker",
+        agentId: "test-agent",
+        taskId: "test-task",
+        apiUrl: `http://localhost:${server.port}`,
+        apiKey: "example-test-key",
+        cwd: dir,
+        logFile: join(dir, "session.log"),
+      });
+      session = (provider as unknown as { agentSession: AgentSession }).agentSession;
+      return session.getActiveToolNames();
+    } finally {
+      session?.dispose();
+      server.stop(true);
+    }
+  }
+
+  test("flag on: codemode is added and swarm tools stay declared", async () => {
+    process.env.PI_CODEMODE = "true";
+    const active = await activeTools();
+    expect(active).toContain("codemode");
+    expect(active).toContain("store-progress");
+    expect(active).toContain("create-page");
+  });
+
+  test("flag off: no codemode", async () => {
+    expect(await activeTools()).not.toContain("codemode");
+    process.env.PI_CODEMODE = "false";
+    expect(await activeTools()).not.toContain("codemode");
+  });
+});
+
+describe("bounded codemode", () => {
+  type Registered = ToolDefinition;
+
+  function registerCodemode(limits: CodemodeLimits): Registered {
+    let registered: Registered | undefined;
+    const pi = {
+      registerTool: (tool: Registered) => {
+        registered = tool;
+      },
+      getSettings: () => ({}),
+      getAllTools: () => [],
+      appendEntry: () => {},
+    } as unknown as ExtensionAPI;
+    createBoundedCodemodeExtension(limits)(pi);
+    if (!registered) throw new Error("codemode tool was not registered");
+    return registered;
+  }
+
+  function fakeCtx(onCall: () => Promise<void> = async () => {}) {
+    const calls: string[] = [];
+    let running = 0;
+    let peak = 0;
+    // Same shape as pi's createToolContext(): executeTool is defined
+    // non-writable and non-configurable, so a Proxy cannot swap it.
+    const ctx = Object.defineProperties(
+      {
+        tools: [{ name: "noop", description: "does nothing", parameters: { type: "object" } }],
+        sessionManager: { getBranch: () => [] },
+      },
+      {
+        executeTool: {
+          value: async (name: string) => {
+            calls.push(name);
+            running++;
+            peak = Math.max(peak, running);
+            try {
+              await onCall();
+            } finally {
+              running--;
+            }
+            return {
+              toolCall: { id: `call-${calls.length}` },
+              result: { content: [{ type: "text", text: "ok" }] },
+              isError: false,
+            };
+          },
+        },
+      },
+    ) as unknown as ExtensionToolContext;
+    return { ctx, calls, peak: () => peak };
+  }
+
+  function textOf(result: { content: Array<{ type: string; text?: string }> }): string {
+    return result.content.map((item) => item.text ?? "").join("\n");
+  }
+
+  const limits = { timeoutMs: 30_000, maxNestedCalls: 32, maxConcurrentCalls: 4 };
+
+  test("a non-terminating script is interrupted at the deadline", async () => {
+    const tool = registerCodemode({ ...limits, timeoutMs: 300 });
+    const started = Date.now();
+    const result = await tool.execute(
+      "t1",
+      { code: "while (true) {}" },
+      undefined,
+      undefined,
+      fakeCtx().ctx,
+    );
+    expect(Date.now() - started).toBeLessThan(10_000);
+    expect(textOf(result)).toContain("300 ms deadline");
+  }, 20_000);
+
+  test("the deadline also caps a script that asks for a longer timeout_ms", async () => {
+    const tool = registerCodemode({ ...limits, timeoutMs: 300 });
+    const code = '// @options: {"timeout_ms": 600000}\nwhile (true) {}';
+    const result = await tool.execute("t2", { code }, undefined, undefined, fakeCtx().ctx);
+    expect(textOf(result)).toContain("300 ms deadline");
+  }, 20_000);
+
+  test("nested calls past the budget fail the script", async () => {
+    const tool = registerCodemode({ ...limits, maxNestedCalls: 3 });
+    const fake = fakeCtx();
+    const code =
+      "for (let i = 0; i < 10; i++) { try { await tools.noop({}); } catch {} }\nreturn 'done';";
+    const result = await tool.execute("t3", { code }, undefined, undefined, fake.ctx);
+    expect(fake.calls).toHaveLength(3);
+    expect(textOf(result)).toStartWith("Script failed");
+    expect(textOf(result)).toContain("budget of 3 nested tool calls");
+  }, 20_000);
+
+  test("nested calls run at most maxConcurrentCalls at once", async () => {
+    const tool = registerCodemode({ ...limits, maxConcurrentCalls: 2 });
+    const fake = fakeCtx(() => new Promise((resolve) => setTimeout(resolve, 20)));
+    const code =
+      "await Promise.all(Array.from({ length: 6 }, () => tools.noop({})));\nreturn 'done';";
+    const result = await tool.execute("t4", { code }, undefined, undefined, fake.ctx);
+    expect(textOf(result)).toStartWith("Script completed");
+    expect(fake.calls).toHaveLength(6);
+    expect(fake.peak()).toBe(2);
+  }, 20_000);
+
+  test("cancelling the task aborts a running script", async () => {
+    const tool = registerCodemode(limits);
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(new Error("task cancelled")), 200);
+    const result = await tool.execute(
+      "t5",
+      { code: "while (true) {}" },
+      controller.signal,
+      undefined,
+      fakeCtx().ctx,
+    );
+    expect(textOf(result)).toContain("task cancelled");
+  }, 20_000);
+});

package/src/tests/pi-mono-adapter.test.ts

@@ -46,6 +46,7 @@ describe("PiMonoAdapter.createSession — reasoning_effort", () => {
       model: undefined,
       subscribe: () => () => {},
       dispose: () => {},
+      bindExtensions: async () => {},
     };
   }
 
@@ -136,6 +137,7 @@ describe("PiMonoAdapter.createSession — OPENROUTER_BASE_URL gateway", () => {
           model: undefined,
           subscribe: () => () => {},
           dispose: () => {},
+          bindExtensions: async () => {},
         },
       };
     }) as typeof piCodingAgent.createAgentSession);
@@ -191,6 +193,7 @@ describe("PiMonoAdapter.createSession — MCP runtime identity header", () => {
           model: undefined,
           subscribe: () => () => {},
           dispose: () => {},
+          bindExtensions: async () => {},
         },
       };
     }) as typeof piCodingAgent.createAgentSession);