@desplega.ai/agent-swarm 2.6.0 → 2.7.0

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

@@ -1859,3 +1859,57 @@ describe("PiMonoSession context-bound note", () => {
     expect(await lateSteers([assistantTurn(usage(5000))])).toEqual([HELD_NOTE_TEXT]);
   });
 });
+
+describe("PiMonoSession — per-call usage line", () => {
+  function assistantEnd(content: unknown[], usage?: unknown): AgentSessionEvent {
+    return {
+      type: "message_end",
+      message: { role: "assistant", content, stopReason: "stop", ...(usage ? { usage } : {}) },
+    } as unknown as AgentSessionEvent;
+  }
+
+  test("one call_usage raw_log line per assistant message_end with usage", async () => {
+    const { events } = await runWithEvents([
+      assistantEnd([{ type: "toolCall", id: "call-1", name: "bash", arguments: {} }], {
+        input: 120,
+        cacheRead: 9_000,
+        cacheWrite: 400,
+        output: 60,
+        reasoning: 12,
+        totalTokens: 9_580,
+      }),
+      {
+        type: "message_end",
+        message: { role: "user", content: [{ type: "text", text: "tool output" }] },
+      } as unknown as AgentSessionEvent,
+      // No usage (some providers omit it): no line.
+      assistantEnd([{ type: "text", text: "thinking out loud" }]),
+      assistantEnd([{ type: "text", text: "Done" }], { input: 5, cacheRead: 9_500, output: 3 }),
+    ]);
+
+    const raw = events.flatMap((e) =>
+      e.type === "raw_log" ? [JSON.parse(e.content) as Record<string, unknown>] : [],
+    );
+    const usageLines = raw.filter((line) => line.type === "call_usage");
+    expect(usageLines).toEqual([
+      {
+        type: "call_usage",
+        harness: "pi",
+        usage: { input: 120, cacheRead: 9_000, cacheWrite: 400, output: 60, reasoning: 12 },
+      },
+      {
+        type: "call_usage",
+        harness: "pi",
+        usage: { input: 5, cacheRead: 9_500, cacheWrite: 0, output: 3, reasoning: 0 },
+      },
+    ]);
+    // The usage line precedes the call's own text line.
+    const done = raw.findIndex(
+      (line) => line.type === "assistant" && JSON.stringify(line).includes('"Done"'),
+    );
+    expect(done).toBeGreaterThan(0);
+    expect(raw[done - 1]).toEqual(usageLines[1]);
+    // Token counts only: no message content rides on the line.
+    expect(JSON.stringify(usageLines)).not.toContain("tool output");
+  });
+});

package/src/tests/pi-native-mcp.test.ts

@@ -30,6 +30,17 @@ describe("toPiMcpServers", () => {
     });
   });
 
+  test("deferred maps every installed server to deferred exposure", () => {
+    const servers = toPiMcpServers(
+      {
+        local: { command: "context-mode" },
+        remote: { url: "https://mcp.example.com/mcp" },
+      },
+      { deferred: true },
+    );
+    expect(Object.values(servers).map((s) => s.exposure)).toEqual(["deferred", "deferred"]);
+  });
+
   test("no installed servers maps to an empty set", () => {
     expect(toPiMcpServers(null)).toEqual({});
   });
@@ -70,7 +81,8 @@ describe("PiMonoAdapter.createSession — native MCP for installed servers", ()
     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_TOOL_DEFERRAL;
+    // Direct exposure, so installed tools show up as active tool names.
+    process.env.PI_TOOL_DEFERRAL = "false";
     mkdirSync(join(dir, "agent"), { recursive: true });
   });
   afterEach(() => {

package/src/tests/pi-tool-exposure.test.ts

@@ -176,8 +176,8 @@ describe("pi resource loader trust", () => {
 });
 
 describe("PI_TOOL_DEFERRAL flag", () => {
-  test("defaults off and parses boolean literals", () => {
-    expect(isPiToolDeferralEnabled({})).toBe(false);
+  test("defaults on and parses boolean literals", () => {
+    expect(isPiToolDeferralEnabled({})).toBe(true);
     expect(isPiToolDeferralEnabled({ PI_TOOL_DEFERRAL: "true" })).toBe(true);
     expect(isPiToolDeferralEnabled({ PI_TOOL_DEFERRAL: "1" })).toBe(true);
     expect(isPiToolDeferralEnabled({ PI_TOOL_DEFERRAL: "false" })).toBe(false);
@@ -187,9 +187,9 @@ describe("PI_TOOL_DEFERRAL flag", () => {
     "traits.hasToolSearch follows the flag live",
     withEnv("PI_TOOL_DEFERRAL", undefined, () => {
       const adapter = new PiMonoAdapter();
-      expect(adapter.traits.hasToolSearch).toBe(false);
-      process.env.PI_TOOL_DEFERRAL = "true";
       expect(adapter.traits.hasToolSearch).toBe(true);
+      process.env.PI_TOOL_DEFERRAL = "false";
+      expect(adapter.traits.hasToolSearch).toBe(false);
     }),
   );
 });
@@ -259,8 +259,8 @@ describe("PiMonoAdapter.createSession — tool deferral wiring", () => {
   }
 
   test(
-    "flag on: non-core tools deferred and tool_search enabled by default",
-    withEnv("PI_TOOL_DEFERRAL", "true", async () => {
+    "flag unset: non-core tools deferred and tool_search enabled by default",
+    withEnv("PI_TOOL_DEFERRAL", undefined, async () => {
       const opts = await captureSessionOptions();
       const tools = opts.customTools as ToolDefinition[];
       expect(Object.fromEntries(tools.map((t) => [t.name, t.exposure]))).toEqual({
@@ -274,8 +274,8 @@ describe("PiMonoAdapter.createSession — tool deferral wiring", () => {
   );
 
   test(
-    "flag off: every tool declared and no tool_search",
-    withEnv("PI_TOOL_DEFERRAL", undefined, async () => {
+    "flag false: every tool declared and no tool_search",
+    withEnv("PI_TOOL_DEFERRAL", "false", async () => {
       const opts = await captureSessionOptions();
       const tools = opts.customTools as ToolDefinition[];
       expect(tools.map((t) => t.exposure)).toEqual([undefined, undefined, undefined]);

package/src/tests/probe-tool-schema-tokens.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  bareToolName,
+  controlReached,
+  countSwarmTools,
+  hasControlResult,
+  inputTokens,
+  toolNames,
+  turnOne,
+  withSessionDirs,
+} from "../../scripts/probe-tool-schema-tokens";
+
+describe("probe-tool-schema-tokens", () => {
+  let dir = "";
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("matches swarm tools under every harness naming", () => {
+    const swarm = new Set(["get_swarm", "store_progress"]);
+    expect(bareToolName("mcp__agent_swarm__get_swarm")).toBe("get_swarm");
+    expect(bareToolName("agent-swarm_store-progress")).toBe("store_progress");
+    expect(
+      countSwarmTools(["get-swarm", "mcp__agent_swarm__store_progress", "bash", "read"], swarm),
+    ).toBe(2);
+  });
+
+  test("lists tools in chat-completions and namespaced responses bodies", () => {
+    expect(toolNames({ tools: [{ type: "function", function: { name: "get-swarm" } }] })).toEqual([
+      "get-swarm",
+    ]);
+    const responses = {
+      input: [
+        {
+          type: "additional_tools",
+          tools: [{ type: "namespace", name: "functions", tools: [{ name: "exec" }] }],
+        },
+      ],
+      tools: [{ name: "wait" }],
+    };
+    expect(toolNames(responses).sort()).toEqual(["exec", "wait"]);
+  });
+
+  test("reads the last reported input token count from a stream", () => {
+    const sse = 'data: {"usage":null}\n\ndata: {"usage":{"prompt_tokens":90776}}\n';
+    expect(inputTokens(sse)).toBe(90776);
+    expect(inputTokens('{"response":{"usage":{"input_tokens":16629}}}')).toBe(16629);
+    expect(inputTokens("data: [DONE]")).toBeNull();
+  });
+
+  test("turn one skips side requests for other models", () => {
+    dir = mkdtempSync(join(tmpdir(), "probe-tool-schema-"));
+    writeFileSync(join(dir, "req-1.json"), JSON.stringify({ model: "openai/gpt-6-luna" }));
+    writeFileSync(join(dir, "res-1.txt"), '{"usage":{"prompt_tokens":453}}');
+    writeFileSync(
+      join(dir, "req-2.json"),
+      JSON.stringify({ model: "deepseek/deepseek-v4.1-flash", tools: [{ name: "bash" }] }),
+    );
+    writeFileSync(join(dir, "res-2.txt"), '{"usage":{"prompt_tokens":33115}}');
+    expect(turnOne(dir, "openrouter/deepseek/deepseek-v4.1-flash")).toEqual({
+      tokens: 33115,
+      names: ["bash"],
+    });
+  });
+
+  const found = "Found 5 agent(s) in the swarm. Requested by session: s1";
+
+  test("control passes only on a get-swarm tool output", () => {
+    dir = mkdtempSync(join(tmpdir(), "probe-tool-schema-"));
+    // The schema alone carries "in the swarm" in get-swarm's description.
+    const schemaOnly = {
+      model: "m",
+      tools: [
+        {
+          type: "function",
+          function: { name: "agent-swarm_get-swarm", description: "Lists agents in the swarm." },
+        },
+      ],
+      messages: [{ role: "user", content: "Call get-swarm. Found 5 agent(s) in the swarm." }],
+    };
+    expect(hasControlResult(schemaOnly)).toBe(false);
+    writeFileSync(join(dir, "req-1.json"), JSON.stringify(schemaOnly));
+    expect(controlReached(dir)).toBe(false);
+
+    const chat = {
+      ...schemaOnly,
+      messages: [
+        {
+          role: "assistant",
+          tool_calls: [{ id: "c1", type: "function", function: { name: "agent-swarm_get-swarm" } }],
+        },
+        { role: "tool", tool_call_id: "c1", content: [{ type: "text", text: found }] },
+      ],
+    };
+    expect(hasControlResult(chat)).toBe(true);
+    writeFileSync(join(dir, "req-2.json"), JSON.stringify(chat));
+    expect(controlReached(dir)).toBe(true);
+  });
+
+  test("control reads Responses items and rejects other tools and failed calls", () => {
+    const responses = (name: string, output: string) => ({
+      input: [
+        { type: "function_call", name, call_id: "call_1", arguments: "{}" },
+        { type: "function_call_output", call_id: "call_1", output },
+      ],
+    });
+    expect(hasControlResult(responses("mcp__agent_swarm__get_swarm", found))).toBe(true);
+    expect(hasControlResult(responses("mcp__agent_swarm__get_tasks", found))).toBe(false);
+    expect(hasControlResult(responses("mcp__agent_swarm__get_swarm", "Agent ID required."))).toBe(
+      false,
+    );
+    // An output for a different call id does not count.
+    const mismatched = responses("mcp__agent_swarm__get_swarm", found);
+    mismatched.input[1] = { type: "function_call_output", call_id: "call_2", output: found };
+    expect(hasControlResult(mismatched)).toBe(false);
+  });
+
+  test("session dirs: home is removed on success and on error, captures stay", async () => {
+    dir = mkdtempSync(join(tmpdir(), "probe-tool-schema-"));
+    let home = "";
+    const capDir = await withSessionDirs(dir, "ok", async (cap, h) => {
+      home = h;
+      writeFileSync(join(h, "config.toml"), "x");
+      writeFileSync(join(cap, "req-1.json"), "{}");
+      return cap;
+    });
+    expect(existsSync(home)).toBe(false);
+    expect(existsSync(join(capDir, "req-1.json"))).toBe(true);
+
+    await expect(
+      withSessionDirs(dir, "boom", async (cap, h) => {
+        home = h;
+        writeFileSync(join(h, "config.toml"), "x");
+        writeFileSync(join(cap, "req-1.json"), "{}");
+        throw new Error("codex exec exited 1");
+      }),
+    ).rejects.toThrow("codex exec exited 1");
+    expect(existsSync(home)).toBe(false);
+    expect(existsSync(join(dir, "boom-cap", "req-1.json"))).toBe(true);
+  });
+});

package/src/tests/prompt-template-session.test.ts

@@ -25,6 +25,7 @@ const SYSTEM_TEMPLATES = [
   "system.agent.context.bound_note",
   "system.agent.cursor.first_message",
   "system.agent.lead",
+  "system.agent.lead.docs",
   "system.agent.memory",
   "system.agent.memory.remote",
   "system.agent.outputs",
@@ -118,11 +119,11 @@ describe("Session templates: registration", () => {
     expect(sessionSystemEventTypes("session")).toEqual([...SESSION_TEMPLATES].sort());
   });
 
-  test("registers 32 system and session templates in total", () => {
+  test("registers 33 system and session templates in total", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 27 system blocks + 5 session composites.
-    expect(sessionSystem.length).toBe(32);
+    // 28 system blocks + 5 session composites.
+    expect(sessionSystem.length).toBe(33);
   });
 
   test("drops the v1 blocks that prompt v2 deleted", () => {

package/src/tests/request-composition-derive.test.ts

@@ -0,0 +1,329 @@
+import { describe, expect, test } from "bun:test";
+import {
+  type CompositionCall,
+  type CompositionManifest,
+  compositionCallsOf,
+  deriveCallCompositions,
+  staticTokens,
+} from "../../apps/ui/src/lib/request-composition";
+import type { CallUsage, NormalizedItem } from "../../apps/ui/src/logs-parser/types";
+
+const T0 = Date.parse("2026-10-26T10:00:00.000Z");
+
+function manifest(overrides: Partial<CompositionManifest> = {}): CompositionManifest {
+  return {
+    id: "m-0",
+    taskId: "task-1",
+    agentId: "agent-1",
+    sessionId: "s-1",
+    seq: 0,
+    provider: "claude",
+    model: null,
+    source: "worker",
+    parts: [
+      {
+        kind: "system_section",
+        id: "system.agent.role",
+        label: "role",
+        chars: 4000,
+        estTokens: 1000,
+        fidelity: "exact",
+      },
+      {
+        kind: "persona",
+        id: "persona",
+        label: "persona",
+        chars: 8000,
+        estTokens: 2000,
+        fidelity: "exact",
+      },
+      {
+        kind: "tool_schemas",
+        id: "mcp:agent-swarm",
+        label: "tools",
+        chars: 40000,
+        estTokens: 10000,
+        fidelity: "estimate",
+      },
+      {
+        kind: "skills_listing",
+        id: "skills_listing",
+        label: "skills",
+        chars: 4000,
+        estTokens: 1000,
+        fidelity: "estimate",
+      },
+      {
+        kind: "task_prompt",
+        id: "task_prompt",
+        label: "task",
+        chars: 2000,
+        estTokens: 500,
+        fidelity: "exact",
+      },
+      {
+        kind: "memories",
+        id: "memories",
+        label: "memories",
+        chars: 2000,
+        estTokens: 500,
+        fidelity: "exact",
+      },
+    ],
+    staticEstTokens: 15000,
+    tokenRatio: 1,
+    createdAt: new Date(T0 - 1000).toISOString(),
+    ...overrides,
+  };
+}
+
+function call(
+  callId: string,
+  promptTokens: number,
+  offsetMs: number,
+  extra: Partial<CallUsage> = {},
+  sessionId = "s-1",
+): CompositionCall {
+  return {
+    sessionId,
+    t: T0 + offsetMs,
+    usage: {
+      callId,
+      promptTokens,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      uncachedInputTokens: promptTokens,
+      outputTokens: 10,
+      sidechain: false,
+      harness: "claude",
+      reportedAt: "start",
+      ...extra,
+    },
+  };
+}
+
+function sum(tokens: { tokens: number }[]): number {
+  return tokens.reduce((acc, s) => acc + s.tokens, 0);
+}
+
+function tokensOf(segments: { group: string; tokens: number }[], group: string): number {
+  return segments.find((s) => s.group === group)?.tokens ?? 0;
+}
+
+describe("deriveCallCompositions", () => {
+  test("segments sum to each call's prompt tokens", () => {
+    const { byCall } = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 52_000, 1000), call("c3", 90_000, 2000)],
+      [manifest()],
+    );
+    for (const [id, prompt] of [
+      ["c1", 40_000],
+      ["c2", 52_000],
+      ["c3", 90_000],
+    ] as const) {
+      const comp = byCall.get(id);
+      expect(comp).toBeDefined();
+      expect(sum(comp!.segments)).toBeCloseTo(prompt, 6);
+      expect(comp!.scaled).toBe(false);
+    }
+  });
+
+  test("the first main call anchors the harness base; later calls add history", () => {
+    const { byCall, anchors } = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 52_000, 1000)],
+      [manifest()],
+    );
+    const first = byCall.get("c1")!;
+    expect(tokensOf(first.segments, "harness")).toBe(25_000);
+    expect(tokensOf(first.segments, "history")).toBe(0);
+    expect(tokensOf(first.segments, "task")).toBe(1000);
+    const second = byCall.get("c2")!;
+    expect(tokensOf(second.segments, "harness")).toBe(25_000);
+    expect(tokensOf(second.segments, "history")).toBe(12_000);
+    expect(anchors.get("m-0")).toEqual({
+      callId: "c1",
+      promptTokens: 40_000,
+      residualTokens: 25_000,
+    });
+  });
+
+  test("sub-agent calls are never the anchor and get no composition", () => {
+    const { byCall, anchors } = deriveCallCompositions(
+      [call("sub", 5_000, 0, { sidechain: true }), call("c1", 40_000, 1000)],
+      [manifest()],
+    );
+    expect(byCall.has("sub")).toBe(false);
+    expect(anchors.get("m-0")?.callId).toBe("c1");
+    expect(tokensOf(byCall.get("c1")!.segments, "harness")).toBe(25_000);
+  });
+
+  test("a compaction starts a new anchor whose harness base never grows", () => {
+    const compactions = [{ sessionId: "s-1", t: T0 + 1500 }];
+    // Post-compaction prompt carries a 6k summary: it is history, not harness.
+    const grown = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 120_000, 1000), call("c3", 46_000, 2000)],
+      [manifest()],
+      compactions,
+    );
+    const post = grown.byCall.get("c3")!;
+    expect(tokensOf(post.segments, "harness")).toBe(25_000);
+    expect(tokensOf(post.segments, "history")).toBe(6_000);
+    // The rail's "first call" stays the session's first call.
+    expect(grown.anchors.get("m-0")?.callId).toBe("c1");
+
+    // The harness dropped part of its base after compacting: the base shrinks.
+    const shrunk = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c3", 30_000, 2000), call("c4", 33_000, 3000)],
+      [manifest()],
+      compactions,
+    );
+    expect(tokensOf(shrunk.byCall.get("c3")!.segments, "harness")).toBe(15_000);
+    expect(tokensOf(shrunk.byCall.get("c4")!.segments, "history")).toBe(3_000);
+    // Control: without the compaction, the base stays at the first call's.
+    const control = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c3", 30_000, 2000)],
+      [manifest()],
+    );
+    expect(tokensOf(control.byCall.get("c3")!.segments, "harness")).toBe(
+      25_000 * (30_000 / 40_000),
+    );
+  });
+
+  test("nothing goes negative when the estimates overshoot the prompt", () => {
+    const { byCall } = deriveCallCompositions(
+      [call("c1", 9_000, 0), call("c2", 7_500, 1000)],
+      [manifest()],
+    );
+    for (const id of ["c1", "c2"]) {
+      const comp = byCall.get(id)!;
+      expect(comp.scaled).toBe(true);
+      for (const seg of comp.segments) expect(seg.tokens).toBeGreaterThan(0);
+      expect(tokensOf(comp.segments, "harness")).toBe(0);
+      expect(tokensOf(comp.segments, "history")).toBe(0);
+    }
+    expect(sum(byCall.get("c1")!.segments)).toBeCloseTo(9_000, 6);
+    expect(sum(byCall.get("c2")!.segments)).toBeCloseTo(7_500, 6);
+  });
+
+  test("the token ratio scales the static parts", () => {
+    const m = manifest({ tokenRatio: 1.2 });
+    expect(staticTokens(m)).toBeCloseTo(18_000, 6);
+    const { byCall } = deriveCallCompositions([call("c1", 40_000, 0)], [m]);
+    expect(tokensOf(byCall.get("c1")!.segments, "tools")).toBeCloseTo(12_000, 6);
+    expect(tokensOf(byCall.get("c1")!.segments, "harness")).toBeCloseTo(22_000, 6);
+  });
+
+  test("each session uses its own manifest; a later seq applies from its write time", () => {
+    const s2 = manifest({ id: "m-s2", sessionId: "s-2", parts: manifest().parts.slice(0, 1) });
+    const seq1 = manifest({
+      id: "m-1",
+      seq: 1,
+      createdAt: new Date(T0 + 1500).toISOString(),
+      parts: manifest().parts.slice(0, 2),
+    });
+    const { byCall } = deriveCallCompositions(
+      [
+        call("c1", 40_000, 0),
+        call("c2", 41_000, 2000),
+        call("d1", 20_000, 0, {}, "s-2"),
+        call("x1", 20_000, 0, {}, "s-unknown"),
+      ],
+      [manifest(), seq1, s2],
+    );
+    expect(byCall.get("c1")!.manifest.id).toBe("m-0");
+    expect(byCall.get("c2")!.manifest.id).toBe("m-1");
+    expect(byCall.get("d1")!.manifest.id).toBe("m-s2");
+    expect(tokensOf(byCall.get("d1")!.segments, "harness")).toBe(19_000);
+    expect(byCall.has("x1")).toBe(false);
+    for (const comp of byCall.values())
+      expect(sum(comp.segments)).toBeCloseTo(comp.promptTokens, 6);
+  });
+
+  test("a hook manifest after the first call keeps later growth as history", () => {
+    // The worker manifest (15k static) anchors c1. The harness hook then posts
+    // exact parts worth 40k, the whole first prompt. c2's extra 12k is history.
+    const hook = manifest({
+      id: "m-hook",
+      seq: 1,
+      source: "harness-hook",
+      createdAt: new Date(T0 + 500).toISOString(),
+      parts: [{ ...manifest().parts[0]!, estTokens: 40_000, fidelity: "exact" }],
+    });
+    const { byCall, anchors } = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 52_000, 1000)],
+      [manifest(), hook],
+    );
+    const second = byCall.get("c2")!;
+    expect(second.manifest.id).toBe("m-hook");
+    expect(tokensOf(second.segments, "harness")).toBe(0);
+    expect(tokensOf(second.segments, "history")).toBe(12_000);
+    expect(sum(second.segments)).toBeCloseTo(52_000, 6);
+    expect(anchors.get("m-hook")).toEqual({
+      callId: "c1",
+      promptTokens: 40_000,
+      residualTokens: 0,
+    });
+    // After a compaction the re-split base still caps the harness base: the
+    // 6k summary is history.
+    const compacted = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 52_000, 1000), call("c3", 46_000, 2000)],
+      [manifest(), hook],
+      [{ sessionId: "s-1", t: T0 + 1500 }],
+    );
+    expect(tokensOf(compacted.byCall.get("c3")!.segments, "harness")).toBe(0);
+    expect(tokensOf(compacted.byCall.get("c3")!.segments, "history")).toBe(6_000);
+    // A hook manifest smaller than the first prompt leaves the rest as harness.
+    const partial = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 52_000, 1000)],
+      [manifest(), { ...hook, parts: [{ ...hook.parts[0]!, estTokens: 30_000 }] }],
+    );
+    expect(tokensOf(partial.byCall.get("c2")!.segments, "harness")).toBe(10_000);
+    expect(tokensOf(partial.byCall.get("c2")!.segments, "history")).toBe(12_000);
+  });
+
+  test("a later worker manifest keeps the harness base and swaps only the static parts", () => {
+    // m-0 has 15k static, so c1 (40k) measures a 25k harness base. A worker
+    // manifest then re-estimates the static parts as 16k. c2's history is
+    // 55k − 16k − 25k = 14k.
+    const part = manifest().parts[0]!;
+    const first = manifest({ parts: [{ ...part, estTokens: 15_000 }] });
+    const second = manifest({
+      id: "m-1",
+      seq: 1,
+      createdAt: new Date(T0 + 500).toISOString(),
+      parts: [{ ...part, estTokens: 16_000 }],
+    });
+    const { byCall, anchors } = deriveCallCompositions(
+      [call("c1", 40_000, 0), call("c2", 55_000, 1000)],
+      [first, second],
+    );
+    const c2 = byCall.get("c2")!;
+    expect(c2.manifest.id).toBe("m-1");
+    expect(tokensOf(c2.segments, "harness")).toBe(25_000);
+    expect(tokensOf(c2.segments, "history")).toBe(14_000);
+    expect(sum(c2.segments)).toBeCloseTo(55_000, 6);
+    expect(anchors.get("m-1")).toEqual({
+      callId: "c1",
+      promptTokens: 40_000,
+      residualTokens: 25_000,
+    });
+  });
+
+  test("no manifests means no compositions", () => {
+    expect(deriveCallCompositions([call("c1", 40_000, 0)], []).byCall.size).toBe(0);
+  });
+});
+
+describe("compositionCallsOf", () => {
+  test("keeps call_usage items whose record has a session", () => {
+    const base = { fileIndex: 0, iteration: 1, lineNumber: 1, createdAt: "", t: T0, cli: "claude" };
+    const usage = call("c1", 100, 0).usage;
+    const items: NormalizedItem[] = [
+      { ...base, recId: "r1", kind: "call_usage", usage },
+      { ...base, recId: "r2", kind: "call_usage", usage: { ...usage, callId: "c2" } },
+      { ...base, recId: "r1", kind: "text", text: "hi" },
+    ];
+    const calls = compositionCallsOf(items, (recId) => (recId === "r1" ? "s-1" : undefined));
+    expect(calls).toEqual([{ usage, sessionId: "s-1", t: T0 }]);
+  });
+});

package/src/tests/script-connections.test.ts

@@ -653,6 +653,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "241_skills_meta_fts.sql");
       // 244 alters api_key_status, which this migration-112-only fixture does not create.
       markMigrationApplied(database, "244_api_key_validation.sql");
+      // 245 alters scripts, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "245_script_executor.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/script-executor-conformance.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, describe, expect, test } from "bun:test";
+import { afterAll, describe, expect, spyOn, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -402,6 +402,41 @@ describe("native-only executor behavior", () => {
     expect(output.error).toBe("killed");
   });
 
+  // Before the fix the abort listener was added after the file writes, so an
+  // abort that landed during them was missed and the script ran to the end.
+  test.skipIf(SKIP_SANDBOX_SPAWN_TESTS)(
+    "an abort while args.json is written kills the run before the script starts",
+    async () => {
+      const dir = await mkdtemp(join(tmpdir(), "native-abort-"));
+      const marker = join(dir, "side-effect.marker");
+      const controller = new AbortController();
+      const write = Bun.write;
+      const spy = spyOn(Bun, "write").mockImplementation((async (
+        ...writeArgs: Parameters<typeof Bun.write>
+      ) => {
+        const written = await write(...writeArgs);
+        if (String(writeArgs[0]).endsWith("/args.json")) controller.abort();
+        return written;
+      }) as typeof Bun.write);
+      try {
+        const output = await new NativeScriptExecutor().run(
+          input({
+            source: `export default async () => { await Bun.write(${JSON.stringify(marker)}, "ran"); return "ran"; };`,
+            signal: controller.signal,
+            resources: { ...DEFAULT_SCRIPT_RESOURCES, memoryMb: 2048, wallClockMs: 10_000 },
+          }),
+        );
+        expect(output.error).toBe("killed");
+        expect(output.result).toBeUndefined();
+        expect(await Bun.file(marker).exists()).toBe(false);
+      } finally {
+        spy.mockRestore();
+        await rm(dir, { recursive: true, force: true });
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
   // PR #1326 review finding: exit 134 (SIGABRT) was classified `capacity_exceeded`
   // — and therefore retried by `runScript` — purely from the exit code, with no
   // evidence about *when* the abort happened. A script that causes a side effect