@dungle-scrubs/tallow 0.8.26 → 0.8.27

package/extensions/permissions/__tests__/permissions.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Tests for the permissions extension registration and wiring.
+ *
+ * Uses the ExtensionHarness to avoid mock.module() — which contaminates
+ * other test files in the same Bun worker. Tests cover command/handler
+ * registration and event handler presence without mocking the _shared modules.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
+import registerPermissions from "../index.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+type EventName = "session_start" | "tool_call";
+type EventHandler = (event: unknown, ctx: ExtensionContext) => Promise<unknown>;
+type CommandHandler = (args: string | undefined, ctx: unknown) => Promise<void>;
+
+interface CapturedPi {
+	handlers: Partial<Record<EventName, EventHandler>>;
+	commands: Record<string, { description: string; handler: CommandHandler }>;
+}
+
+/**
+ * Run the extension against a spy pi to capture what it registers.
+ *
+ * @returns Captured event handlers and commands
+ */
+function captureRegistrations(): CapturedPi {
+	const handlers: Partial<Record<EventName, EventHandler>> = {};
+	const commands: Record<string, { description: string; handler: CommandHandler }> = {};
+	const pi = {
+		on: (event: string, handler: EventHandler) => {
+			handlers[event as EventName] = handler;
+		},
+		registerCommand: (name: string, opts: { description: string; handler: CommandHandler }) => {
+			commands[name] = opts;
+		},
+	} as unknown as ExtensionAPI;
+
+	registerPermissions(pi);
+	return { handlers, commands };
+}
+
+// ════════════════════════════════════════════════════════════════
+// Registration
+// ════════════════════════════════════════════════════════════════
+
+describe("permissions extension registration", () => {
+	test("registers session_start handler", () => {
+		const { handlers } = captureRegistrations();
+		expect(handlers.session_start).toBeDefined();
+	});
+
+	test("registers tool_call handler", () => {
+		const { handlers } = captureRegistrations();
+		expect(handlers.tool_call).toBeDefined();
+	});
+
+	test("registers /permissions command", () => {
+		const { commands } = captureRegistrations();
+		expect(commands.permissions).toBeDefined();
+		expect(commands.permissions.description).toBeTruthy();
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// tool_call handler wiring
+// ════════════════════════════════════════════════════════════════
+
+describe("tool_call handler", () => {
+	test("skips bash tool (handled by shell-policy)", async () => {
+		const { handlers } = captureRegistrations();
+		const result = await handlers.tool_call!(
+			{ type: "tool_call", toolName: "bash", toolCallId: "t1", input: { command: "ls" } },
+			{ cwd: "/tmp", hasUI: false, ui: {} } as unknown as ExtensionContext
+		);
+		// No block/error — should be undefined (pass-through)
+		expect(result).toBeUndefined();
+	});
+
+	test("skips bg_bash tool (handled by shell-policy)", async () => {
+		const { handlers } = captureRegistrations();
+		const result = await handlers.tool_call!(
+			{ type: "tool_call", toolName: "bg_bash", toolCallId: "t2", input: { command: "ls" } },
+			{ cwd: "/tmp", hasUI: false, ui: {} } as unknown as ExtensionContext
+		);
+		expect(result).toBeUndefined();
+	});
+
+	test("skips when no rules configured", async () => {
+		const { handlers } = captureRegistrations();
+		// Session-start hasn't been called yet, so currentCwd is "", and
+		// getPermissions("") returns empty rules → skip
+		const result = await handlers.tool_call!(
+			{
+				type: "tool_call",
+				toolName: "read",
+				toolCallId: "t3",
+				input: { path: "/etc/passwd" },
+			},
+			{ cwd: "/tmp", hasUI: false, ui: {} } as unknown as ExtensionContext
+		);
+		expect(result).toBeUndefined();
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// /permissions command wiring
+// ════════════════════════════════════════════════════════════════
+
+describe("/permissions command", () => {
+	test("reload subcommand calls reloadPermissions", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("reload", ctx);
+		// Should have notified about reload
+		expect(notifications.length).toBeGreaterThan(0);
+		expect(notifications[0].msg).toContain("Reloaded");
+	});
+
+	test("no args shows rules (or 'no rules' when none configured)", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("", ctx);
+		expect(notifications.length).toBeGreaterThan(0);
+		// Should show either "No permission rules" or "Active Permission Rules"
+		const msg = notifications[0].msg;
+		expect(msg.includes("No permission rules") || msg.includes("Permission Rules")).toBe(true);
+	});
+
+	test("test subcommand evaluates Tool(specifier) format", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("test Bash(ls)", ctx);
+		expect(notifications.length).toBeGreaterThan(0);
+		// Should contain action verdict info
+		expect(notifications[0].msg).toContain("Action:");
+	});
+
+	test("test subcommand handles bare tool name", async () => {
+		const { commands } = captureRegistrations();
+		const notifications: Array<{ msg: string; type: string }> = [];
+		const ctx = {
+			cwd: "/tmp",
+			ui: {
+				notify: (msg: string, type: string) => {
+					notifications.push({ msg, type });
+				},
+			},
+		};
+
+		await commands.permissions.handler("test read", ctx);
+		expect(notifications.length).toBeGreaterThan(0);
+		expect(notifications[0].msg).toContain("Action:");
+	});
+});
+
+// ════════════════════════════════════════════════════════════════
+// ExtensionHarness integration
+// ════════════════════════════════════════════════════════════════
+
+describe("permissions via ExtensionHarness", () => {
+	test("tool_call event handler is registered", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(registerPermissions);
+		// Verify the extension registered a tool_call handler by firing one
+		const results = await harness.fireEvent("tool_call", {
+			type: "tool_call",
+			toolName: "read",
+			toolCallId: "h-1",
+			input: { path: "foo.txt" },
+		});
+		// No rules configured → should not block
+		const blocked = results.some(
+			(r) => r && typeof r === "object" && (r as { block?: boolean }).block
+		);
+		expect(blocked).toBe(false);
+	});
+
+	test("/permissions command is registered", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(registerPermissions);
+		expect(harness.commands.has("permissions")).toBe(true);
+	});
+});

package/extensions/progress-indicator/__tests__/progress-indicator.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import progressIndicator from "../index.js";
+
+describe("progress-indicator extension", () => {
+	let originalIsTTY: boolean;
+	let written: string[];
+	let originalWrite: typeof process.stdout.write;
+
+	beforeEach(() => {
+		originalIsTTY = process.stdout.isTTY;
+		originalWrite = process.stdout.write;
+		written = [];
+		Object.defineProperty(process.stdout, "isTTY", { value: true, configurable: true });
+		process.stdout.write = ((chunk: string) => {
+			written.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+	});
+
+	afterEach(() => {
+		Object.defineProperty(process.stdout, "isTTY", {
+			value: originalIsTTY,
+			configurable: true,
+		});
+		process.stdout.write = originalWrite;
+	});
+
+	test("registers turn_start, turn_end, agent_end, session_shutdown handlers", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		expect(events).toContain("turn_start");
+		expect(events).toContain("turn_end");
+		expect(events).toContain("agent_end");
+		expect(events).toContain("session_shutdown");
+	});
+
+	test("turn_start writes indeterminate OSC sequence", () => {
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.turn_start();
+
+		expect(written).toHaveLength(1);
+		expect(written[0]).toContain("9;4;3");
+	});
+
+	test("turn_end writes clear OSC sequence", () => {
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.turn_end();
+
+		expect(written).toHaveLength(1);
+		expect(written[0]).toContain("9;4;0");
+	});
+
+	test("agent_end writes clear OSC sequence", () => {
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.agent_end();
+
+		expect(written).toHaveLength(1);
+		expect(written[0]).toContain("9;4;0");
+	});
+
+	test("skips write when stdout is not a TTY", () => {
+		Object.defineProperty(process.stdout, "isTTY", { value: false, configurable: true });
+
+		const handlers: Record<string, () => void> = {};
+		const pi = {
+			on: (event: string, handler: () => void) => {
+				handlers[event] = handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		progressIndicator(pi);
+		handlers.turn_start();
+
+		expect(written).toHaveLength(0);
+	});
+});

package/extensions/random-spinner/__tests__/random-spinner.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import randomSpinner from "../index.js";
+
+describe("random-spinner extension", () => {
+	test("registers session_start handler", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		randomSpinner(pi);
+		expect(events).toContain("session_start");
+	});
+
+	test("does not register any commands or tools", () => {
+		const commands: string[] = [];
+		const tools: string[] = [];
+		const pi = {
+			on: () => {},
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+			registerTool: (opts: { name: string }) => {
+				tools.push(opts.name);
+			},
+		} as unknown as ExtensionAPI;
+
+		randomSpinner(pi);
+		expect(commands).toHaveLength(0);
+		expect(tools).toHaveLength(0);
+	});
+});

package/extensions/show-system-prompt/__tests__/show-system-prompt.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import showPrompt from "../index.js";
+
+describe("show-system-prompt extension", () => {
+	test("registers show-system-prompt command", () => {
+		const commands: string[] = [];
+		const pi = {
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+		} as unknown as ExtensionAPI;
+
+		showPrompt(pi);
+		expect(commands).toContain("show-system-prompt");
+	});
+
+	test("handler logs system prompt and notifies", async () => {
+		let handler: ((args: string, ctx: unknown) => Promise<void>) | undefined;
+		const pi = {
+			registerCommand: (
+				_name: string,
+				opts: { handler: (args: string, ctx: unknown) => Promise<void> }
+			) => {
+				handler = opts.handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		showPrompt(pi);
+
+		const notify = mock(() => {});
+		const ctx = {
+			getSystemPrompt: () => "You are a test prompt",
+			ui: { notify },
+		};
+
+		const origLog = console.log;
+		const logged: string[] = [];
+		console.log = (...args: unknown[]) => {
+			logged.push(args.join(" "));
+		};
+		try {
+			await handler!("", ctx);
+		} finally {
+			console.log = origLog;
+		}
+
+		expect(logged.some((l) => l.includes("You are a test prompt"))).toBe(true);
+		expect(notify).toHaveBeenCalledWith("System prompt logged to terminal", "info");
+	});
+});

package/extensions/subagent-tool/__tests__/presentation-rendering.test.ts

@@ -133,7 +133,7 @@ describe("subagent presentation rendering", () => {
 		expect(rendered).toContain("<dim>Implement authentication flow with retry handling</dim>");
 	});
 
-	it("keeps long parallel call previews informative without dumping the full tail", () => {
+	it("renders parallel call header without inlining task text", () => {
 		const component = tool.renderCall?.(
 			{
 				tasks: [
@@ -152,7 +152,8 @@ describe("subagent presentation rendering", () => {
 
 		const rendered = renderComponent(component);
 		expect(rendered).toContain("<accent>parallel (1 tasks)</accent>");
-		expect(rendered).toContain("KEEP_THIS_SEGMENT_VISIBLE");
+		// Parallel renderCall shows header + metadata only — no inline task preview
+		expect(rendered).not.toContain("KEEP_THIS_SEGMENT_VISIBLE");
 		expect(rendered).not.toContain("END_MARKER_SHOULD_TRUNCATE");
 	});
 
@@ -260,8 +261,8 @@ describe("subagent presentation rendering", () => {
 		if (!component) throw new Error("subagent.renderResult returned undefined");
 
 		const rendered = renderComponent(component);
-		expect(rendered).toContain("<b><toolTitle>subagent</toolTitle></b>");
-		expect(rendered).toContain("<accent>parallel</accent>");
+		// Result no longer repeats the "subagent parallel" header (call header already shows it)
+		expect(rendered).not.toContain("<toolTitle>subagent</toolTitle>");
 		expect(rendered).toContain("├─");
 		expect(rendered).toContain("└─");
 		expect(rendered).toContain("<dim>(gpt-5.1)</dim>");

package/extensions/subagent-tool/__tests__/process-liveness.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import type { SingleResult } from "../formatting.js";
 import {
 	applyStalledClassification,
+	createStalledSubagentErrorMessage,
 	createWatchdogHeartbeatState,
 	evaluateWatchdogStatus,
 	type ForegroundWatchdogThresholds,
@@ -13,6 +14,7 @@ import {
 	SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV,
 	SUBAGENT_STARTUP_TIMEOUT_MS_ENV,
 	SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV,
+	SUBAGENT_WALL_CLOCK_TIMEOUT_MS_ENV,
 	terminateProcessWithGrace,
 } from "../process.js";
 
@@ -21,6 +23,7 @@ const TEST_THRESHOLDS: ForegroundWatchdogThresholds = {
 	killGraceMs: 50,
 	startupTimeoutMs: 1_000,
 	toolExecutionTimeoutMs: 8_000,
+	wallClockTimeoutMs: 20_000,
 };
 
 interface ManualTimer {
@@ -124,6 +127,52 @@ describe("foreground subagent liveness watchdog", () => {
 		expect(state.activeToolCalls).toBe(0);
 	});
 
+	it("terminates active agents that exceed wall-clock timeout", () => {
+		let state = createWatchdogHeartbeatState(0);
+		// Agent is actively producing heartbeats — not stalled by liveness checks
+		state = recordWatchdogHeartbeat(state, 5_000);
+		state = recordWatchdogHeartbeat(state, 10_000);
+		state = recordWatchdogHeartbeat(state, 15_000);
+		state = recordWatchdogHeartbeat(state, 19_000);
+		expect(evaluateWatchdogStatus(state, 19_500, TEST_THRESHOLDS).kind).toBe("healthy");
+
+		// Wall-clock timeout (20s) fires even though last heartbeat was recent
+		const status = evaluateWatchdogStatus(state, 20_100, TEST_THRESHOLDS);
+		expect(status.kind).toBe("stalled");
+		if (status.kind !== "stalled") return;
+		expect(status.phase).toBe("wall_clock");
+	});
+
+	it("wall-clock timeout takes precedence over other stall phases", () => {
+		// Agent started and never sent a heartbeat — would normally be startup stall
+		const state = createWatchdogHeartbeatState(0);
+		// But wall-clock fires first when both thresholds are exceeded
+		const status = evaluateWatchdogStatus(state, 25_000, TEST_THRESHOLDS);
+		expect(status.kind).toBe("stalled");
+		if (status.kind !== "stalled") return;
+		expect(status.phase).toBe("wall_clock");
+	});
+
+	it("wall-clock error message differs from liveness stall messages", () => {
+		const wallClockMsg = createStalledSubagentErrorMessage({
+			elapsedMs: 900_000,
+			kind: "stalled",
+			phase: "wall_clock",
+			timeoutMs: 900_000,
+		});
+		expect(wallClockMsg).toContain("wall-clock timeout");
+		expect(wallClockMsg).toContain("TALLOW_SUBAGENT_WALL_CLOCK_TIMEOUT_MS");
+		expect(wallClockMsg).not.toContain("slow provider startup");
+
+		const startupMsg = createStalledSubagentErrorMessage({
+			elapsedMs: 60_000,
+			kind: "stalled",
+			phase: "startup",
+			timeoutMs: 60_000,
+		});
+		expect(startupMsg).not.toContain("wall-clock");
+	});
+
 	it("treats message updates and tool execution events as heartbeats", () => {
 		expect(isWatchdogHeartbeatEventType("message_update")).toBe(true);
 		expect(isWatchdogHeartbeatEventType("tool_execution_start")).toBe(true);
@@ -136,10 +185,12 @@ describe("foreground subagent liveness watchdog", () => {
 			[SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV]: "7000",
 			[SUBAGENT_STARTUP_TIMEOUT_MS_ENV]: "3000",
 			[SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV]: "11000",
+			[SUBAGENT_WALL_CLOCK_TIMEOUT_MS_ENV]: "1800000",
 		});
 		expect(thresholds.inactivityTimeoutMs).toBe(7_000);
 		expect(thresholds.startupTimeoutMs).toBe(3_000);
 		expect(thresholds.toolExecutionTimeoutMs).toBe(11_000);
+		expect(thresholds.wallClockTimeoutMs).toBe(1_800_000);
 	});
 
 	it("stalled termination escalates and resolves without hanging", async () => {

package/extensions/subagent-tool/__tests__/subprocess-args.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "bun:test";
+import { buildSubprocessArgs, type SubprocessArgsOptions } from "../process.js";
+
+describe("buildSubprocessArgs", () => {
+	/** Minimal options — no session, no model, just a task. */
+	const minimal: SubprocessArgsOptions = { task: "do something" };
+
+	it("always places -p as the last flag, right before the task text", () => {
+		const args = buildSubprocessArgs(minimal);
+		const pIdx = args.lastIndexOf("-p");
+		expect(pIdx).toBeGreaterThanOrEqual(0);
+		expect(pIdx).toBe(args.length - 2);
+		expect(args[pIdx + 1]).toBe("Task: do something");
+	});
+
+	it("uses --no-session when session is omitted", () => {
+		const args = buildSubprocessArgs(minimal);
+		expect(args).toContain("--no-session");
+		expect(args).not.toContain("--session");
+	});
+
+	it("uses --session <id> when session is provided", () => {
+		const args = buildSubprocessArgs({ ...minimal, session: "my-session" });
+		expect(args).toContain("--session");
+		expect(args[args.indexOf("--session") + 1]).toBe("my-session");
+		expect(args).not.toContain("--no-session");
+	});
+
+	it("--no-session is never consumed as -p value (regression: 86a8d26e)", () => {
+		// The original bug: -p was placed before --no-session, so Commander
+		// treated "--no-session" as the prompt text and the real task became
+		// a stray positional argument → "too many arguments".
+		const args = buildSubprocessArgs(minimal);
+		const pIdx = args.indexOf("-p");
+		const noSessionIdx = args.indexOf("--no-session");
+		// -p must come AFTER --no-session in the array
+		expect(pIdx).toBeGreaterThan(noSessionIdx);
+	});
+
+	it("includes --model when modelDisplayName is provided", () => {
+		const args = buildSubprocessArgs({
+			...minimal,
+			modelDisplayName: "anthropic/claude-sonnet-4-6",
+		});
+		const mIdx = args.indexOf("--model");
+		expect(mIdx).toBeGreaterThanOrEqual(0);
+		expect(args[mIdx + 1]).toBe("anthropic/claude-sonnet-4-6");
+		// Still before -p
+		expect(mIdx).toBeLessThan(args.lastIndexOf("-p"));
+	});
+
+	it("includes --tools when tools are provided", () => {
+		const args = buildSubprocessArgs({ ...minimal, tools: ["read", "bash", "edit"] });
+		const tIdx = args.indexOf("--tools");
+		expect(tIdx).toBeGreaterThanOrEqual(0);
+		expect(args[tIdx + 1]).toBe("read,bash,edit");
+		expect(tIdx).toBeLessThan(args.lastIndexOf("-p"));
+	});
+
+	it("includes --skill for each skill", () => {
+		const args = buildSubprocessArgs({ ...minimal, skills: ["tdd", "git"] });
+		const firstSkill = args.indexOf("--skill");
+		expect(firstSkill).toBeGreaterThanOrEqual(0);
+		expect(args[firstSkill + 1]).toBe("tdd");
+		const secondSkill = args.indexOf("--skill", firstSkill + 1);
+		expect(secondSkill).toBeGreaterThanOrEqual(0);
+		expect(args[secondSkill + 1]).toBe("git");
+		// Both before -p
+		expect(secondSkill).toBeLessThan(args.lastIndexOf("-p"));
+	});
+
+	it("includes --append-system-prompt when path is provided", () => {
+		const args = buildSubprocessArgs({
+			...minimal,
+			systemPromptPath: "/tmp/prompt.md",
+		});
+		const sIdx = args.indexOf("--append-system-prompt");
+		expect(sIdx).toBeGreaterThanOrEqual(0);
+		expect(args[sIdx + 1]).toBe("/tmp/prompt.md");
+		expect(sIdx).toBeLessThan(args.lastIndexOf("-p"));
+	});
+
+	it("produces correct full arg array with all options", () => {
+		const args = buildSubprocessArgs({
+			session: "sess-123",
+			modelDisplayName: "openai/gpt-5",
+			tools: ["read", "write"],
+			skills: ["tdd"],
+			systemPromptPath: "/tmp/prompt.md",
+			task: "fix the tests",
+		});
+		expect(args).toEqual([
+			"--mode",
+			"json",
+			"--session",
+			"sess-123",
+			"--model",
+			"openai/gpt-5",
+			"--tools",
+			"read,write",
+			"--skill",
+			"tdd",
+			"--append-system-prompt",
+			"/tmp/prompt.md",
+			"-p",
+			"Task: fix the tests",
+		]);
+	});
+
+	it("omits optional flags when not provided", () => {
+		const args = buildSubprocessArgs({ task: "hello" });
+		expect(args).toEqual(["--mode", "json", "--no-session", "-p", "Task: hello"]);
+	});
+
+	it("always starts with --mode json", () => {
+		const args = buildSubprocessArgs(minimal);
+		expect(args[0]).toBe("--mode");
+		expect(args[1]).toBe("json");
+	});
+});

package/extensions/subagent-tool/formatting.ts

@@ -37,6 +37,8 @@ export interface SingleResult {
 	stopReason?: string;
 	errorMessage?: string;
 	step?: number;
+	/** Timestamp (ms) when this subagent started executing. */
+	startTime?: number;
 	/** Tool names that were denied permission during execution. */
 	deniedTools?: string[];
 }