@pi-archimedes/subagent 2.10.3 → 2.11.0

package/src/row-block.ts

@@ -0,0 +1,186 @@
+/**
+ * Width-aware rows for the subagent tool's transcript rows.
+ *
+ * pi draws a tool row at the width it is rendering at: bash truncates inside
+ * `VisualLinePreview`/`truncateToVisualLines`, which are handed `render(width)`'s
+ * width. That module is not importable (pi's export map is `.` and `./rpc-entry`),
+ * so the rows here get the same behaviour from pi-tui's own helpers — the
+ * sanctioned route, per ADR 0029 ("width maths goes through pi-tui helpers").
+ *
+ * Two kinds of content, because the subagent draws two kinds of thing:
+ *
+ *   * a **row** — one logical line: the agent label, the stats line, the activity
+ *     line, the outcome line. It is cut at the render width, so it fills the
+ *     frame and truncates there, exactly like the bash row. Leaving it uncapped
+ *     inside a `Text` is not the fix: `Text.render(width)` *wraps*, so a long task
+ *     would become a multi-row block instead of one full-width row.
+ *   * a **block** — multi-line content that is meant to be read in full (the
+ *     expanded view's output, its task text, its tool-call history). It wraps,
+ *     as it always has (ADR 0020: expanded output is deliberately untruncated).
+ *
+ * The width therefore arrives per-render and nothing is cached across renders
+ * except keyed by (content, width).
+ */
+
+import { Text, sliceByColumn, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+/** The marker appended to a row that was cut. Plain text, so it inherits colour. */
+export const ROW_ELLIPSIS = "...";
+
+/** SGR reset, appended after a cut so the row's padding is not painted. */
+const RESET = "\x1b[0m";
+
+/** How `Text` renders a tab; kept identical so short rows stay byte-identical. */
+const TAB_WIDTH = 3;
+
+/** `row`: one line, truncated to the frame. `block`: wrapped, never cut. */
+export type RowKind = "row" | "block";
+
+export interface RowSegment {
+  readonly kind: RowKind;
+  readonly text: string;
+}
+
+/** One logical line that must stay one line at any width. */
+export function row(text: string): RowSegment {
+  return { kind: "row", text };
+}
+
+/**
+ * What the row builders draw into: the two ways content reaches a `RowBlock`.
+ * Kept as a projection of `RowBlock` so a builder cannot ask for anything a row
+ * does not do (no `tui`, no width, no renderer — see ADR 0027).
+ */
+export type RowSink = Pick<RowBlock, "setText" | "setSegments">;
+
+/** Multi-line content that keeps pi-tui's wrapping. */
+export function block(text: string): RowSegment {
+  return { kind: "block", text };
+}
+
+/** Treat every logical line of `text` as a row (the compact view is all rows). */
+export function rowsFromText(text: string): RowSegment[] {
+  return text.split("\n").map(row);
+}
+
+/**
+ * Cut one styled row to `width` display cells.
+ *
+ * The ellipsis stays inside the styled span — the property the old character-based
+ * `truncLine` existed to keep, and the reason `truncateToWidth` is not used for
+ * the cut: it emits `…\x1b[0m…`, i.e. the dots land *after* a colour reset, so a
+ * truncated span loses its colour (`row-block.test.ts` pins those bytes).
+ * `sliceByColumn` cuts on display cells instead — wide glyphs and emoji included —
+ * and leaves the ANSI state open where it cuts, so a plain `"..."` appended after
+ * it inherits whatever colour the row was drawing at that point. The trailing
+ * reset then closes what was left open, so the row's padding is not painted.
+ *
+ * A newline is a hard boundary: the row stops at the first one rather than
+ * bleeding into the next row, and says so with the ellipsis.
+ */
+export function truncateRow(line: string, width: number): string {
+  if (width <= 0) return "";
+  const nlIdx = line.indexOf("\n");
+  const firstLine = nlIdx === -1 ? line : line.slice(0, nlIdx);
+  if (nlIdx === -1 && visibleWidth(firstLine) <= width) return firstLine;
+
+  const budget = width - ROW_ELLIPSIS.length;
+  // No room for both content and dots: show as many dots as the frame holds, so
+  // the row still reads as "cut" rather than as "the whole task".
+  if (budget <= 0) return sliceByColumn(ROW_ELLIPSIS, 0, width, true);
+  return sliceByColumn(firstLine, 0, budget, true) + ROW_ELLIPSIS + RESET;
+}
+
+/** Pad a rendered line out to the frame, the way `Text` does. */
+function padToWidth(line: string, width: number): string {
+  const used = visibleWidth(line);
+  return used >= width ? line : line + " ".repeat(width - used);
+}
+
+/**
+ * The rows of one subagent result, truncated at the width pi renders them at.
+ *
+ * A `Text` subclass, because everything that already knows how to hold a row —
+ * pi's own tool shell, and this package's `setText`-shaped renderers — expects
+ * one. `setText` treats every logical line as a row; `setSegments` is for the
+ * views that mix rows with wrapped blocks (expanded).
+ */
+export class RowBlock extends Text {
+  private segments: RowSegment[];
+  private content: string;
+  private cacheKey: string | undefined;
+  private cacheWidth: number | undefined;
+  private cacheLines: string[] | undefined;
+
+  constructor(text = "") {
+    // Edge-to-edge: pi's tool shell supplies the row's inset (a Box with its own
+    // padding), exactly as it did for the `Text` this replaces.
+    super(text, 0, 0);
+    this.segments = rowsFromText(text);
+    this.content = text;
+  }
+
+  /** Every logical line of `text` is a row. */
+  override setText(text: string): void {
+    super.setText(text);
+    this.content = text;
+    this.segments = rowsFromText(text);
+    this.cacheKey = undefined;
+    this.cacheWidth = undefined;
+    this.cacheLines = undefined;
+  }
+
+  /** Mixed content: rows truncated to the frame, blocks wrapped. */
+  setSegments(segments: RowSegment[]): void {
+    const text = segments.map((segment) => segment.text).join("\n");
+    super.setText(text);
+    this.content = text;
+    this.segments = segments;
+    this.cacheKey = undefined;
+    this.cacheWidth = undefined;
+    this.cacheLines = undefined;
+  }
+
+  override invalidate(): void {
+    super.invalidate();
+    this.cacheKey = undefined;
+    this.cacheWidth = undefined;
+    this.cacheLines = undefined;
+  }
+
+  override render(width: number): string[] {
+    // Cached across frames exactly the way `Text` caches: by content and width,
+    // because the duration in a running row changes the content between frames.
+    if (
+      this.cacheLines !== undefined &&
+      this.cacheKey === this.content &&
+      this.cacheWidth === width
+    ) {
+      return this.cacheLines;
+    }
+    const lines = this.layout(Math.max(1, width));
+    this.cacheKey = this.content;
+    this.cacheWidth = width;
+    this.cacheLines = lines;
+    return lines;
+  }
+
+  private layout(width: number): string[] {
+    // Nothing but blanks to draw: render no lines at all, matching `Text`.
+    if (this.segments.length === 0 || this.segments.every((s) => s.text.trim() === "")) {
+      return [];
+    }
+    const lines: string[] = [];
+    for (const segment of this.segments) {
+      const text = segment.text.replace(/\t/g, " ".repeat(TAB_WIDTH));
+      if (segment.kind === "block") {
+        for (const wrapped of wrapTextWithAnsi(text, width)) {
+          lines.push(padToWidth(wrapped, width));
+        }
+      } else {
+        lines.push(padToWidth(truncateRow(text, width), width));
+      }
+    }
+    return lines;
+  }
+}

package/src/run-outcome.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { decideRunOutcome } from "./run-outcome.js";
+
+// The decision table, pinned where it lives. Every row is a case the child can
+// actually produce on pi 1.2.0 — see the table comment in `run-outcome.ts` for
+// where each one comes from.
+
+const SETTLED = { settledAborted: false, stopReason: undefined, exitCode: 0, signal: undefined };
+
+describe("decideRunOutcome", () => {
+  it("completed: exit 0, clean stopReason, settled not aborted", () => {
+    expect(decideRunOutcome({ ...SETTLED, stopReason: "stop" })).toBe("completed");
+    expect(decideRunOutcome(SETTLED)).toBe("completed");
+  });
+
+  it("truncated: stopReason length, whether the child exited 0 (json mode) or 1 (print mode)", () => {
+    expect(decideRunOutcome({ ...SETTLED, stopReason: "length" })).toBe("truncated");
+    expect(decideRunOutcome({ ...SETTLED, stopReason: "length", exitCode: 1 })).toBe("truncated");
+  });
+
+  it("aborted: agent_settled.aborted wins over a clean stopReason and a nonzero exit", () => {
+    expect(decideRunOutcome({ ...SETTLED, settledAborted: true })).toBe("aborted");
+    expect(decideRunOutcome({ ...SETTLED, settledAborted: true, exitCode: 143 })).toBe("aborted");
+    expect(decideRunOutcome({ ...SETTLED, settledAborted: true, stopReason: "length" })).toBe("aborted");
+  });
+
+  it("aborted: the provider aborted the last response", () => {
+    expect(decideRunOutcome({ ...SETTLED, stopReason: "aborted" })).toBe("aborted");
+  });
+
+  it("aborted: killed by a cancellation signal before it could settle", () => {
+    const killed = { ...SETTLED, exitCode: null };
+    expect(decideRunOutcome({ ...killed, signal: "SIGTERM" })).toBe("aborted");
+    expect(decideRunOutcome({ ...killed, signal: "SIGKILL" })).toBe("aborted");
+    expect(decideRunOutcome({ ...killed, signal: "SIGHUP" })).toBe("aborted");
+    expect(decideRunOutcome({ ...killed, signal: "SIGINT" })).toBe("aborted");
+  });
+
+  it("aborted: pi's own signal handlers exit 143/129 instead of dying by the signal", () => {
+    // Observed against a real 1.2.0 child SIGTERM'd mid-run: `close` reported
+    // code 143 and NO signal, because print mode catches SIGTERM/SIGHUP and
+    // calls process.exit(143)/process.exit(129) itself
+    // (`dist/modes/print-mode.js`, registerSignalHandlers). Reading only
+    // `signal` would call a cancellation a failure.
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 143 })).toBe("aborted");
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 129 })).toBe("aborted");
+    // A completed last response does not make a cancelled child un-cancelled.
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 143, stopReason: "stop" })).toBe("aborted");
+    // And it outranks the shapes a cancellation can leave behind on the way out.
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 143, stopReason: "error" })).toBe("aborted");
+  });
+
+  it("failed: the child's last response errored, whatever the exit code says", () => {
+    expect(decideRunOutcome({ ...SETTLED, stopReason: "error", exitCode: 1 })).toBe("failed");
+    expect(decideRunOutcome({ ...SETTLED, stopReason: "error", exitCode: 0 })).toBe("failed");
+  });
+
+  it("failed: a nonzero exit with no run behind it", () => {
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 1 })).toBe("failed");
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 2 })).toBe("failed");
+    // 130 (SIGINT) is NOT one of pi's handler exits — SIGINT is uncaught, so it
+    // arrives as a signal death above; anything else stays a failure.
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 130 })).toBe("failed");
+    expect(decideRunOutcome({ ...SETTLED, exitCode: 137 })).toBe("failed");
+  });
+
+  it("failed: a crash on an unexpected signal is not someone cancelling", () => {
+    expect(decideRunOutcome({ ...SETTLED, exitCode: null, signal: "SIGSEGV" })).toBe("failed");
+    expect(decideRunOutcome({ ...SETTLED, exitCode: null, signal: undefined })).toBe("failed");
+  });
+});

package/src/run-outcome.ts

@@ -0,0 +1,84 @@
+import type { RunOutcome } from "./types.js";
+
+// ── The *Run outcome* decision table (CONTEXT.md vocabulary, ADR 0028) ──────
+//
+// The child's exit code cannot tell these apart, and after pi 1.2.0 it cannot
+// even be trusted to mean "failed": print mode exits **1** when the final
+// response hit the output token limit, so a useful-but-cut-off answer arrives as
+// the same `1` as a crash. `stream.ts` used to reduce the child to `code ?? 1`,
+// which destroyed that distinction exactly where the plan says it must not.
+//
+// The two signals that do carry it are the child's own `stopReason` (on the last
+// assistant `message_end`) and pi 1.1.0's `agent_settled.aborted`. Note that
+// `--mode json` — what the child actually runs — does *not* map `stopReason` onto
+// the exit code at all (that mapping lives in print mode's text branch), so a
+// json child reports truncation through `stopReason` alone and exits 0. Both
+// shapes are handled: truncation is read from the child, never inferred from
+// the code.
+//
+// | input                                                       | outcome     |
+// |-------------------------------------------------------------|-------------|
+// | `agent_settled.aborted: true`                               | aborted     |
+// | last assistant `stopReason: "aborted"`                      | aborted     |
+// | killed by a cancellation signal (SIGKILL/SIGINT — uncaught) | aborted     |
+// | killed by an unexpected signal (SIGSEGV, …)                 | failed      |
+// | exit 143 / 129 (pi caught SIGTERM / SIGHUP and exited)      | aborted     |
+// | last assistant `stopReason: "error"`                        | failed      |
+// | last assistant `stopReason: "length"` — exit 0 **or** 1     | truncated   |
+// | any other nonzero exit                                      | failed      |
+// | exit 0, nothing above matched                               | completed   |
+//
+// `truncated` is not an error and neither is `aborted`; `failed` is, and is what
+// the caller reports as one (the result carries no outcome in that case).
+
+/** Signals that mean "someone cancelled this run", as opposed to "it broke". */
+const CANCELLATION_SIGNALS = new Set(["SIGTERM", "SIGKILL", "SIGHUP", "SIGINT"]);
+
+/**
+ * The same cancellation, arriving as an exit code instead of a signal.
+ *
+ * print mode catches SIGTERM (and SIGHUP on non-Windows) and exits by itself —
+ * `process.exit(signal === "SIGHUP" ? 129 : 143)`
+ * (`pi-coding-agent/dist/modes/print-mode.js`, `registerSignalHandlers`) — so a
+ * real SIGTERM'd child closes with code 143 and **no** signal, which the table
+ * would otherwise read as an ordinary failure. Verified against a live 1.2.0
+ * child killed mid-run. SIGINT is not caught, so it still arrives as a signal
+ * death; SIGKILL cannot be caught at all. Hence exactly these two codes.
+ */
+const CANCELLATION_EXIT_CODES = new Set([143, 129]);
+
+export interface RunOutcomeInput {
+  /** `agent_settled.aborted` seen on the child's event stream. */
+  settledAborted: boolean;
+  /** `stopReason` of the last assistant message the child emitted. */
+  stopReason: string | undefined;
+  /** Process exit code, or `null` when it was terminated by a signal. */
+  exitCode: number | null;
+  /** The terminating signal, when there was one. */
+  signal: string | undefined;
+}
+
+/**
+ * Decide the run's terminal state, or `failed` when the run did not reach one.
+ *
+ * Order is the table above: cancellation first (an aborted run's `stopReason` may
+ * be `error` or `length` on the way out), then a signal death — which is decided
+ * before `stopReason`, because a killed child's last message says nothing about
+ * how it died — then the child's own account of how its last response ended
+ * (`error`, then `length`), then the exit code, which is the least informative of
+ * the three and therefore last. That last ordering is the whole point of the
+ * 1.2.0 change: exit 1 arrives for a crash and for a truncated answer alike, so
+ * `length` has to be read before the exit code or the distinction is lost again.
+ */
+export function decideRunOutcome(input: RunOutcomeInput): RunOutcome | "failed" {
+  if (input.settledAborted) return "aborted";
+  if (input.stopReason === "aborted") return "aborted";
+  if (input.exitCode === null) {
+    return CANCELLATION_SIGNALS.has(input.signal ?? "") ? "aborted" : "failed";
+  }
+  if (CANCELLATION_EXIT_CODES.has(input.exitCode)) return "aborted";
+  if (input.stopReason === "error") return "failed";
+  if (input.stopReason === "length") return "truncated";
+  if (input.exitCode !== 0) return "failed";
+  return "completed";
+}

package/src/spawn.test.ts

@@ -1,18 +1,46 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
 import * as net from "node:net";
-import { getBus, Events } from "@pi-archimedes/core/bus";
-import { startAskSocketServer } from "./spawn.js";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import { Events } from "@pi-archimedes/core/events";
+import type { AgentConfig } from "./agents.js";
+
+// The child's argv is a contract with the `pi` CLI, and CLI strings are invisible
+// to tsc — these tests are the only guard on what the child actually receives.
+// `node:child_process` is mocked so no real pi process is spawned.
+const spawnMock = vi.hoisted(() => vi.fn());
+vi.mock("node:child_process", () => ({ spawn: spawnMock }));
+
+const { startAskSocketServer, spawnSubagent } = await import("./spawn.js");
 
 // startAskSocketServer is tested directly (not via spawnSubagent, which would
-// spawn a real `pi` process). The real bus is used — subscriptions are
-// unsubscribed in afterEach so they don't leak into other test files in the
-// same worker (the bus is a globalThis singleton).
+// spawn a real `pi` process). Each test gets its OWN bus stand-in — the host
+// handle is passed in rather than reached for, so there is no process-wide
+// singleton to leak between tests any more.
+
+/** Stands in for the host's `createEventBus()` (same emit/on/unsubscribe shape). */
+function fakeBus() {
+  const listeners = new Map<string, Array<(data: unknown) => void>>();
+  return {
+    emit(channel: string, data: unknown): void {
+      for (const handler of [...(listeners.get(channel) ?? [])]) handler(data);
+    },
+    on(channel: string, handler: (data: unknown) => void): () => void {
+      const subs = listeners.get(channel) ?? [];
+      subs.push(handler);
+      listeners.set(channel, subs);
+      return () => {
+        const current = listeners.get(channel) ?? [];
+        const idx = current.indexOf(handler);
+        if (idx !== -1) current.splice(idx, 1);
+      };
+    },
+  };
+}
 
 const cleanups: Array<() => void> = [];
-const unsubs: Array<() => void> = [];
 
 afterEach(() => {
-  unsubs.splice(0).forEach((u) => u());
   cleanups.splice(0).forEach((c) => c());
 });
 
@@ -20,6 +48,83 @@ function track(fn: () => void): void {
   cleanups.push(fn);
 }
 
+// ── spawnSubagent argv ──────────────────────────────────────────────────────
+
+/** A minimal spawn target: the argv assertions never touch the process. */
+function fakeSpawnResult(): ChildProcess {
+  const child = new EventEmitter() as ChildProcess & { pid: number };
+  Object.assign(child, { pid: 4242, killed: false, kill: () => true });
+  return child;
+}
+
+/** Run spawnSubagent against the mocked spawn and return the argv it received. */
+function argvFor(agent: Partial<AgentConfig> | undefined): string[] {
+  spawnMock.mockReset();
+  spawnMock.mockReturnValue(fakeSpawnResult());
+  const events = fakeBus();
+  const socket = startAskSocketServer(agent?.name ?? "general", events);
+  track(socket.cleanup);
+  spawnSubagent({
+    task: "do the thing",
+    model: undefined,
+    activeModel: undefined,
+    cwd: "/tmp",
+    signal: undefined,
+    events,
+    agent: agent
+      ? { name: agent.name ?? "general", description: "d", systemPrompt: "p", source: "user", filePath: "/tmp/a.md", ...agent }
+      : undefined,
+  });
+  const call = spawnMock.mock.calls[0] as [string, string[]] | undefined;
+  if (!call) throw new Error("spawn was not called");
+  return call[1];
+}
+
+describe("spawnSubagent tool allowlist (closed set, ADR 0028)", () => {
+  afterEach(() => {
+    spawnMock.mockReset();
+  });
+
+  it("a non-empty tools allowlist also passes --no-mcp, so the list stays closed", () => {
+    const argv = argvFor({ tools: ["read", "bash"] });
+    expect(argv).toContain("--tools");
+    expect(argv[argv.indexOf("--tools") + 1]).toBe("read,bash");
+    expect(argv).toContain("--no-mcp");
+  });
+
+  it("mcp: true is the only way the allowlist stops being closed", () => {
+    const argv = argvFor({ tools: ["read", "bash"], mcp: true });
+    expect(argv).toContain("--tools");
+    expect(argv).not.toContain("--no-mcp");
+  });
+
+  it("an empty tools list changes neither the tool set nor MCP", () => {
+    const argv = argvFor({ tools: [] });
+    expect(argv).not.toContain("--tools");
+    expect(argv).not.toContain("--no-mcp");
+  });
+
+  it("mcp: true without an allowlist passes neither flag (nothing to close)", () => {
+    const argv = argvFor({ mcp: true });
+    expect(argv).not.toContain("--tools");
+    expect(argv).not.toContain("--no-mcp");
+  });
+
+  it("the recursion guard survives the closed allowlist", () => {
+    const argv = argvFor({ tools: ["read"] });
+    const excludeIdx = argv.indexOf("--exclude-tools");
+    expect(excludeIdx).toBeGreaterThan(-1);
+    expect(argv[excludeIdx + 1]).toContain("subagent");
+  });
+
+  it("an agent with no config at all gets neither --tools nor --no-mcp", () => {
+    const argv = argvFor(undefined);
+    expect(argv).not.toContain("--tools");
+    expect(argv).not.toContain("--no-mcp");
+    expect(argv).toContain("--exclude-tools");
+  });
+});
+
 function connectClient(socketPath: string): Promise<net.Socket> {
   return new Promise((resolve, reject) => {
     const client = net.connect(socketPath, () => resolve(client));
@@ -40,12 +145,13 @@ function writeAskRequest(client: net.Socket, requestId: string, toolCallId?: str
 
 describe("startAskSocketServer", () => {
   it("a child ask_request carrying toolCallId → the bus ASK_REQUEST carries the same toolCallId", async () => {
-    const { socketPath, cleanup } = startAskSocketServer("test-agent");
+    const events = fakeBus();
+    const { socketPath, cleanup } = startAskSocketServer("test-agent", events);
     track(cleanup);
     await new Promise((r) => setTimeout(r, 50)); // let the server listen
 
     const requests: unknown[] = [];
-    unsubs.push(getBus().on(Events.ASK_REQUEST, (p) => requests.push(p)));
+    events.on(Events.ASK_REQUEST, (p) => requests.push(p));
 
     const client = await connectClient(socketPath);
     writeAskRequest(client, "req-1", "tool-9");
@@ -57,9 +163,9 @@ describe("startAskSocketServer", () => {
     expect(req.toolCallId).toBe("tool-9");
     expect(req.questions).toEqual([{ id: "q1", question: "Which?", options: [{ label: "A" }] }]);
 
-    // Deliver the response (drains pending) before closing so no ASK_CANCEL
-    // leaks onto the global bus queue for the next test
-    getBus().emit(Events.ASK_RESPONSE, {
+    // Deliver the response (drains pending) before closing so no ASK_CANCEL is
+    // signalled for a request that was already answered.
+    events.emit(Events.ASK_RESPONSE, {
       requestId: "req-1",
       cancelled: false,
       results: [{ id: "q1", selectedOptions: ["A"] }],
@@ -69,15 +175,60 @@ describe("startAskSocketServer", () => {
     await new Promise((r) => setTimeout(r, 50)); // close handler ran (no-op)
   });
 
+  /**
+   * The ask round-trip, over the handle: the child's socket request goes out on
+   * the bus, the answer comes back on the SAME handle, and the server writes it
+   * back down the socket. Before this migration both halves went through the
+   * suite's `globalThis` bus; the transport changed, the socket contract did not.
+   */
+  it("round-trip: ask_request in → ASK_REQUEST out on the handle → ASK_RESPONSE in → ask_response back down the socket", async () => {
+    const events = fakeBus();
+    const { socketPath, cleanup } = startAskSocketServer("test-agent", events);
+    track(cleanup);
+    await new Promise((r) => setTimeout(r, 50));
+
+    const frames: unknown[] = [];
+    const requests: unknown[] = [];
+    events.on(Events.ASK_REQUEST, (p) => requests.push(p));
+
+    const client = await connectClient(socketPath);
+    client.on("data", (chunk) => {
+      for (const line of chunk.toString("utf-8").split("\n")) {
+        if (line.trim()) frames.push(JSON.parse(line));
+      }
+    });
+
+    writeAskRequest(client, "req-rt", "tool-rt");
+    await vi.waitFor(() => expect(requests.length).toBe(1));
+
+    events.emit(Events.ASK_RESPONSE, {
+      requestId: "req-rt",
+      cancelled: false,
+      results: [{ id: "q1", selectedOptions: ["A"], customInput: undefined }],
+    });
+
+    await vi.waitFor(() => expect(frames.length).toBe(1));
+    expect(frames[0]).toEqual({
+      type: "ask_response",
+      requestId: "req-rt",
+      cancelled: false,
+      results: [{ id: "q1", selectedOptions: ["A"] }],
+    });
+
+    client.destroy();
+    await new Promise((r) => setTimeout(r, 50));
+  });
+
   it("closing the child socket → ASK_CANCEL for the pending requestId + source", async () => {
-    const { socketPath, cleanup } = startAskSocketServer("test-agent");
+    const events = fakeBus();
+    const { socketPath, cleanup } = startAskSocketServer("test-agent", events);
     track(cleanup);
     await new Promise((r) => setTimeout(r, 50)); // let the server listen
 
     const cancels: unknown[] = [];
-    unsubs.push(getBus().on(Events.ASK_CANCEL, (p) => cancels.push(p)));
+    events.on(Events.ASK_CANCEL, (p) => cancels.push(p));
     const requests: unknown[] = [];
-    unsubs.push(getBus().on(Events.ASK_REQUEST, (p) => requests.push(p)));
+    events.on(Events.ASK_REQUEST, (p) => requests.push(p));
 
     const client = await connectClient(socketPath);
     writeAskRequest(client, "req-2");
@@ -91,21 +242,22 @@ describe("startAskSocketServer", () => {
   });
 
   it("no ASK_CANCEL once the response has already been delivered (pending drained)", async () => {
-    const { socketPath, cleanup } = startAskSocketServer("test-agent");
+    const events = fakeBus();
+    const { socketPath, cleanup } = startAskSocketServer("test-agent", events);
     track(cleanup);
     await new Promise((r) => setTimeout(r, 50)); // let the server listen
 
     const cancels: unknown[] = [];
-    unsubs.push(getBus().on(Events.ASK_CANCEL, (p) => cancels.push(p)));
+    events.on(Events.ASK_CANCEL, (p) => cancels.push(p));
     const requests: unknown[] = [];
-    unsubs.push(getBus().on(Events.ASK_REQUEST, (p) => requests.push(p)));
+    events.on(Events.ASK_REQUEST, (p) => requests.push(p));
 
     const client = await connectClient(socketPath);
     writeAskRequest(client, "req-3");
     await vi.waitFor(() => expect(requests.length).toBe(1));
 
     // Deliver the response (drains pending) before the socket closes
-    getBus().emit(Events.ASK_RESPONSE, {
+    events.emit(Events.ASK_RESPONSE, {
       requestId: "req-3",
       cancelled: false,
       results: [{ id: "q1", selectedOptions: ["A"] }],
@@ -117,3 +269,36 @@ describe("startAskSocketServer", () => {
     expect(cancels.length).toBe(0);
   });
 });
+
+// ── thinking level (pi warns and drops; we must not feed it one) ───────────
+
+describe("spawnSubagent thinking level", () => {
+  afterEach(() => {
+    spawnMock.mockReset();
+  });
+
+  it("passes a level pi accepts through to --thinking", () => {
+    const argv = argvFor({ thinking: "xhigh" });
+    const at = argv.indexOf("--thinking");
+    expect(at).toBeGreaterThan(-1);
+    expect(argv[at + 1]).toBe("xhigh");
+  });
+
+  it("does not pass a level pi would warn about and drop", () => {
+    // `--thinking ultra` is a `warning` diagnostic and a dropped flag in pi's
+    // own parser (dist/cli/args.js), so the child ran at the default thinking
+    // level while its config said otherwise — and in `--mode json` that warning
+    // is stderr, which the stream reader only shows for a failed run. Passing
+    // nothing is the same outcome, said out loud at dispatch instead.
+    const argv = argvFor({ thinking: "ultra" });
+    expect(argv).not.toContain("--thinking");
+  });
+
+  it("is case-sensitive, exactly like pi's list", () => {
+    expect(argvFor({ thinking: "Medium" })).not.toContain("--thinking");
+  });
+
+  it("passes no --thinking when the config sets none", () => {
+    expect(argvFor({})).not.toContain("--thinking");
+  });
+});