@selesai/code 0.8.6 → 0.8.8

package/dist/extensions/pi-subagents/test/unit/subagent-control.test.ts

@@ -8,6 +8,7 @@ import {
 	formatControlIntercomMessage,
 	formatControlNoticeMessage,
 	resolveControlConfig,
+	shouldEmitOpenToolAttention,
 	shouldNotifyControlEvent,
 } from "../../src/runs/shared/subagent-control.ts";
 import { nextLongRunningTrigger } from "../../src/runs/shared/long-running-guard.ts";
@@ -99,6 +100,15 @@ describe("subagent control attention state", () => {
 		}), "time_threshold");
 	});
 
+	it("marks non-exempt open tools for attention at the active threshold", () => {
+		const defaults = resolveControlConfig();
+
+		assert.equal(shouldEmitOpenToolAttention({ config: defaults, currentTool: "bash", currentToolStartedAt: 0, now: 239_999 }), false);
+		assert.equal(shouldEmitOpenToolAttention({ config: defaults, currentTool: "bash", currentToolStartedAt: 0, now: 240_000 }), true);
+		assert.equal(shouldEmitOpenToolAttention({ config: defaults, currentTool: "contact_supervisor", currentToolStartedAt: 0, now: 999_999 }), false);
+		assert.equal(shouldEmitOpenToolAttention({ config: { ...defaults, enabled: false }, currentTool: "bash", currentToolStartedAt: 0, now: 999_999 }), false);
+	});
+
 	it("supports opt-in turn and token long-running thresholds", () => {
 		const tokenBudget = resolveControlConfig(undefined, { activeNoticeAfterMs: 999_999, activeNoticeAfterTokens: 500_000 });
 		const turnBudget = resolveControlConfig(undefined, { activeNoticeAfterMs: 999_999, activeNoticeAfterTurns: 5 });
@@ -172,6 +182,24 @@ describe("subagent control attention state", () => {
 		assert.doesNotMatch(message, /Wait:/);
 	});
 
+	it("formats open-tool attention notices with tool facts", () => {
+		const event = buildControlEvent({
+			to: "needs_attention",
+			runId: "78f659a3",
+			agent: "worker",
+			reason: "tool_open_threshold",
+			message: "worker has had tool 'bash' open for 240s",
+			currentTool: "bash",
+			currentToolDurationMs: 240_000,
+			currentPath: "scripts/run-tests.sh",
+		});
+
+		const message = formatControlNoticeMessage(event, "subagent-worker-78f659a3");
+
+		assert.match(message, /worker has had tool 'bash' open for 240s/);
+		assert.match(message, /Facts: tool bash 240s \| path scripts\/run-tests\.sh/);
+	});
+
 	it("formats supervisor-request notices with pending-channel guidance", () => {
 		const event = buildControlEvent({
 			to: "needs_attention",

package/dist/extensions/pi-subagents/test/unit/subagent-prompt-runtime.test.ts

@@ -595,9 +595,13 @@ describe("subagent prompt runtime", () => {
 
 	it("registers child watchdog lifecycle handlers only when enabled by env", () => {
 		delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
-		// Clear the ack capture env explicitly: when this test suite itself runs inside a
-		// pi-subagents child, the runner sets it and an extra agent_end handler registers.
+		// Clear the ack capture and steer env vars explicitly: when this test suite itself
+		// runs inside a pi-subagents child, the runner sets them and extra agent_end
+		// handlers register (steering inbox is gated on SUBAGENT_STEER_INBOX_ENV).
 		delete process.env[RUNTIME_EXTENSION_ACK_PATH_ENV];
+		delete process.env[SUBAGENT_STEER_INBOX_ENV];
+		delete process.env[SUBAGENT_STEER_CAPABILITY_ENV];
+		delete process.env[SUBAGENT_STEER_ACK_DIR_ENV];
 		const handlersWithout = new Map<string, unknown[]>();
 		registerSubagentPromptRuntime({
 			on(event: string, handler: unknown) {
@@ -922,7 +926,7 @@ describe("subagent prompt runtime", () => {
 		assert.deepEqual(registered, ["subagent_wait"]);
 	});
 
-	it("registers native intercom before the final strict allowlist check", () => {
+	it("does not satisfy strict allowlists with native generic intercom", () => {
 		setSupervisorEnv();
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-intercom-diagnostic-"));
 		try {
@@ -944,9 +948,14 @@ describe("subagent prompt runtime", () => {
 			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void });
 
 			handlers.get("session_start")?.({});
-			assert.deepEqual(registered, ["subagent_wait", "contact_supervisor", "intercom"]);
+			assert.deepEqual(registered, ["subagent_wait", "contact_supervisor"]);
 			handlers.get("agent_start")?.({});
-			assert.equal(fs.existsSync(diagnosticPath), false);
+			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
+				agent: "scout",
+				required: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
+				available: ["subagent_wait", "contact_supervisor"],
+				missing: ["intercom"],
+			});
 		} finally {
 			fs.rmSync(dir, { recursive: true, force: true });
 		}
@@ -973,7 +982,7 @@ describe("subagent prompt runtime", () => {
 		assert.deepEqual(registered, ["subagent_wait", "contact_supervisor"]);
 	});
 
-	it("registers native supervisor tools at runtime when pi-intercom is absent", async () => {
+	it("registers only native supervisor tools at runtime when pi-intercom is absent", async () => {
 		setSupervisorEnv();
 		const previousRequiredTools = process.env[REQUIRED_CHILD_TOOLS_ENV];
 		delete process.env[REQUIRED_CHILD_TOOLS_ENV];
@@ -995,7 +1004,7 @@ describe("subagent prompt runtime", () => {
 			assert.deepEqual(registered, ["subagent_wait", "contact_supervisor"]);
 
 			await handlers.get("before_agent_start")?.({ systemPrompt: BASE_PROMPT });
-			assert.deepEqual(registered, ["subagent_wait", "contact_supervisor", "intercom"]);
+			assert.deepEqual(registered, ["subagent_wait", "contact_supervisor"]);
 		} finally {
 			if (previousRequiredTools === undefined) delete process.env[REQUIRED_CHILD_TOOLS_ENV];
 			else process.env[REQUIRED_CHILD_TOOLS_ENV] = previousRequiredTools;

package/dist/extensions/pi-subagents/test/unit/subagent-startup-retry.test.ts

@@ -4,6 +4,7 @@ import type { Usage } from "../../src/shared/types.ts";
 import {
 	MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS,
 	SUBAGENT_STARTUP_RETRY_DELAYS_MS,
+	formatSubagentExtensionConflictError,
 	formatSubagentStartupRetryExhaustedError,
 	formatSubagentStartupRetryNote,
 	isRetryableSubagentStartupFailure,
@@ -69,6 +70,20 @@ describe("subagent startup retry", () => {
 		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ turnBudgetExceeded: true })), false);
 	});
 
+	it("adds actionable guidance for ambient extension registration conflicts", () => {
+		const conflict = 'Error: Failed to load extension "/tmp/pi-mcp-adapter-clone/index.ts": Tool "mcpScript" conflicts with /tmp/pi-mcp-adapter/index.ts\nError: Failed to load extension "/tmp/pi-mcp-adapter-clone/index.ts": Flag "--mcp-config" conflicts with /tmp/pi-mcp-adapter/index.ts';
+		const formatted = formatSubagentExtensionConflictError(conflict, {
+			agent: "reviewer",
+			ambientExtensionsEnabled: true,
+		});
+
+		assert.match(formatted ?? "", /loaded conflicting ambient Pi extensions/);
+		assert.match(formatted ?? "", /\.pi\/settings\.json/);
+		assert.match(formatted ?? "", /\{"subagents":\{"agentOverrides":\{"reviewer":\{"extensions":\[\]\}\}\}\}/);
+		assert.equal(formatSubagentExtensionConflictError(conflict, { agent: "reviewer", ambientExtensionsEnabled: false }), conflict);
+		assert.equal(formatSubagentExtensionConflictError("authentication failed", { agent: "reviewer", ambientExtensionsEnabled: true }), "authentication failed");
+	});
+
 	it("formats retry and exhaustion diagnostics without task content", () => {
 		assert.equal(
 			formatSubagentStartupRetryNote({ model: "openai/test", attempt: 1, maxAttempts: 4, delayMs: 250 }),

package/dist/extensions/pi-subagents/test/unit/subagent-wait.test.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { writeAsyncResultFile } from "../../src/runs/background/result-files.ts";
 import { WAIT_TOOL_ENABLED_ENV, resolveWaitToolConfig, waitForSubagents, type SubagentWaitDeps } from "../../src/runs/background/subagent-wait.ts";
 import { recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 import type { AsyncStatus, SubagentState } from "../../src/shared/types.ts";
@@ -218,6 +219,32 @@ describe("subagent_wait tool", () => {
 		}
 	});
 
+	it("tells blocking callers to reply and wait for intercom-detached failed runs", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-intercom-detach-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "worker-session.jsonl");
+			fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-detached", "running", { sessionId: "sess-1", pid: 999999 });
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => writeStatus(asyncRoot, "run-detached", "failed", {
+					sessionId: "sess-1",
+					error: "Step failed: worker",
+					steps: [{ agent: "worker", status: "failed", sessionFile, error: "Detached for intercom coordination before task completion." }],
+				}),
+			}));
+
+			const text = textOf(result);
+			assert.match(text, /Reply to the supervisor request first/);
+			assert.match(text, /wait with subagent_wait/);
+			assert.match(text, /do not resume or launch a replacement/);
+			assert.doesNotMatch(text, /Resume-first/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("surfaces terminal completion payloads from the result file in details.completions", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-completions-file-"));
 		try {
@@ -270,6 +297,45 @@ describe("subagent_wait tool", () => {
 		}
 	});
 
+	it("surfaces terminal completion payloads from an indexed pending result file", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-completions-pending-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			const publicResultPath = path.join(resultsDir, "run-pending.json");
+			fs.mkdirSync(publicResultPath, { recursive: true });
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-pending", "running", { sessionId: "sess-1", pid: 999999 });
+
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => {
+					writeStatus(asyncRoot, "run-pending", "complete", { sessionId: "sess-1" });
+					assert.deepEqual(writeAsyncResultFile(publicResultPath, {
+						id: "run-pending",
+						runId: "run-pending",
+						sessionId: "sess-1",
+						agent: "worker",
+						mode: "single",
+						state: "complete",
+						success: true,
+						results: [{ agent: "worker", success: true, outputState: "present" }],
+					}), { state: "pending" });
+				},
+			}));
+
+			assert.equal(result.isError, undefined);
+			assert.equal(result.details.completions?.[0]?.runId, "run-pending");
+			assert.equal(result.details.completions?.[0]?.success, true);
+			assert.equal(result.details.completions?.[0]?.results?.[0]?.agent, "worker");
+			assert.equal(fs.statSync(publicResultPath).isDirectory(), true);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("reports malformed terminal result files as actionable errors", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-completions-malformed-"));
 		try {
@@ -949,33 +1015,31 @@ describe("subagent_wait tool", () => {
 				},
 			};
 
-			// A real timer-based sleep with a LONG poll interval; if wait waited for
-			// the poll it would take ~10s. The event should wake it in ~10ms.
 			let sleepCalls = 0;
-			const realSleep = (ms: number, signal?: AbortSignal) => new Promise<void>((resolve) => {
+			let sleepArmed!: () => void;
+			const armed = new Promise<void>((resolve) => { sleepArmed = resolve; });
+			const sleep = (_ms: number, signal?: AbortSignal) => new Promise<void>((resolve) => {
 				sleepCalls += 1;
-				const t = setTimeout(resolve, ms);
-				signal?.addEventListener("abort", () => { clearTimeout(t); resolve(); }, { once: true });
+				signal?.addEventListener("abort", resolve, { once: true });
+				sleepArmed();
 			});
 
-			const startedAt = Date.now();
 			const p = waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
 				events,
 				pollIntervalMs: 10_000,
-				sleep: realSleep,
+				sleep,
 			}));
 
-			// After a short delay, flip the run terminal and emit a completion event.
-			setTimeout(() => {
-				writeStatus(asyncRoot, "run-a", "complete", { sessionId: "sess-1" });
-				events.emit("subagent:async-complete", { id: "run-a" });
-			}, 15);
+			await armed;
+			writeStatus(asyncRoot, "run-a", "complete", { sessionId: "sess-1" });
+			events.emit("subagent:async-complete", { id: "run-a" });
 
-			const result = await p;
-			const elapsed = Date.now() - startedAt;
+			const result = await Promise.race([
+				p,
+				new Promise<never>((_resolve, reject) => setTimeout(() => reject(new Error("event wake did not resolve subagent_wait")), 1_000)),
+			]);
 			assert.equal(result.isError, undefined);
 			assert.match(textOf(result), /done/i);
-			assert.ok(elapsed < 5_000, `should wake via event, not the 10s poll; took ${elapsed}ms`);
 			assert.ok(sleepCalls >= 1, "poll-interval sleep still armed as fallback");
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });

package/dist/extensions/pi-subagents/test/unit/tool-description.test.ts

@@ -29,7 +29,7 @@ function parentToolEnv(agentDir?: string): NodeJS.ProcessEnv {
 
 describe("registered subagent tool description", () => {
 	it("describes the four first-class execution modes", () => {
-		const description = buildSubagentToolDescription();
+		const description = buildSubagentToolDescription({ toolDescriptionMode: "full" });
 		assert.match(description, /^Delegate one child with \{ agent, task \}/i);
 		assert.match(description, /SINGLE: \{ agent, task\? \}/i);
 		assert.match(description, /CHAIN: \{ chain: \[\{ agent: "explorer"/i);
@@ -49,7 +49,7 @@ describe("registered subagent tool description", () => {
 	});
 
 	it("includes legacy chain-control guidance when enabled", () => {
-		const description = buildSubagentToolDescription({ legacyChainControls: true });
+		const description = buildSubagentToolDescription({ toolDescriptionMode: "full", legacyChainControls: true });
 		assert.match(description, /append-step.*step:/i);
 		assert.match(description, /approve-checkpoint|reject-checkpoint/);
 	});
@@ -147,7 +147,7 @@ describe("registered subagent tool description", () => {
 		assert.doesNotMatch(description, /decide a paused durable legacy chain checkpoint/);
 	});
 
-	it("falls back to full mode when custom mode has no valid file", () => {
+	it("falls back to compact mode when custom mode has no valid file", () => {
 		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-missing-"));
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-agent-"));
 		const warnings: string[] = [];
@@ -157,11 +157,11 @@ describe("registered subagent tool description", () => {
 			{ cwd, agentDir, warn: (message) => warnings.push(message) },
 		);
 
-		assert.equal(description, FULL_SUBAGENT_TOOL_DESCRIPTION);
-		assert.ok(warnings.some((message) => message.includes("using full description")));
+		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		assert.ok(warnings.some((message) => message.includes("using compact description")));
 	});
 
-	it("falls back to full mode when toolDescriptionMode is invalid", () => {
+	it("falls back to compact mode when toolDescriptionMode is invalid", () => {
 		const warnings: string[] = [];
 
 		const description = buildSubagentToolDescription(
@@ -169,7 +169,7 @@ describe("registered subagent tool description", () => {
 			{ warn: (message) => warnings.push(message) },
 		);
 
-		assert.equal(description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
 		assert.ok(warnings.some((message) => message.includes("Ignoring invalid toolDescriptionMode")));
 	});
 
@@ -219,7 +219,7 @@ describe("registered subagent tool description", () => {
 
 	it("registers full, compact, custom, and fallback descriptions from extension config", () => {
 		const defaultAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-default-"));
-		writeExtensionConfig(defaultAgentDir, { legacyChainControls: true });
+		writeExtensionConfig(defaultAgentDir, { toolDescriptionMode: "full", legacyChainControls: true });
 		assert.equal(readRegisteredTool(defaultAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
 
 		const compactAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-compact-"));
@@ -235,20 +235,20 @@ describe("registered subagent tool description", () => {
 
 		const missingCustomAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-missing-"));
 		writeExtensionConfig(missingCustomAgentDir, { toolDescriptionMode: "custom", legacyChainControls: true });
-		assert.equal(readRegisteredTool(missingCustomAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(readRegisteredTool(missingCustomAgentDir).description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
 
 		const invalidAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-invalid-"));
 		writeExtensionConfig(invalidAgentDir, { toolDescriptionMode: "tiny", legacyChainControls: true });
-		assert.equal(readRegisteredTool(invalidAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(readRegisteredTool(invalidAgentDir).description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
 	});
 
-	it("registers the full schema and first-class chain description by default", () => {
+	it("registers the full schema and chain description by default", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-trimmed-"));
 		const tool = readRegisteredTool(agentDir);
 		assert.equal(tool.properties.includes("step"), true);
 		assert.equal(tool.properties.includes("chain"), true);
 		assert.equal(tool.properties.includes("tasks"), true);
-		assert.match(tool.description, /CHAIN: \{ chain:/i);
+		assert.match(tool.description, /CHAIN \{chain:/i);
 	});
 
 	it("registers the trimmed schema and description when legacyChainControls is false", () => {

package/dist/extensions/pi-subagents/test/unit/tool-timeout.test.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	DEFAULT_FAST_TOOL_TIMEOUT_MS,
+	DEFAULT_FAST_TOOL_TIMEOUT_TOOLS,
+	TOOL_TIMEOUT_ALLOWLIST,
+	TOOL_TIMEOUT_ENV,
+	defaultToolTimeoutMs,
+	effectiveToolTimeoutMs,
+	formatToolTimeoutMessage,
+	isToolTimeoutExempt,
+	resolveToolTimeoutMs,
+	toolTimeoutCallKey,
+	toolTimeoutFromEnv,
+} from "../../src/runs/shared/tool-timeout.ts";
+
+describe("resolveToolTimeoutMs", () => {
+	it("has no configured hard timeout when nothing is configured anywhere", () => {
+		assert.deepEqual(resolveToolTimeoutMs({}), {});
+	});
+
+	it("honors precedence: per-call > agent frontmatter > config > env", () => {
+		const input = {
+			callValue: 1_000,
+			agentValue: 2_000,
+			configValue: 3_000,
+			envValue: "4000",
+		};
+		assert.deepEqual(resolveToolTimeoutMs(input), { toolTimeoutMs: 1_000 });
+		assert.deepEqual(resolveToolTimeoutMs({ ...input, callValue: undefined }), { toolTimeoutMs: 2_000 });
+		assert.deepEqual(resolveToolTimeoutMs({ ...input, callValue: undefined, agentValue: undefined }), {
+			toolTimeoutMs: 3_000,
+		});
+		assert.deepEqual(
+			resolveToolTimeoutMs({ ...input, callValue: undefined, agentValue: undefined, configValue: undefined }),
+			{ toolTimeoutMs: 4_000 },
+		);
+	});
+
+	it("accepts the env value as a plain integer string", () => {
+		assert.deepEqual(
+			resolveToolTimeoutMs({ envValue: "60000", callValue: undefined, agentValue: undefined, configValue: undefined }),
+			{ toolTimeoutMs: 60_000 },
+		);
+	});
+
+	it("rejects non-positive, non-integer, and oversized values with an error", () => {
+		for (const bad of [0, -1, 1.5, "abc", Number.NaN]) {
+			const r = resolveToolTimeoutMs({ callValue: bad });
+			assert.ok(r.error, `expected error for ${String(bad)}`);
+			assert.match(r.error!, /positive integer/);
+		}
+		const huge = resolveToolTimeoutMs({ callValue: 2_147_483_648 });
+		assert.ok(huge.error);
+		assert.match(huge.error!, /no larger than/);
+	});
+
+	it("ignores an empty env string (treated as unset)", () => {
+		assert.deepEqual(resolveToolTimeoutMs({ envValue: "  " }), {});
+	});
+});
+
+describe("effectiveToolTimeoutMs", () => {
+	it("uses a default hard timeout only for known-fast tools", () => {
+		for (const tool of ["read", "grep", "find", "ls", "edit", "write", "structured_output"]) {
+			assert.equal(defaultToolTimeoutMs(tool), DEFAULT_FAST_TOOL_TIMEOUT_MS, tool);
+			assert.equal(effectiveToolTimeoutMs(tool, undefined), DEFAULT_FAST_TOOL_TIMEOUT_MS, tool);
+		}
+		assert.equal(defaultToolTimeoutMs("bash"), undefined);
+		assert.equal(effectiveToolTimeoutMs("bash", undefined), undefined);
+		assert.deepEqual([...DEFAULT_FAST_TOOL_TIMEOUT_TOOLS].sort(), ["edit", "find", "grep", "ls", "read", "structured_output", "write"]);
+	});
+
+	it("lets an explicit configured timeout win for non-exempt tools", () => {
+		assert.equal(effectiveToolTimeoutMs("bash", 1234), 1234);
+		assert.equal(effectiveToolTimeoutMs("read", 1234), 1234);
+	});
+
+	it("never applies a tool timeout to blocking coordination tools", () => {
+		for (const tool of ["contact_supervisor", "intercom", "subagent_wait"]) {
+			assert.equal(isToolTimeoutExempt(tool), true, `${tool} must be exempt`);
+			assert.equal(effectiveToolTimeoutMs(tool, 1234), undefined);
+			assert.equal(effectiveToolTimeoutMs(tool, undefined), undefined);
+		}
+		assert.equal(isToolTimeoutExempt("bash"), false);
+		assert.equal(isToolTimeoutExempt(undefined), false);
+		assert.deepEqual([...TOOL_TIMEOUT_ALLOWLIST].sort(), ["contact_supervisor", "intercom", "subagent_wait"]);
+	});
+});
+
+describe("tool timeout formatting and keys", () => {
+	it("formats timeout errors consistently", () => {
+		assert.equal(formatToolTimeoutMessage("bash", 1000), "Tool 'bash' exceeded its timeout of 1000ms.");
+	});
+
+	it("uses toolCallId when present and falls back to an anonymous sequence", () => {
+		assert.equal(toolTimeoutCallKey({ toolCallId: "call-1", toolName: "read" }, 9), "id:call-1");
+		assert.equal(toolTimeoutCallKey({ toolName: "read" }, 9), "anon:read:9");
+	});
+});
+
+describe("toolTimeoutFromEnv", () => {
+	it("reads SELESAI_SUBAGENT_TOOL_TIMEOUT_MS from the process env, with PI_ fallback", () => {
+		assert.equal(TOOL_TIMEOUT_ENV, "SELESAI_SUBAGENT_TOOL_TIMEOUT_MS");
+		assert.equal(toolTimeoutFromEnv({ SELESAI_SUBAGENT_TOOL_TIMEOUT_MS: "123" }), "123");
+		assert.equal(toolTimeoutFromEnv({ PI_SUBAGENT_TOOL_TIMEOUT_MS: "456" }), "456");
+		assert.equal(toolTimeoutFromEnv({}), undefined);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/wait-subscriptions.test.ts

@@ -235,6 +235,40 @@ describe("non-blocking wait subscriptions", () => {
 		}
 	});
 
+	it("tells the parent to reply and wait for an intercom-detached failed async run", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-intercom-detach-"));
+		const asyncRoot = path.join(root, "runs");
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const sessionFile = path.join(root, "worker-session.jsonl");
+		const sent: string[] = [];
+		const state = makeState();
+		const manager = createWaitSubscriptionManager({
+			events: new TestBus(),
+			sendMessage(message: { content?: unknown }) { sent.push(String(message.content)); },
+		} as never, state, { asyncDirRoot: asyncRoot, subscriptionsDir, pollIntervalMs: 60_000, kill: () => true });
+		try {
+			fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+			writeStatus(asyncRoot, "run-detached", "running", { sessionId: "session-a", pid: 999_999 });
+			manager.arm({ targetKind: "async", runId: "run-detached", requestedId: "run-detached", timeoutMs: 30_000 });
+
+			writeStatus(asyncRoot, "run-detached", "failed", {
+				sessionId: "session-a",
+				error: "Step failed: worker",
+				steps: [{ agent: "worker", status: "failed", sessionFile, error: "Detached for intercom coordination before task completion." }],
+			});
+			manager.reconcile();
+
+			const message = sent[0] ?? "";
+			assert.match(message, /Reply to the supervisor request first/);
+			assert.match(message, /wait with subagent_wait/);
+			assert.match(message, /do not resume or launch a replacement/);
+			assert.doesNotMatch(message, /Resume-first/);
+		} finally {
+			manager.dispose();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("waits for foreground run restoration before reconciling a restored subscription", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-foreground-restore-"));
 		const subscriptionsDir = path.join(root, "subscriptions");

package/dist/extensions/pi-subagents/test/unit/workflow-chat-progress.test.ts

@@ -4,7 +4,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { isSameGitRepository, resolveWorkflowChatProgress } from "../../src/workflows/chat-progress.ts";
+import { buildWorkflowChatProgressRows, isSameGitRepository, resolveWorkflowChatProgress } from "../../src/workflows/chat-progress.ts";
 import { renderSubagentResult } from "../../src/tui/render.ts";
 import { bindMissionWorkflowChildAsyncLaunch, createSubagentExecutor, foregroundResultIntercomStatus, missionWorkflowChildStatus, runMissionWorkflowChild, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
 import { readMissionBinding } from "../../src/missions/lifecycle.ts";
@@ -202,6 +202,38 @@ describe("workflow chat progress rendering", () => {
 		}
 	});
 
+	it("warns once when a workflow child outlives its mission record", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-missing-mission-"));
+		const originalWarn = console.warn;
+		const warnings: string[] = [];
+		try {
+			const location = {
+				projectRoot: root,
+				missionDir: path.join(root, ".pi/subagents", "missions"),
+				globalIndexDir: path.join(root, ".pi/subagents", "mission-index"),
+				writeGlobalIndex: false,
+			};
+			const mission = createMission(location, { title: "Workflow", objective: "Track child" });
+			fs.rmSync(path.join(location.missionDir, `${mission.id}.json`));
+			console.warn = (...args: unknown[]) => warnings.push(args.map(String).join(" "));
+
+			for (const key of ["first", "second"]) {
+				await assert.rejects(
+					() => runMissionWorkflowChild({ missionId: mission.id, location, autoCreated: false }, "wf-missing-mission", key, "Prep", async () => {
+						throw new Error("child failed");
+					}),
+					/child failed/,
+				);
+			}
+
+			assert.equal(warnings.length, 1);
+			assert.match(warnings[0] ?? "", new RegExp(`Mission '${mission.id}' is no longer in the mission store`));
+		} finally {
+			console.warn = originalWarn;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("renders stable rows keyed by workflow trace entries", () => {
 		const text = componentText(renderSubagentResult({
 			content: [{ type: "text", text: "Workflow running." }],
@@ -215,6 +247,7 @@ describe("workflow chat progress rendering", () => {
 						{ operation: "run", key: "scout", state: "completed", runId: "run-scout", phase: "Validation", label: "Found renderer seam", durationMs: 12 },
 						{ operation: "run", key: "tests", state: "started", phase: "Validation", label: "focused integration suite" },
 						{ operation: "run", key: "review", state: "failed", phase: "Validation", label: "fresh-context UX review", error: "needs fixes" },
+						{ operation: "run", key: "stale", state: "stopped", phase: "Validation", label: "superseded exact-head review", error: "Workflow stopped by user." },
 					],
 					emits: [],
 					console: [],
@@ -228,6 +261,66 @@ describe("workflow chat progress rendering", () => {
 		assert.match(text, /complete\s+scout Found renderer seam/);
 		assert.match(text, /running\s+tests focused integration suite/);
 		assert.match(text, /failed\s+review fresh-context UX review .* needs fixes/);
+		assert.match(text, /stopped\s+stale superseded exact-head review .* Workflow stopped by user/);
+	});
+
+	it("renders detached workflow trace rows as paused attention", () => {
+		const trace: NonNullable<Details["workflow"]>["trace"] = [{
+			operation: "run",
+			key: "detaches",
+			state: "detached",
+			phase: "Decision",
+			label: "supervisor handoff",
+			error: "Detached for intercom coordination. Reply to the supervisor request first.",
+		}];
+		const rows = buildWorkflowChatProgressRows(trace);
+		assert.equal(rows[0]?.state, "detached");
+
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow paused." }],
+			details: {
+				mode: "workflow",
+				runId: "wf_detached",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: { trace, emits: [], console: [] },
+			},
+		}, { expanded: false }, theme as any));
+
+		assert.match(text, /workflow wf_detached .* same repo .* paused/);
+		assert.match(text, /Phase  Decision/);
+		assert.match(text, /detached\s+detaches supervisor handoff .* Detached for intercom coordination/);
+		assert.doesNotMatch(text, /running\s+detaches/);
+		assert.doesNotMatch(text, /failed\s+detaches/);
+	});
+
+	it("applies main-window density settings to collapsed workflow live cards", () => {
+		const trace = Array.from({ length: 10 }, (_, index) => ({
+			operation: "run" as const,
+			key: `step-${index}`,
+			state: "started" as const,
+			label: `review ${index}`,
+		}));
+		const result = {
+			content: [{ type: "text" as const, text: "Workflow running." }],
+			details: {
+				mode: "workflow" as const,
+				runId: "wf_density",
+				results: [],
+				chatProgress: { mode: "live-card" as const, repoRelation: "same" as const, repoLabel: "pi-subagents" },
+				workflow: { trace, emits: [], console: [] },
+			},
+		};
+
+		const compact = renderSubagentResult(result, { expanded: false }, theme as any, undefined, { horizontalSpacing: 0, compactResultMaxLines: 3 }).render(120);
+		assert.equal(compact.length, 3);
+		assert.match(compact[1]!, /^Repo   pi-subagents\s*$/);
+		assert.match(compact[2]!, /rows hidden/);
+
+		const expanded = renderSubagentResult(result, { expanded: true }, theme as any, undefined, { horizontalSpacing: 0, compactResultMaxLines: 3 }).render(120);
+		assert.ok(expanded.length > 3);
+		assert.match(expanded[1]!, /^  Repo   pi-subagents\s*$/);
+		assert.doesNotMatch(expanded.join("\n"), /rows hidden · .* expands/);
 	});
 
 	it("bounds workflow live-card rows and keeps old failed children visible", () => {