@dungle-scrubs/tallow 0.8.26 → 0.8.28

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[];
 }

package/extensions/subagent-tool/index.ts

@@ -50,6 +50,7 @@ import {
 	applyBackgroundResultRetention,
 	mapWithConcurrencyLimit,
 	type OnUpdateCallback,
+	resolveRetryPhaseTimeoutMs,
 	runSingleAgent,
 	setPiRef,
 	setTelemetryHandle,
@@ -181,6 +182,25 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
+	// Kill all running background subagents on session shutdown (SIGTERM during user input).
+	// Unlike agent_end, this fires when the entire session is exiting — we don't need to
+	// retain results, just ensure orphaned subagent processes are terminated promptly.
+	pi.on("session_shutdown", async () => {
+		let mutated = false;
+		for (const [_id, bg] of backgroundSubagents) {
+			if (bg.status === "running" && bg.process && !bg.process.killed) {
+				bg.process.kill("SIGTERM");
+				bg.completedAt = Date.now();
+				bg.status = "failed";
+				bg.result.stopReason = "shutdown";
+				mutated = true;
+			}
+		}
+		if (mutated) {
+			publishSubagentSnapshot(pi.events);
+		}
+	});
+
 	pi.registerTool({
 		name: "subagent",
 		label: "subagent",
@@ -674,6 +694,7 @@ async function executeParallel(
 	const allResults: SingleResult[] = new Array(tasks.length);
 
 	// Initialize placeholder results
+	const parallelStartTime = Date.now();
 	for (let i = 0; i < tasks.length; i++) {
 		allResults[i] = {
 			agent: tasks[i].agent,
@@ -692,6 +713,7 @@ async function executeParallel(
 				turns: 0,
 				denials: 0,
 			},
+			startTime: parallelStartTime,
 		};
 	}
 
@@ -788,12 +810,34 @@ async function executeParallel(
 		const retrySummaryLines: string[] = [];
 		const totalRetries = initialStalledIndexes.length;
 
+		// Cap the entire retry phase with a wall-clock timeout so N sequential
+		// retries × per-worker watchdog timeouts don't block the parent for 30+ min.
+		const retryPhaseTimeoutMs = resolveRetryPhaseTimeoutMs();
+		const retryAbort = new AbortController();
+		const retryTimer = setTimeout(() => retryAbort.abort(), retryPhaseTimeoutMs);
+		// Propagate parent abort to the retry phase.
+		const parentAbortHandler = signal ? () => retryAbort.abort() : undefined;
+		if (signal && parentAbortHandler) {
+			if (signal.aborted) retryAbort.abort();
+			else signal.addEventListener("abort", parentAbortHandler, { once: true });
+		}
+		const retrySignal = retryAbort.signal;
+
 		try {
 			ctx.ui.setWorkingMessage(
 				`Rerunning ${totalRetries} stalled worker${totalRetries === 1 ? "" : "s"} individually`
 			);
 
 			for (let retryIndex = 0; retryIndex < initialStalledIndexes.length; retryIndex++) {
+				// Bail out if the retry phase deadline has elapsed.
+				if (retrySignal.aborted) {
+					for (let remaining = retryIndex; remaining < initialStalledIndexes.length; remaining++) {
+						const idx = initialStalledIndexes[remaining];
+						retrySummaryLines.push(`- [${tasks[idx].agent}] skipped (retry phase timeout)`);
+					}
+					break;
+				}
+
 				const stalledIndex = initialStalledIndexes[retryIndex];
 				const stalledTask = tasks[stalledIndex];
 				const priorResult = allResults[stalledIndex];
@@ -810,33 +854,49 @@ async function executeParallel(
 					`Retrying stalled worker ${retryIndex + 1}/${totalRetries}: ${stalledTask.agent}`
 				);
 
-				const retryResult = await runSingleAgent(
-					ctx.cwd,
-					agents,
-					stalledTask.agent,
-					retryTask,
-					stalledTask.cwd,
-					undefined,
-					signal,
-					(partial) => {
-						if (partial.details?.results[0]) {
-							const partialResult = {
-								...partial.details.results[0],
-								task: stalledTask.task,
-							};
-							allResults[stalledIndex] = partialResult;
-							emitParallelUpdate();
-						}
-					},
-					makeDetails("parallel"),
-					pi.events,
-					undefined,
-					explicitRetryModel,
-					parentModelId,
-					defaults,
-					retryRoutingHints,
-					stalledTask.isolation
-				);
+				let retryResult: SingleResult;
+				try {
+					retryResult = await runSingleAgent(
+						ctx.cwd,
+						agents,
+						stalledTask.agent,
+						retryTask,
+						stalledTask.cwd,
+						undefined,
+						retrySignal,
+						(partial) => {
+							if (partial.details?.results[0]) {
+								const partialResult = {
+									...partial.details.results[0],
+									task: stalledTask.task,
+								};
+								allResults[stalledIndex] = partialResult;
+								emitParallelUpdate();
+							}
+						},
+						makeDetails("parallel"),
+						pi.events,
+						undefined,
+						explicitRetryModel,
+						parentModelId,
+						defaults,
+						retryRoutingHints,
+						stalledTask.isolation
+					);
+				} catch {
+					// Retry-phase timeout aborted this worker. Mark remaining
+					// workers as skipped and exit the loop.
+					retrySummaryLines.push(`- [${stalledTask.agent}] aborted (retry phase timeout)`);
+					for (
+						let remaining = retryIndex + 1;
+						remaining < initialStalledIndexes.length;
+						remaining++
+					) {
+						const idx = initialStalledIndexes[remaining];
+						retrySummaryLines.push(`- [${tasks[idx].agent}] skipped (retry phase timeout)`);
+					}
+					break;
+				}
 
 				retryResult.task = stalledTask.task;
 				retryResult.stderr = appendStderrNote(
@@ -848,6 +908,10 @@ async function executeParallel(
 				emitParallelUpdate();
 			}
 		} finally {
+			clearTimeout(retryTimer);
+			if (signal && parentAbortHandler) {
+				signal.removeEventListener("abort", parentAbortHandler);
+			}
 			ctx.ui.setWorkingMessage();
 		}
 
@@ -1066,8 +1130,6 @@ interface DisplayRenderOptions {
  * Shared preview budgets for compact subagent presentation lines.
  */
 const SUBAGENT_PREVIEW_LIMITS = {
-	callCentipedeStep: 90,
-	callParallelTask: 90,
 	collapsedParallelResult: 88,
 } as const;
 
@@ -1333,71 +1395,35 @@ function renderSubagentCall(args: Record<string, unknown>, theme: Theme) {
 		args.tasks as { agent: string; model?: string; task: string }[] | string | undefined
 	);
 	const lines: string[] = [];
+	// Only show scope when non-default (user is the default)
+	const scopeEntry = scope !== "user" ? `scope:${scope}` : undefined;
 
 	if (centipedeArr && centipedeArr.length > 0) {
 		appendSection(lines, [formatSubagentHeader(theme, `centipede (${centipedeArr.length} steps)`)]);
-		const metaLine = formatMetaLine(theme, [
-			`scope:${scope}`,
-			model ? `model:${model}` : undefined,
-		]);
+		const metaLine = formatMetaLine(theme, [scopeEntry, model ? `model:${model}` : undefined]);
 		if (metaLine) appendSection(lines, [metaLine]);
-
-		const previewLines = centipedeArr.slice(0, 3).map((step, index) => {
-			const task = step.task.replace(/\{previous\}/g, "").trim();
-			const preview = toCompactPreview(
-				task || "(uses previous output)",
-				SUBAGENT_PREVIEW_LIMITS.callCentipedeStep
-			);
-			const modelTag = formatModelTag(theme, step.model);
-			const identity = modelTag
-				? `${formatSubagentIdentity(step.agent)} ${modelTag}`
-				: formatSubagentIdentity(step.agent);
-			return `${formatPresentationText(theme, "meta", `${index + 1}.`)} ${identity} ${formatPresentationText(theme, "process_output", preview)}`;
-		});
-		if (previewLines.length > 0) appendSection(lines, previewLines, { blankBefore: true });
-		if (centipedeArr.length > 3) {
-			appendSection(lines, [
-				formatPresentationText(theme, "hint", `… +${centipedeArr.length - 3} more steps`),
-			]);
-		}
 		return new Text(lines.join("\n"), 0, 0);
 	}
 
 	if (tasksArr && tasksArr.length > 0) {
 		appendSection(lines, [formatSubagentHeader(theme, `parallel (${tasksArr.length} tasks)`)]);
-		const metaLine = formatMetaLine(theme, [
-			`scope:${scope}`,
-			model ? `model:${model}` : undefined,
-		]);
+		const metaLine = formatMetaLine(theme, [scopeEntry, model ? `model:${model}` : undefined]);
 		if (metaLine) appendSection(lines, [metaLine]);
-
-		const previewLines = tasksArr.slice(0, 2).map((task, index) => {
-			const taskPreview = toCompactPreview(task.task, SUBAGENT_PREVIEW_LIMITS.callParallelTask);
-			const modelTag = formatModelTag(theme, task.model);
-			const identity = modelTag
-				? `${formatSubagentIdentity(task.agent)} ${modelTag}`
-				: formatSubagentIdentity(task.agent);
-			return `${formatPresentationText(theme, "meta", `${index + 1}.`)} ${identity} ${formatPresentationText(theme, "process_output", taskPreview)}`;
-		});
-		if (previewLines.length > 0) appendSection(lines, previewLines, { blankBefore: true });
-		if (tasksArr.length > 2) {
-			appendSection(lines, [
-				formatPresentationText(theme, "hint", `… +${tasksArr.length - 2} more tasks`),
-			]);
-		}
 		return new Text(lines.join("\n"), 0, 0);
 	}
 
 	const agentName = (args.agent as string) || "...";
 	const task = typeof args.task === "string" ? args.task : "...";
-	appendSection(lines, [formatSubagentHeader(theme, "single", agentName)]);
-	const metaLine = formatMetaLine(theme, [`scope:${scope}`, model ? `model:${model}` : undefined]);
+	// Single mode: skip the redundant "subagent single" header — the result
+	// renderer already shows "subagent running <duration> <agent>" with a spinner.
+	// Just show the task preview so the user sees what was requested.
+	const metaLine = formatMetaLine(theme, [scopeEntry, model ? `model:${model}` : undefined]);
 	if (metaLine) appendSection(lines, [metaLine]);
 	appendSection(
 		lines,
 		[formatPresentationText(theme, "process_output", toCompactPreview(task, 200))],
 		{
-			blankBefore: true,
+			blankBefore: false,
 		}
 	);
 	return new Text(lines.join("\n"), 0, 0);
@@ -1523,7 +1549,14 @@ function renderSingleResult(
 		: isError
 			? theme.fg("error", getIcon("error"))
 			: theme.fg("success", getIcon("success"));
-	const statusLabel = isRunning ? "running" : isError ? "failed" : "completed";
+	const statusLabel =
+		isRunning && r.startTime
+			? `running ${formatDuration(Date.now() - r.startTime)}`
+			: isRunning
+				? "running"
+				: isError
+					? "failed"
+					: "completed";
 	const headerLine = formatSubagentHeader(theme, statusLabel, r.agent, icon);
 	const metaLine = formatMetaLine(theme, [
 		`source:${r.agentSource}`,
@@ -1727,17 +1760,25 @@ function renderCentipedeResult(
 		: failCount > 0
 			? theme.fg("error", getIcon("error"))
 			: theme.fg("success", getIcon("success"));
+	const earliestStart = details.results.reduce(
+		(min, r) => (r.startTime && r.startTime < min ? r.startTime : min),
+		Number.POSITIVE_INFINITY
+	);
+	const elapsed = Number.isFinite(earliestStart)
+		? formatDuration(Date.now() - earliestStart)
+		: undefined;
 	const summaryLine = formatMetaLine(theme, [
 		`${successCount + failCount}/${totalSteps} done`,
 		runningCount > 0 ? `${runningCount} running` : undefined,
 		failCount > 0 ? `${failCount} failed` : undefined,
+		elapsed,
 	]);
 
 	if (expanded) {
 		const container = new Container();
-		const headerLines: string[] = [formatSubagentHeader(theme, "centipede", undefined, icon)];
-		if (summaryLine) appendSection(headerLines, [summaryLine]);
-		container.addChild(new Text(headerLines.join("\n"), 0, 0));
+		const headerLines: string[] = [];
+		if (summaryLine) headerLines.push(`${icon} ${summaryLine}`);
+		if (headerLines.length > 0) container.addChild(new Text(headerLines.join("\n"), 0, 0));
 
 		for (let si = 0; si < totalSteps; si++) {
 			const stepNum = si + 1;
@@ -1746,11 +1787,13 @@ function renderCentipedeResult(
 				stepResult?.agent ?? details.centipedeSteps?.[si]?.agent ?? `step ${stepNum}`;
 			const stepStatus = !stepResult
 				? "pending"
-				: stepResult.exitCode === -1
-					? "running"
-					: isResultError(stepResult)
-						? "failed"
-						: "completed";
+				: stepResult.exitCode === -1 && stepResult.startTime
+					? `running ${formatDuration(Date.now() - stepResult.startTime)}`
+					: stepResult.exitCode === -1
+						? "running"
+						: isResultError(stepResult)
+							? "failed"
+							: "completed";
 			const stepStatusRole = !stepResult
 				? "meta"
 				: stepResult.exitCode === -1
@@ -1839,8 +1882,8 @@ function renderCentipedeResult(
 		return container;
 	}
 
-	const lines: string[] = [formatSubagentHeader(theme, "centipede", undefined, icon)];
-	if (summaryLine) appendSection(lines, [summaryLine]);
+	const lines: string[] = [];
+	if (summaryLine) lines.push(`${icon} ${summaryLine}`);
 
 	for (let si = 0; si < totalSteps; si++) {
 		const stepNum = si + 1;
@@ -1851,11 +1894,13 @@ function renderCentipedeResult(
 		const stem = isLast ? "   " : `${formatPresentationText(theme, "meta", "│")}  `;
 		const stepStatus = !stepResult
 			? "pending"
-			: stepResult.exitCode === -1
-				? "running"
-				: isResultError(stepResult)
-					? "failed"
-					: "done";
+			: stepResult.exitCode === -1 && stepResult.startTime
+				? `running ${formatDuration(Date.now() - stepResult.startTime)}`
+				: stepResult.exitCode === -1
+					? "running"
+					: isResultError(stepResult)
+						? "failed"
+						: "done";
 		const statusRole = !stepResult
 			? "meta"
 			: stepResult.exitCode === -1
@@ -1922,23 +1967,36 @@ function renderParallelResult(
 			: counts.stalled > 0
 				? theme.fg("warning", getIcon("blocked"))
 				: theme.fg("success", getIcon("success"));
+	const earliestStart = details.results.reduce(
+		(min, r) => (r.startTime && r.startTime < min ? r.startTime : min),
+		Number.POSITIVE_INFINITY
+	);
+	const elapsed = Number.isFinite(earliestStart)
+		? formatDuration(Date.now() - earliestStart)
+		: undefined;
 	const summaryLine = formatMetaLine(theme, [
 		`${counts.finished}/${details.results.length} done`,
 		`${counts.completed} completed`,
 		counts.failed > 0 ? `${counts.failed} failed` : undefined,
 		`${counts.stalled} stalled`,
 		counts.running > 0 ? `${counts.running} running` : undefined,
+		elapsed,
 	]);
 
 	if (expanded && !isRunning) {
 		const container = new Container();
-		const headerLines = [formatSubagentHeader(theme, "parallel", undefined, icon)];
-		if (summaryLine) appendSection(headerLines, [summaryLine]);
-		container.addChild(new Text(headerLines.join("\n"), 0, 0));
+		const headerLines: string[] = [];
+		if (summaryLine) headerLines.push(`${icon} ${summaryLine}`);
+		if (headerLines.length > 0) container.addChild(new Text(headerLines.join("\n"), 0, 0));
 
 		for (const result of details.results) {
 			const resultState = getParallelResultState(result);
-			const resultStatus = resultState === "completed" ? "completed" : resultState;
+			const resultStatus =
+				resultState === "completed"
+					? "completed"
+					: resultState === "running" && result.startTime
+						? `running ${formatDuration(Date.now() - result.startTime)}`
+						: resultState;
 			const resultStatusRole =
 				resultState === "failed"
 					? "status_error"
@@ -2028,8 +2086,8 @@ function renderParallelResult(
 		return container;
 	}
 
-	const lines: string[] = [formatSubagentHeader(theme, "parallel", undefined, icon)];
-	if (summaryLine) appendSection(lines, [summaryLine]);
+	const lines: string[] = [];
+	if (summaryLine) lines.push(`${icon} ${summaryLine}`);
 
 	for (let index = 0; index < details.results.length; index++) {
 		const result = details.results[index];
@@ -2037,7 +2095,12 @@ function renderParallelResult(
 		const branch = formatPresentationText(theme, "meta", isLast ? "└─" : "├─");
 		const stem = isLast ? "   " : `${formatPresentationText(theme, "meta", "│")}  `;
 		const resultState = getParallelResultState(result);
-		const resultStatus = resultState === "completed" ? "done" : resultState;
+		const resultStatus =
+			resultState === "completed"
+				? "done"
+				: resultState === "running" && result.startTime
+					? `running ${formatDuration(Date.now() - result.startTime)}`
+					: resultState;
 		const statusRole =
 			resultState === "failed"
 				? "status_error"