@stigmer/cli 3.35.0 → 3.37.0

package/src/resources/stream/diff.test.ts

@@ -1,338 +0,0 @@
-// Scenario tests for the snapshot→event differ. Each test drives a sequence of
-// AgentExecution snapshots through a single SnapshotDiffer and asserts the
-// resulting event sequence — the wire-parity contract with Go's streamToEvents.
-
-import { create } from "@bufbuild/protobuf";
-import { describe, expect, it } from "vitest";
-import {
-  AgentExecutionSchema,
-  AgentExecutionStatusSchema,
-  type AgentExecution,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { AgentExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
-import {
-  AgentMessageSchema,
-  ToolCallSchema,
-  type AgentMessage,
-  type ToolCall,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import {
-  SubAgentExecutionSchema,
-  type SubAgentExecution,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/subagent_pb";
-import { TodoItemSchema, type TodoItem } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/todo_pb";
-import {
-  PendingApprovalSchema,
-  type PendingApproval,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
-import {
-  ContextInfoSchema,
-  SummarizationEventSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/context_pb";
-import {
-  ExecutionPhase,
-  MessageType,
-  SubAgentStatus,
-  ToolCallStatus,
-  TodoStatus,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { SnapshotDiffer } from "./diff.js";
-import type { StreamEvent } from "./events.js";
-
-// --- Snapshot builders ---------------------------------------------------------
-
-interface SnapshotOpts {
-  message?: string;
-  phase?: ExecutionPhase;
-  messages?: AgentMessage[];
-  subAgents?: SubAgentExecution[];
-  todos?: Record<string, TodoItem>;
-  pendingApprovals?: PendingApproval[];
-  summarizations?: Array<{ source?: number; tokensBefore?: number; tokensAfter?: number }>;
-  error?: string;
-}
-
-function snapshot(opts: SnapshotOpts): AgentExecution {
-  const contextInfo =
-    opts.summarizations !== undefined
-      ? create(ContextInfoSchema, {
-          summarizationEvents: opts.summarizations.map((s) =>
-            create(SummarizationEventSchema, {
-              tokensBefore: s.tokensBefore ?? 0,
-              tokensAfter: s.tokensAfter ?? 0,
-            }),
-          ),
-        })
-      : undefined;
-
-  return create(AgentExecutionSchema, {
-    spec: create(AgentExecutionSpecSchema, { message: opts.message ?? "" }),
-    status: create(AgentExecutionStatusSchema, {
-      phase: opts.phase ?? ExecutionPhase.EXECUTION_IN_PROGRESS,
-      messages: opts.messages ?? [],
-      subAgentExecutions: opts.subAgents ?? [],
-      todos: opts.todos ?? {},
-      pendingApprovals: opts.pendingApprovals ?? [],
-      contextInfo,
-      error: opts.error ?? "",
-    }),
-  });
-}
-
-function aiMsg(content: string, opts: { streaming?: boolean; toolCalls?: ToolCall[] } = {}): AgentMessage {
-  return create(AgentMessageSchema, {
-    type: MessageType.MESSAGE_AI,
-    content,
-    isStreaming: opts.streaming ?? false,
-    toolCalls: opts.toolCalls ?? [],
-  });
-}
-
-function toolMsg(content: string, toolCalls: ToolCall[]): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_TOOL, content, toolCalls });
-}
-
-function humanMsg(content: string): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_HUMAN, content });
-}
-
-function systemMsg(content: string): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_SYSTEM, content });
-}
-
-function tool(id: string, name: string, status: ToolCallStatus, opts: { result?: string; isStreaming?: boolean } = {}): ToolCall {
-  return create(ToolCallSchema, { id, name, status, result: opts.result ?? "", isStreaming: opts.isStreaming ?? false });
-}
-
-function subAgent(
-  id: string,
-  status: SubAgentStatus,
-  opts: { name?: string; subject?: string; input?: string; output?: string; messages?: AgentMessage[] } = {},
-): SubAgentExecution {
-  return create(SubAgentExecutionSchema, {
-    id,
-    status,
-    name: opts.name ?? "researcher",
-    subject: opts.subject ?? "",
-    input: opts.input ?? "",
-    output: opts.output ?? "",
-    messages: opts.messages ?? [],
-  });
-}
-
-function todo(id: string, content: string, status: TodoStatus): TodoItem {
-  return create(TodoItemSchema, { id, content, status });
-}
-
-function approval(toolCallId: string, toolName: string, message: string): PendingApproval {
-  return create(PendingApprovalSchema, { toolCallId, toolName, message });
-}
-
-// Drive a snapshot sequence through one differ; return flattened event kinds.
-function kindsFor(snapshots: AgentExecution[]): string[] {
-  const differ = new SnapshotDiffer();
-  const out: string[] = [];
-  for (const s of snapshots) out.push(...differ.next(s).map((e) => e.kind));
-  return out;
-}
-
-// Drive a sequence and return the full event objects.
-function eventsFor(snapshots: AgentExecution[]): StreamEvent[] {
-  const differ = new SnapshotDiffer();
-  const out: StreamEvent[] = [];
-  for (const s of snapshots) out.push(...differ.next(s));
-  return out;
-}
-
-// --- Tests ---------------------------------------------------------------------
-
-describe("human message", () => {
-  it("emits once and suppresses the 'execute' placeholder", () => {
-    expect(kindsFor([snapshot({ message: "hi" }), snapshot({ message: "hi" })])).toEqual([
-      "humanMessage",
-      "phaseChange",
-    ]);
-    expect(kindsFor([snapshot({ message: "execute" })])).toEqual(["phaseChange"]);
-  });
-});
-
-describe("AI streaming lifecycle", () => {
-  it("start → delta → end across snapshots", () => {
-    const seq = [
-      snapshot({ messages: [aiMsg("Hel", { streaming: true })] }),
-      snapshot({ messages: [aiMsg("Hello", { streaming: true })] }),
-      snapshot({ messages: [aiMsg("Hello world", { streaming: false })] }),
-    ];
-    expect(kindsFor(seq)).toEqual(["aiStreamStart", "phaseChange", "aiStreamDelta", "aiStreamEnd"]);
-  });
-});
-
-describe("tool call interleaving", () => {
-  it("running tool is an orphan event, completion lands at the tool-message position", () => {
-    const seq = [
-      snapshot({ messages: [aiMsg("calling", { toolCalls: [tool("t1", "read", ToolCallStatus.TOOL_CALL_RUNNING)] })] }),
-      snapshot({
-        messages: [
-          aiMsg("calling", { toolCalls: [tool("t1", "read", ToolCallStatus.TOOL_CALL_COMPLETED, { result: "data" })] }),
-          toolMsg("data", [tool("t1", "read", ToolCallStatus.TOOL_CALL_COMPLETED, { result: "data" })]),
-        ],
-      }),
-    ];
-    expect(kindsFor(seq)).toEqual(["aiMessage", "toolRunning", "phaseChange", "toolCompleted"]);
-  });
-
-  it("first-sight terminal tool synthesizes a completion", () => {
-    const seq = [
-      snapshot({
-        messages: [toolMsg("data", [tool("t1", "read", ToolCallStatus.TOOL_CALL_COMPLETED, { result: "data" })])],
-      }),
-    ];
-    expect(kindsFor(seq)).toContain("toolCompleted");
-  });
-
-  it("running → interrupted closes the block with toolInterrupted, not toolCompleted", () => {
-    // Issue #207: the platform settles an in-flight call to INTERRUPTED when
-    // the execution terminalizes; the live differ must close its running block
-    // with the honest event (a checkmark would claim the tool finished).
-    const seq = [
-      snapshot({ messages: [aiMsg("calling", { toolCalls: [tool("t1", "shell", ToolCallStatus.TOOL_CALL_RUNNING)] })] }),
-      snapshot({ messages: [aiMsg("calling", { toolCalls: [tool("t1", "shell", ToolCallStatus.TOOL_CALL_INTERRUPTED)] })] }),
-    ];
-    const kinds = kindsFor(seq);
-    expect(kinds).toContain("toolInterrupted");
-    expect(kinds).not.toContain("toolCompleted");
-  });
-
-  it("first-sight interrupted tool (re-attach) synthesizes toolInterrupted", () => {
-    const seq = [
-      snapshot({
-        messages: [toolMsg("", [tool("t1", "read", ToolCallStatus.TOOL_CALL_INTERRUPTED)])],
-      }),
-    ];
-    expect(kindsFor(seq)).toContain("toolInterrupted");
-  });
-
-  it("emits a streaming delta when a running tool's result grows", () => {
-    const seq = [
-      snapshot({
-        messages: [aiMsg("", { toolCalls: [tool("t1", "shell", ToolCallStatus.TOOL_CALL_RUNNING, { isStreaming: true, result: "a" })] })],
-      }),
-      snapshot({
-        messages: [aiMsg("", { toolCalls: [tool("t1", "shell", ToolCallStatus.TOOL_CALL_RUNNING, { isStreaming: true, result: "ab" })] })],
-      }),
-    ];
-    expect(kindsFor(seq)).toContain("toolStreamDelta");
-  });
-});
-
-describe("system messages", () => {
-  it("sanitizes raw API errors and suppresses approval noise", () => {
-    const events = eventsFor([
-      snapshot({ messages: [systemMsg('Boom: Error code: 500 - {"type": "error"}'), systemMsg("Approval received: ok")] }),
-    ]);
-    const system = events.filter((e) => e.kind === "systemMessage");
-    expect(system).toHaveLength(1);
-    expect(system[0].kind === "systemMessage" && system[0].content).toContain("internal error");
-  });
-});
-
-describe("approval detection", () => {
-  it("emits ApprovalNeeded from pending_approvals once", () => {
-    const snap = snapshot({
-      phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
-      messages: [aiMsg("", { toolCalls: [tool("t1", "delete", ToolCallStatus.TOOL_CALL_WAITING_APPROVAL)] })],
-      pendingApprovals: [approval("t1", "delete", "Delete repo?")],
-    });
-    // Same snapshot twice — the dedup set prevents a second prompt.
-    const events = eventsFor([snap, snap]);
-    const approvals = events.filter((e) => e.kind === "approvalNeeded");
-    expect(approvals).toHaveLength(1);
-    expect(approvals[0].kind === "approvalNeeded" && approvals[0].toolName).toBe("delete");
-  });
-
-  it("defense-in-depth: detects approval via tool status when pending_approvals is empty", () => {
-    const snap = snapshot({
-      phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
-      messages: [aiMsg("", { toolCalls: [tool("t1", "delete", ToolCallStatus.TOOL_CALL_WAITING_APPROVAL)] })],
-      pendingApprovals: [],
-    });
-    expect(kindsFor([snap])).toContain("approvalNeeded");
-  });
-
-  it("re-prompts after an approval cycle (IN_PROGRESS → WAITING_FOR_APPROVAL)", () => {
-    const waiting = () =>
-      snapshot({
-        phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
-        messages: [aiMsg("", { toolCalls: [tool("t1", "delete", ToolCallStatus.TOOL_CALL_WAITING_APPROVAL)] })],
-        pendingApprovals: [approval("t1", "delete", "Delete?")],
-      });
-    const running = snapshot({
-      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
-      messages: [aiMsg("", { toolCalls: [tool("t1", "delete", ToolCallStatus.TOOL_CALL_RUNNING)] })],
-    });
-    const events = eventsFor([waiting(), running, waiting()]);
-    expect(events.filter((e) => e.kind === "approvalNeeded")).toHaveLength(2);
-  });
-});
-
-describe("todos", () => {
-  it("emits an update only when the fingerprint changes", () => {
-    const t = todo("a", "do x", TodoStatus.TODO_PENDING);
-    const seq = [
-      snapshot({ todos: { a: t } }),
-      snapshot({ todos: { a: t } }),
-      snapshot({ todos: { a: todo("a", "do x", TodoStatus.TODO_COMPLETED) } }),
-    ];
-    expect(kindsFor(seq).filter((k) => k === "todoUpdate")).toHaveLength(2);
-  });
-});
-
-describe("context compaction", () => {
-  it("emits one event per new summarization entry", () => {
-    const seq = [
-      snapshot({ summarizations: [{ tokensBefore: 100, tokensAfter: 50 }] }),
-      snapshot({ summarizations: [{ tokensBefore: 100, tokensAfter: 50 }, { tokensBefore: 80, tokensAfter: 40 }] }),
-    ];
-    expect(kindsFor(seq).filter((k) => k === "contextCompacted")).toHaveLength(2);
-  });
-});
-
-describe("sub-agents", () => {
-  it("emits started, nested messages, then completed", () => {
-    const seq = [
-      snapshot({
-        subAgents: [subAgent("s1", SubAgentStatus.SUB_AGENT_IN_PROGRESS, { subject: "Explore", messages: [aiMsg("thinking")] })],
-      }),
-      snapshot({
-        subAgents: [
-          subAgent("s1", SubAgentStatus.SUB_AGENT_COMPLETED, {
-            subject: "Explore",
-            output: "done",
-            messages: [aiMsg("thinking"), aiMsg("result")],
-          }),
-        ],
-      }),
-    ];
-    const events = eventsFor(seq);
-    const subKinds = events.filter((e) => ["subAgentStarted", "subAgentCompleted"].includes(e.kind)).map((e) => e.kind);
-    expect(subKinds).toEqual(["subAgentStarted", "subAgentCompleted"]);
-    const nested = events.filter((e) => e.kind === "aiMessage" && e.subAgentId === "s1");
-    expect(nested).toHaveLength(2);
-  });
-});
-
-describe("terminal", () => {
-  it("emits done and ignores all later snapshots", () => {
-    const differ = new SnapshotDiffer();
-    const first = differ.next(snapshot({ phase: ExecutionPhase.EXECUTION_COMPLETED }));
-    expect(first.map((e) => e.kind)).toContain("done");
-    const second = differ.next(snapshot({ phase: ExecutionPhase.EXECUTION_COMPLETED }));
-    expect(second).toEqual([]);
-  });
-
-  it("carries the error message on failure", () => {
-    const events = eventsFor([snapshot({ phase: ExecutionPhase.EXECUTION_FAILED, error: "boom" })]);
-    const done = events.find((e) => e.kind === "done");
-    expect(done?.kind === "done" && done.error).toBe("boom");
-  });
-});

package/src/resources/stream/headless.test.ts

@@ -1,119 +0,0 @@
-// Tests for the headless stream driver: terminal result propagation, approval
-// auto-resolution + submission, submit-failure → stream_error, clean abort.
-
-import { create } from "@bufbuild/protobuf";
-import { describe, expect, it } from "vitest";
-import { Code, ConnectError } from "@connectrpc/connect";
-import {
-  AgentExecutionSchema,
-  AgentExecutionStatusSchema,
-  type AgentExecution,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { AgentMessageSchema, ToolCallSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import { PendingApprovalSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
-import {
-  ApprovalAction,
-  ExecutionPhase,
-  MessageType,
-  ToolCallStatus,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { ApprovalNeededEvent, StreamEvent } from "./events.js";
-import { type HeadlessRenderer, runHeadlessStream } from "./headless.js";
-
-function snapshot(phase: ExecutionPhase, opts: { waiting?: boolean } = {}): AgentExecution {
-  const toolCalls = opts.waiting
-    ? [create(ToolCallSchema, { id: "t1", name: "delete", status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL })]
-    : [];
-  return create(AgentExecutionSchema, {
-    status: create(AgentExecutionStatusSchema, {
-      phase,
-      messages: [create(AgentMessageSchema, { type: MessageType.MESSAGE_AI, content: "hi", toolCalls })],
-      pendingApprovals: opts.waiting ? [create(PendingApprovalSchema, { toolCallId: "t1", toolName: "delete" })] : [],
-    }),
-  });
-}
-
-function source(snapshots: AgentExecution[]): (signal: AbortSignal) => AsyncIterable<AgentExecution> {
-  return async function* (signal: AbortSignal) {
-    for (const s of snapshots) {
-      if (signal.aborted) throw new DOMException("Aborted", "AbortError");
-      yield s;
-    }
-  };
-}
-
-class RecordingRenderer implements HeadlessRenderer {
-  readonly kinds: string[] = [];
-  constructor(private readonly action: ApprovalAction = ApprovalAction.SKIP) {}
-  render(event: StreamEvent): void {
-    this.kinds.push(event.kind);
-  }
-  resolveApproval(_event: ApprovalNeededEvent): ApprovalAction {
-    return this.action;
-  }
-}
-
-describe("runHeadlessStream", () => {
-  it("drives to a terminal done and returns the phase", async () => {
-    const renderer = new RecordingRenderer();
-    const result = await runHeadlessStream({
-      subscribe: source([snapshot(ExecutionPhase.EXECUTION_IN_PROGRESS), snapshot(ExecutionPhase.EXECUTION_COMPLETED)]),
-      submitApproval: async () => {},
-      renderer,
-      sessionId: "ses_1",
-      signal: new AbortController().signal,
-    });
-    expect(result).toEqual({ phase: "completed", error: "" });
-    expect(renderer.kinds).toContain("done");
-  });
-
-  it("resolves and submits an approval, then completes", async () => {
-    const renderer = new RecordingRenderer(ApprovalAction.SKIP);
-    const submitted: Array<{ id: string; action: ApprovalAction }> = [];
-    const result = await runHeadlessStream({
-      subscribe: source([
-        snapshot(ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL, { waiting: true }),
-        snapshot(ExecutionPhase.EXECUTION_COMPLETED),
-      ]),
-      submitApproval: async (id, action) => void submitted.push({ id, action }),
-      renderer,
-      sessionId: "ses_1",
-      signal: new AbortController().signal,
-    });
-    expect(submitted).toEqual([{ id: "t1", action: ApprovalAction.SKIP }]);
-    expect(renderer.kinds).toContain("approvalNeeded");
-    expect(result.phase).toBe("completed");
-  });
-
-  it("renders a stream_error and stops when submission fails permanently", async () => {
-    const renderer = new RecordingRenderer();
-    const result = await runHeadlessStream({
-      subscribe: source([
-        snapshot(ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL, { waiting: true }),
-        snapshot(ExecutionPhase.EXECUTION_COMPLETED),
-      ]),
-      submitApproval: async () => {
-        throw new ConnectError("nope", Code.InvalidArgument);
-      },
-      renderer,
-      sessionId: "ses_9",
-      signal: new AbortController().signal,
-    });
-    expect(renderer.kinds).toContain("streamError");
-    expect(result.error).toContain("Failed to submit approval");
-    expect(result.error).toContain("stigmer resume ses_9");
-  });
-
-  it("exits cleanly when aborted", async () => {
-    const controller = new AbortController();
-    controller.abort();
-    const result = await runHeadlessStream({
-      subscribe: source([snapshot(ExecutionPhase.EXECUTION_IN_PROGRESS)]),
-      submitApproval: async () => {},
-      renderer: new RecordingRenderer(),
-      sessionId: "",
-      signal: controller.signal,
-    });
-    expect(result).toEqual({ phase: "", error: "" });
-  });
-});

package/src/resources/stream/lazy-import.test.ts

@@ -1,63 +0,0 @@
-// DD-001 boundary guard: React/Ink must load lazily so non-streaming commands
-// and `--help` never pay for them. This codifies the boundary structurally so a
-// regression (a stray static import) fails CI instead of silently slowing every
-// command. The one allowed static importer is ink.tsx, which is itself only ever
-// reached through a dynamic import().
-
-import { readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-
-const SRC_ROOT = fileURLToPath(new URL("../..", import.meta.url));
-// The only modules allowed to statically import react/ink/@stigmer/ink. Each is
-// itself reached exclusively through a dynamic import() in a command action, so
-// the heavy graph stays out of every non-interactive path (DD-001).
-const INK_MODULES = [
-  join(SRC_ROOT, "resources/stream/ink.tsx"),
-  join(SRC_ROOT, "resources/picker/ink.tsx"),
-];
-const STATIC_HEAVY_IMPORT = /^\s*import\s+[^;]*?from\s+["'](?:react|ink|@stigmer\/ink)["']/m;
-
-function walk(dir: string): string[] {
-  const out: string[] = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...walk(path));
-    else if (/\.(ts|tsx)$/.test(entry.name)) out.push(path);
-  }
-  return out;
-}
-
-describe("lazy-import boundary (DD-001)", () => {
-  it("only the lazy Ink entrypoints statically import react/ink/@stigmer/ink", () => {
-    const offenders = walk(SRC_ROOT)
-      .filter((path) => !INK_MODULES.includes(path))
-      .filter((path) => STATIC_HEAVY_IMPORT.test(readFileSync(path, "utf8")));
-    expect(offenders).toEqual([]);
-  });
-
-  it("the Ink entrypoints are reached only through dynamic import()", () => {
-    const staticImporters = walk(SRC_ROOT).filter((path) => {
-      if (INK_MODULES.includes(path)) return false;
-      const src = readFileSync(path, "utf8");
-      return /^\s*import\s+[^;]*?from\s+["'][^"']*(?:stream|picker)\/ink(?:\.js)?["']/m.test(src);
-    });
-    expect(staticImporters).toEqual([]);
-  });
-
-  // The workflow run stream renders over a CLI-local plaintext/NDJSON renderer
-  // (no Ink WorkflowView this round), so it must stay out of the React/Ink graph.
-  it("workflow-stream.ts has no static react/ink imports", () => {
-    const src = readFileSync(join(SRC_ROOT, "resources/run/workflow-stream.ts"), "utf8");
-    expect(STATIC_HEAVY_IMPORT.test(src)).toBe(false);
-  });
-
-  // `connect` renders plaintext only; its command + resources stay Ink-free.
-  it("connect command and resources have no static react/ink imports", () => {
-    for (const rel of ["commands/connect.ts", "resources/connect/connect.ts", "resources/connect/display.ts"]) {
-      const src = readFileSync(join(SRC_ROOT, rel), "utf8");
-      expect(STATIC_HEAVY_IMPORT.test(src)).toBe(false);
-    }
-  });
-});

package/src/resources/stream/render-ndjson.test.ts

@@ -1,126 +0,0 @@
-// Golden-line tests for the NDJSON renderer: event type strings, payload shape,
-// and Go-parity payload cleaning (empty strings dropped, false/0 kept).
-
-import { describe, expect, it } from "vitest";
-import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { StreamEvent, ToolCallInfo } from "./events.js";
-import { NdjsonRenderer } from "./render-ndjson.js";
-
-const FIXED_TS = "2026-01-01T00:00:00.000Z";
-
-function buffer(): {
-  writer: { write(s: string): void };
-  raw: () => string;
-  lines: () => Array<Record<string, unknown>>;
-} {
-  let raw = "";
-  return {
-    writer: { write: (s: string) => void (raw += s) },
-    raw: () => raw,
-    lines: () =>
-      raw
-        .split("\n")
-        .filter((l) => l !== "")
-        .map((l) => JSON.parse(l) as Record<string, unknown>),
-  };
-}
-
-function renderer(defaultAction = ApprovalAction.SKIP) {
-  const data = buffer();
-  const status = buffer();
-  const r = new NdjsonRenderer({ data: data.writer, status: status.writer, defaultAction, now: () => FIXED_TS });
-  return { r, data, status };
-}
-
-function toolInfo(overrides: Partial<ToolCallInfo> = {}): ToolCallInfo {
-  return { id: "", name: "read", status: "running", args: undefined, result: "", error: "", durationMs: 0, ...overrides };
-}
-
-function render(events: StreamEvent[], defaultAction = ApprovalAction.SKIP) {
-  const ctx = renderer(defaultAction);
-  for (const e of events) ctx.r.render(e);
-  return ctx;
-}
-
-describe("envelope", () => {
-  it("wraps each event as {type, ts, payload} and strips empty payload fields", () => {
-    const { data } = render([{ kind: "aiStreamDelta", content: "", subAgentId: "" }]);
-    const [line] = data.lines();
-    expect(line.type).toBe("ai_stream_delta");
-    expect(line.ts).toBe(FIXED_TS);
-    expect(line.payload).toEqual({});
-  });
-
-  it("keeps boolean false and present strings", () => {
-    const { data } = render([
-      { kind: "approvalNeeded", toolCallId: "t1", toolName: "delete", argsPreview: "", message: "ok", fromSubAgent: false, subAgentName: "" },
-    ]);
-    const [line] = data.lines();
-    expect(line.type).toBe("approval_needed");
-    expect(line.payload).toEqual({ tool_call_id: "t1", tool_name: "delete", message: "ok", from_sub_agent: false });
-  });
-});
-
-describe("tool events", () => {
-  it("emits tool_interrupted as its own wire type (issue #207)", () => {
-    const { data } = render([
-      { kind: "toolInterrupted", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ id: "t1", name: "shell", status: "interrupted" }) },
-    ]);
-    expect(data.lines()[0]).toMatchObject({
-      type: "tool_interrupted",
-      payload: { tool_call_id: "t1", tool_name: "shell", status: "interrupted" },
-    });
-  });
-
-  it("emits tool_running with only the meaningful fields", () => {
-    const { data } = render([
-      { kind: "toolRunning", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ id: "t1", result: "out", durationMs: 42 }) },
-    ]);
-    expect(data.lines()[0]).toMatchObject({
-      type: "tool_running",
-      payload: { tool_call_id: "t1", tool_name: "read", status: "running", result: "out", duration_ms: 42 },
-    });
-  });
-
-  it("includes tool_calls in ai_stream_end, omits when empty", () => {
-    const { data } = render([
-      { kind: "aiStreamEnd", content: "done", subAgentId: "", toolCalls: [toolInfo({ id: "t1", status: "completed" })] },
-      { kind: "aiMessage", content: "x", subAgentId: "", toolCalls: [] },
-    ]);
-    const [end, msg] = data.lines();
-    expect((end.payload as Record<string, unknown>).tool_calls).toEqual([{ name: "read", status: "completed", id: "t1" }]);
-    expect((msg.payload as Record<string, unknown>).tool_calls).toBeUndefined();
-  });
-});
-
-describe("done", () => {
-  it("drops an empty error but keeps a present one", () => {
-    const { data } = render([
-      { kind: "done", phase: "completed", error: "" },
-      { kind: "done", phase: "failed", error: "boom" },
-    ]);
-    const [ok, fail] = data.lines();
-    expect(ok.payload).toEqual({ phase: "completed" });
-    expect(fail.payload).toEqual({ phase: "failed", error: "boom" });
-  });
-});
-
-describe("approval policy", () => {
-  it("honors the configured default action without warning", () => {
-    const { r, status } = renderer(ApprovalAction.APPROVE);
-    const action = r.resolveApproval({
-      kind: "approvalNeeded", toolCallId: "t1", toolName: "delete", argsPreview: "", message: "", fromSubAgent: false, subAgentName: "",
-    });
-    expect(action).toBe(ApprovalAction.APPROVE);
-    expect(status.lines()).toHaveLength(0);
-  });
-
-  it("auto-skips with a stderr warning when no default is set", () => {
-    const { r, status } = renderer(ApprovalAction.UNSPECIFIED);
-    const action = r.resolveApproval({
-      kind: "approvalNeeded", toolCallId: "t1", toolName: "delete", argsPreview: "", message: "", fromSubAgent: false, subAgentName: "",
-    });
-    expect(action).toBe(ApprovalAction.SKIP);
-    expect(status.raw()).toContain("auto-skipping approval for delete");
-  });
-});