@selesai/code 0.13.3 → 0.13.5

package/dist/extensions/pi-subagents/test/integration/single-execution.test.ts

@@ -64,6 +64,7 @@ import { missionStatePath } from "../../src/missions/workflow-state.ts";
 import { discardPreservedWorktrees } from "../../src/runs/shared/parallel-handoff.ts";
 import { createWorktrees } from "../../src/runs/shared/worktree.ts";
 import { resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import { createResultWatcher } from "../../src/runs/background/result-watcher.ts";
 import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
 import { createWorkflowChildPermit, workflowChildPermitConsumed } from "../../src/shared/workflow-child-permit.ts";
 import { toSubagentDelegationExecutionParams } from "../../src/slash/delegation-adapters.ts";
@@ -137,6 +138,7 @@ interface RunSyncResult {
 	processSignal?: string | null;
 	interrupted?: boolean;
 	timedOut?: boolean;
+	timeoutRecovery?: { changedFiles?: string[]; message?: string; recoveryNeeded?: boolean; reason?: string; reportStatus?: string };
 	turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; exceededAtTurn?: number };
 	turnBudgetExceeded?: boolean;
 	wrapUpRequested?: boolean;
@@ -915,6 +917,24 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.deepEqual(failed.details.workflow?.receipt?.hostSteps?.map(({ state, reasonCode, exitCode }) => ({ state, reasonCode, exitCode })), [{ state: "error", reasonCode: "command_failed", exitCode: 4 }]);
 	});
 
+	it("explains the cwd workaround instead of launching a host step", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		const executor = makeExecutor([makeAgent("echo")]);
+		const result = await executor.executePublic(
+			"host-command-cwd",
+			{
+				async: false,
+				workflowScript: `return await runs.host("tests", { kind: "command", command: "npm test", timeoutMs: 5000, cwd: "/tmp" });`,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /does not accept per-step cwd.*workflow cwd.*outer subagent request.*cd \/path\/to\/worktree/);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
 	it("rejects a child output claimed by an earlier host command", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		const scriptPath = path.join(tempDir, "host-output-owner.cjs");
 		fs.writeFileSync(scriptPath, `process.stdout.write("host owns output\\n");`);
@@ -1260,6 +1280,79 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		fs.rmSync(resultPath, { force: true });
 	});
 
+	it("delivers a terminal Darwin workflow failure after demand disappears", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		const state: SubagentState = {
+			baseCwd: tempDir,
+			currentSessionId: "session-1700",
+			completionOwnerId: "owner-1700",
+			asyncJobs: new Map(),
+			foregroundControls: new Map(),
+			lastForegroundControlId: null,
+			completionSeen: new Map(),
+			resultFileCoalescer: { schedule: () => false, clear: () => {} },
+		};
+		let pollCreated = false;
+		const delivered: Array<{ id?: string; state?: string }> = [];
+		const piEvents = createEventBus();
+		const watcher = createResultWatcher({ events: piEvents }, state, DIRS.results, 60_000, {
+			platform: "darwin",
+			deliverIntercomResults: false,
+			coalesceDelayMs: 0,
+			hasDeliveryDemand: () => [...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running"),
+			notifier: { deliver: async (result) => { delivered.push({ id: result.id, state: result.state }); return true; } },
+			timers: {
+				setTimeout,
+				clearTimeout,
+				setInterval: ((handler: () => void, delay?: number) => {
+					assert.equal(delay, 3000);
+					pollCreated = true;
+					return { unref() {} } as NodeJS.Timeout;
+				}) as typeof setInterval,
+				clearInterval: (() => {}) as typeof clearInterval,
+			},
+		});
+		let asyncDir: string | undefined;
+		let resultPath: string | undefined;
+		try {
+			const executor = createSubagentExecutor!({
+				pi: { events: piEvents, getSessionName: () => undefined },
+				state,
+				config: {},
+				asyncByDefault: false,
+				tempArtifactsDir: tempDir,
+				getSubagentSessionRoot: () => path.join(tempDir, ".pi-subagents", "sessions"),
+				expandTilde: (value: string) => value,
+				discoverAgents: () => ({ agents: [makeAgent("echo")] }),
+				refreshResultDelivery: watcher.refreshResultDelivery,
+			});
+			const launchPromise = executor.execute(
+				"darwin-immediate-workflow-failure",
+				{ async: true, workflowScript: "{" },
+				new AbortController().signal,
+				undefined,
+				{ ...makeMinimalCtx(tempDir), sessionManager: { getSessionId: () => "session-1700", getSessionFile: () => null } },
+			);
+			watcher.startResultWatcher();
+			assert.equal(pollCreated, true, "expected Darwin demand polling to be armed");
+			const launch = await launchPromise;
+			assert.equal(launch.isError, undefined, launch.content[0]?.text ?? "workflow launch failed");
+			const workflowRunId = launch.details.asyncId;
+			assert.ok(workflowRunId);
+			asyncDir = launch.details.asyncDir;
+			resultPath = path.join(DIRS.results, `${workflowRunId}.json`);
+			for (let attempt = 0; attempt < 100 && (state.asyncJobs.get(workflowRunId)?.status !== "failed" || delivered.length === 0); attempt += 1) {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+			}
+			assert.equal(state.asyncJobs.get(workflowRunId)?.status, "failed");
+			assert.equal([...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running"), false);
+			assert.deepEqual(delivered, [{ id: workflowRunId, state: "failed" }], "terminal completion must not require a manual result refresh");
+		} finally {
+			watcher.stopResultWatcher();
+			if (asyncDir) fs.rmSync(asyncDir, { recursive: true, force: true });
+			if (resultPath) fs.rmSync(resultPath, { force: true });
+		}
+	});
+
 	it("keeps script workflow phase during async auto-resume", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		mockPi.onCall({
 			jsonl: [
@@ -7641,6 +7734,36 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(result.progress.status, "failed");
 	});
 
+	it("treats an unchanged pre-existing file-only output as missing on dirty foreground timeout", async () => {
+		execFileSync("git", ["init"], { cwd: tempDir, stdio: "ignore" });
+		execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: tempDir });
+		execFileSync("git", ["config", "user.name", "Test User"], { cwd: tempDir });
+		const reportPath = path.join(tempDir, "report.md");
+		fs.writeFileSync(path.join(tempDir, "input.md"), "base\n", "utf-8");
+		fs.writeFileSync(reportPath, "stale report\n", "utf-8");
+		execFileSync("git", ["add", "input.md", "report.md"], { cwd: tempDir });
+		execFileSync("git", ["commit", "-m", "base"], { cwd: tempDir, stdio: "ignore" });
+
+		mockPi.onCall({
+			writeFiles: [{ path: "input.md", content: "changed\n" }],
+			steps: [{ delay: 10_000 }],
+		});
+
+		const result = await runSync(tempDir, makeAgentConfigs(["slow"]), "slow", "Slow task", {
+			timeoutMs: 150,
+			outputPath: reportPath,
+			outputMode: "file-only",
+			acceptance: false,
+		});
+
+		assert.equal(result.timedOut, true);
+		assert.deepEqual(result.timeoutRecovery?.changedFiles, ["input.md"]);
+		assert.equal(result.timeoutRecovery?.reportStatus, "missing");
+		assert.equal(result.timeoutRecovery?.recoveryNeeded, true);
+		assert.match(result.finalOutput ?? "", /requested report: missing/i);
+		assert.equal(fs.readFileSync(reportPath, "utf-8"), "stale report\n");
+	});
+
 	it("ignores legacy turn-budget options without prompt injection or termination", async () => {
 		mockPi.onCall({
 			jsonl: [

package/dist/extensions/pi-subagents/test/unit/agent-management.test.ts

@@ -60,6 +60,54 @@ describe("agent management config parsing", () => {
 		assert.doesNotMatch(readText(result), /- scout \(builtin/);
 	});
 
+	it("lists compact declared capabilities without exposing system prompts", () => {
+		const agentsDir = path.join(tempDir, ".selesai", "agents");
+		fs.mkdirSync(agentsDir, { recursive: true });
+		fs.writeFileSync(path.join(agentsDir, "capability-worker.md"), [
+			"---",
+			"name: capability-worker",
+			"description: Capability worker",
+			"aliases: capability",
+			"tools: read, grep, mcp:github/search",
+			"model: openai/gpt-5-mini",
+			"fallbackModels: openai/gpt-5-mini-fallback",
+			"async: true",
+			"timeoutMs: 123",
+			"thinking: high",
+			"skills: typescript-code",
+			"extensions: github",
+			"subagentOnlyExtensions: surf",
+			"mutationTools: edit, write",
+			"output: report.md",
+			"outputMode: file-only",
+			"---",
+			"SYSTEM_PROMPT_SENTINEL",
+			"---",
+		].join("\n"));
+
+		const capabilityRequest = { agentScope: "project", capabilities: true };
+		const listed = handleManagementAction("list", capabilityRequest, {
+			cwd: tempDir,
+			modelRegistry: { getAvailable: () => [] },
+		});
+		assert.equal(listed.isError, false);
+		const text = readText(listed);
+		assert.match(text, /^Executable agents \(capabilities\):/);
+		assert.match(text, /- capability-worker \(project, aliases: capability\): Description: Capability worker; Tools: read, grep, mcp:github\/search; Model: openai\/gpt-5-mini; Thinking: high/);
+		assert.doesNotMatch(text, /System Prompt:|SYSTEM_PROMPT_SENTINEL/);
+		const capabilities = listed.details?.agentCapabilities;
+		assert.ok(capabilities);
+		const row = capabilities.agents.find((agent) => agent.name === "capability-worker");
+		assert.ok(row);
+		assert.equal(row.executable, true);
+		assert.deepEqual(row.tools, { ambient: false, names: ["read", "grep"], mcpDirectTools: ["github/search"], mutationTools: ["edit", "write"] });
+		assert.deepEqual(row.model, { value: "openai/gpt-5-mini", fallbackModels: ["openai/gpt-5-mini-fallback"], thinking: "high" });
+		assert.deepEqual(row.execution, { defaultAsync: true, timeoutMs: 123 });
+		assert.deepEqual(row.output, { path: "report.md", mode: "file-only" });
+		assert.deepEqual(row.extensions, { names: ["github"], subagentOnly: ["surf"], skills: ["typescript-code"] });
+		assert.equal(JSON.stringify(capabilities).includes("SYSTEM_PROMPT_SENTINEL"), false);
+	});
+
 	it("rejects management attempts to widen the reserved read-only Claude profile", () => {
 		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
 		const writerRunner = { type: "external-cli", adapter: "claude-code-writer", command: "claude" };

package/dist/extensions/pi-subagents/test/unit/async-status-projection.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import type { AsyncJobState, HostStepNodeV1 } from "../../src/shared/types.ts";
+import type { AsyncJobState, HostStepNodeV1, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../src/shared/types.ts";
 import {
 	ASYNC_STATUS_SNAPSHOT_KIND,
 	ASYNC_STATUS_SNAPSHOT_VERSION,
@@ -30,6 +30,27 @@ function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
 	};
 }
 
+const stagedLaneKeys = ["scope-scout", "red-tests", "label-helpers", "summary-title", "detail-row", "tiers-noise", "validation", "minimality-challenge", "fresh-review"];
+
+function stagedLaneGraph(statuses: WorkflowNodeStatus[] = stagedLaneKeys.map((_, index) => index === 0 ? "running" : "pending")): WorkflowGraphSnapshot {
+	const nodeIds = stagedLaneKeys.map((key) => `issue-1695.${key}`);
+	return {
+		runId: "workflow-1695",
+		mode: "workflow",
+		phases: [{ title: "issue-1695", nodeIds }],
+		nodes: stagedLaneKeys.map((key, index) => ({
+			id: nodeIds[index]!,
+			kind: "step",
+			agent: index === 0 ? "scout" : index === 7 ? "simplifier" : "worker",
+			label: key,
+			status: statuses[index] ?? "pending",
+			flatIndex: index,
+			stepIndex: index,
+		})),
+		currentNodeId: nodeIds[statuses.findIndex((status) => status === "running")],
+	};
+}
+
 describe("async status projection", () => {
 	it("projects already-loaded jobs in deterministic newest-first order", () => {
 		const snapshot = projectAsyncStatusSnapshot([
@@ -77,6 +98,18 @@ describe("async status projection", () => {
 		assert.doesNotMatch(serialized, /private\/report|fileMutation|Required file-only output/);
 	});
 
+	it("maps malformed persisted states to partial instead of widening the public state union", () => {
+		const snapshot = projectAsyncStatusSnapshot([{
+			asyncId: "bad-state",
+			asyncDir: "/tmp/bad-state",
+			status: "mystery",
+			steps: [{ agent: "worker", status: "also-mystery" }],
+		} as unknown as AsyncJobState]);
+
+		assert.equal(snapshot.runs[0]?.state, "partial");
+		assert.equal(snapshot.runs[0]?.children?.[0]?.state, "partial");
+	});
+
 	it("projects compact Fleet workflow rows without applying UI bounds", () => {
 		const rows = projectAsyncWorkflowRows([{
 			agent: "reviewer",
@@ -84,6 +117,7 @@ describe("async status projection", () => {
 			label: "Fresh review",
 			phase: "quality",
 			status: "partial",
+			context: "fresh",
 			activityState: "needs_attention",
 			startedAt: 10,
 			tokens: { input: 20, output: 5, total: 25, window: 18 },
@@ -92,6 +126,7 @@ describe("async status projection", () => {
 		assert.deepEqual(rows, [{
 			name: "quality: review · Fresh review (reviewer)",
 			state: "partial",
+			context: "fresh",
 			activity: "needs attention",
 			startedAt: 10,
 			tokens: 25,
@@ -172,6 +207,27 @@ describe("async status projection", () => {
 		]);
 	});
 
+	it("projects known runs.lanes stages from the workflow graph, including pending stages", () => {
+		const rows = projectAsyncWorkflowRows([{
+			agent: "scout",
+			workflowKey: "issue-1695.scope-scout",
+			label: "scope-scout",
+			status: "running",
+		}], stagedLaneGraph(), {
+			version: 1,
+			coverage: "complete",
+			lanes: [{ key: "issue-1695", mode: "scout" }],
+		});
+
+		for (const [index, key] of stagedLaneKeys.entries()) {
+			const row = rows.find((candidate) => candidate.name.includes(key));
+			assert.ok(row, `stage ${key} should remain discoverable`);
+			assert.equal(row?.state, index === 0 ? "running" : "planned", `stage ${key} state`);
+		}
+		assert.equal(rows.filter((row) => row.state === "planned").length, stagedLaneKeys.length - 1);
+		assert.equal(rows.every((row) => row.preflight?.mode === "scout"), true);
+	});
+
 	it("preserves duplicate loaded rows when a declared lane key is reused", () => {
 		const rows = projectAsyncWorkflowRows([
 			{ agent: "worker", workflowKey: "writer", label: "First", status: "complete" },

package/dist/extensions/pi-subagents/test/unit/background-process-options.test.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { backgroundProcessOptions } from "../../src/runs/shared/background-process-options.ts";
+
+test("Windows background runners stay hidden without requesting a new console", () => {
+	assert.deepEqual(backgroundProcessOptions("win32"), {
+		detached: false,
+		windowsHide: true,
+	});
+});
+
+test("background runners remain detached on Unix", () => {
+	assert.deepEqual(backgroundProcessOptions("linux"), {
+		detached: true,
+		windowsHide: true,
+	});
+});

package/dist/extensions/pi-subagents/test/unit/external-cli-runner.test.ts

@@ -150,7 +150,7 @@ describe("external CLI runner", () => {
 					limits: { parserLineBytes: 64 },
 					parser: { parseLine() { return undefined; }, finish() { return { state: "completed" }; } },
 				}),
-				new Promise<never>((_, reject) => { settleTimer = setTimeout(() => reject(new Error("unterminated oversized line did not fail promptly")), 1_000); }),
+				new Promise<never>((_, reject) => { settleTimer = setTimeout(() => reject(new Error("unterminated oversized line did not fail promptly")), 10_000); }),
 			]);
 			assert.equal(unterminated.exitCode, 1);
 			assert.match(unterminated.error ?? "", /line exceeded/);

package/dist/extensions/pi-subagents/test/unit/fleet-status.test.ts

@@ -258,6 +258,46 @@ describe("below-editor subagent FleetView", () => {
 		}
 	});
 
+	it("repaints unchanged running entries but keeps queued-only ticks quiet", () => {
+		const refreshCount = (status: "running" | "queued"): number => {
+			const state = stateForTest();
+			state.asyncJobs.set(`run-${status}`, {
+				asyncId: `run-${status}`,
+				asyncDir: `/tmp/run-${status}`,
+				status,
+				mode: "single",
+				startedAt: 10,
+				updatedAt: 20,
+			});
+			let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
+			let renderRequests = 0;
+			const ctx = {
+				hasUI: true,
+				ui: {
+					setWidget(_key: string, content: typeof widgetFactory | undefined) { if (content) widgetFactory = content; },
+					onTerminalInput() { return () => {}; },
+					getEditorText() { return ""; },
+					requestRender() {},
+					notify() {},
+					theme,
+				},
+			} as unknown as ExtensionContext;
+			const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+			try {
+				fleet.setContext(ctx);
+				assert.ok(widgetFactory);
+				widgetFactory!({ requestRender() { renderRequests++; } }, theme);
+				fleet.refresh();
+				return renderRequests;
+			} finally {
+				fleet.dispose();
+			}
+		};
+
+		assert.equal(refreshCount("running"), 1);
+		assert.equal(refreshCount("queued"), 0);
+	});
+
 	it("counts project panes in compact status", () => {
 		const state = stateForTest();
 		const projectRoot = path.join("fixtures", "peer-project");
@@ -977,8 +1017,8 @@ describe("below-editor subagent FleetView", () => {
 			startedAt: 10,
 			updatedAt: 20,
 			steps: [
-				{ agent: "scout", workflowKey: "scan", phase: "Plan", label: "Find seams", status: "complete" as const, index: 0, tokens: { input: 10, output: 5, total: 15 } },
-				{ agent: "reviewer", workflowKey: "review", phase: "Review", status: "running" as const, index: 1, currentTool: "grep", tokens: { input: 20, output: 5, total: 25 } },
+				{ agent: "scout", workflowKey: "scan", phase: "Plan", label: "Find seams", status: "complete" as const, index: 0, context: "fresh" as const, model: "openai-codex/gpt-5.6-luna", thinking: "max", tokens: { input: 10, output: 5, total: 15 } },
+				{ agent: "reviewer", workflowKey: "review", phase: "Review", status: "running" as const, index: 1, context: "fork" as const, currentTool: "grep", tokens: { input: 20, output: 5, total: 25 } },
 				{ agent: "tester", workflowKey: "test", phase: "Verify", status: "pending" as const, index: 2 },
 			],
 		};
@@ -1007,8 +1047,8 @@ describe("below-editor subagent FleetView", () => {
 			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
 			const lines = component.render(140).join("\n");
 			assert.match(lines, /workflow · running/);
-			assert.match(lines, /Plan: scan · Find seams \(scout\) · complete/);
-			assert.match(lines, /Review: review \(reviewer\) · running · tool grep/);
+			assert.match(lines, /Plan: scan · Find seams \(scout\) \[fresh\] \(gpt-5\.6-luna · thinking max\) · complete/);
+			assert.match(lines, /Review: review \(reviewer\) \[fork\] · running · tool grep/);
 			assert.match(lines, /Verify: test \(tester\) · pending/);
 		} finally {
 			fleet.dispose();

package/dist/extensions/pi-subagents/test/unit/fork-cache-key.test.ts

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { ExtensionContext } from "@selesai/code";
+import { buildPiArgs, deriveForkPromptCacheKey, SUBAGENT_FORK_CACHE_KEY_ENV } from "../../src/runs/shared/pi-args.ts";
+import { rewriteForkCacheProviderRequest } from "../../src/runs/shared/subagent-prompt-runtime.ts";
+
+const originalForkCacheKey = process.env[SUBAGENT_FORK_CACHE_KEY_ENV];
+
+const baseLaunch = {
+	baseArgs: [] as string[],
+	task: "test",
+	sessionEnabled: false,
+	inheritProjectContext: false,
+	inheritGlobalContext: false,
+	inheritSkills: false,
+};
+
+function providerContext(api: string): Pick<ExtensionContext, "model"> {
+	return { model: { api } };
+}
+
+afterEach(() => {
+	if (originalForkCacheKey === undefined) delete process.env[SUBAGENT_FORK_CACHE_KEY_ENV];
+	else process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = originalForkCacheKey;
+});
+
+describe("fork prompt cache keys", () => {
+	it("derives a bounded sibling cache key from the parent session id", () => {
+		assert.equal(deriveForkPromptCacheKey(undefined), undefined);
+		assert.equal(deriveForkPromptCacheKey("   "), undefined);
+		const key = deriveForkPromptCacheKey("parent-session");
+		assert.ok(key);
+		assert.match(key, /^pi-fork:[0-9a-f]{56}$/);
+		assert.equal(Array.from(key).length, 64);
+		assert.equal(key.includes("parent-session"), false);
+
+		const longKey = deriveForkPromptCacheKey(`${"🙂".repeat(80)}-parent`);
+		assert.ok(longKey);
+		assert.equal(Array.from(longKey).length, 64);
+		assert.match(longKey, /^pi-fork:[0-9a-f]{56}$/);
+
+		const prefix = "/Users/example/.pi/agent/sessions/".repeat(3);
+		assert.notEqual(deriveForkPromptCacheKey(`${prefix}/one.jsonl`), deriveForkPromptCacheKey(`${prefix}/two.jsonl`));
+	});
+
+	it("passes the explicit fork cache key without inheriting ambient values", () => {
+		process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = "leaked-parent-value";
+
+		assert.equal(buildPiArgs(baseLaunch).env[SUBAGENT_FORK_CACHE_KEY_ENV], undefined);
+
+		const forkCacheKey = deriveForkPromptCacheKey("parent-session");
+		assert.equal(buildPiArgs({ ...baseLaunch, forkCacheKey }).env[SUBAGENT_FORK_CACHE_KEY_ENV], forkCacheKey);
+	});
+
+	it("rewrites only existing OpenAI-style string prompt cache keys", () => {
+		process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = "pi-fork:parent-session";
+		const payload = {
+			model: "test-model",
+			input: [{ role: "user", content: "hello" }],
+			prompt_cache_key: "child-session",
+		};
+
+		assert.deepEqual(
+			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload }, providerContext("openai-responses")),
+			{ ...payload, prompt_cache_key: "pi-fork:parent-session" },
+		);
+		assert.deepEqual(
+			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { ...payload, prompt_cache_key: "pi-fork:parent-session" } }, providerContext("openai-responses")),
+			{ ...payload, prompt_cache_key: "pi-fork:parent-session" },
+		);
+	});
+
+	it("does not add prompt cache keys or touch non-OpenAI payloads", () => {
+		process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = "pi-fork:parent-session";
+
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: "raw" }, providerContext("openai-responses")), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: [] }, providerContext("openai-responses")), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test" } }, providerContext("openai-responses")), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: undefined } }, providerContext("openai-responses")), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("anthropic-messages")), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("unknown-api")), undefined);
+	});
+
+	it("is a no-op when fork cache affinity is not configured", () => {
+		delete process.env[SUBAGENT_FORK_CACHE_KEY_ENV];
+		assert.equal(
+			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("openai-responses")),
+			undefined,
+		);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/host-command.test.ts

@@ -33,6 +33,7 @@ describe("workflow host commands", () => {
 		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 86_400_001 }), /integer from 1/);
 		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, output: path.resolve("outside.log") }), /relative path/);
 		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, provider: "bad\nprovider" }), /single-line/);
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, cwd: "/tmp" }), /does not accept per-step cwd.*workflow cwd.*outer subagent request.*cd \/path\/to\/worktree/);
 	});
 
 	it("runs without stdin and saves bounded command evidence", async () => {

package/dist/extensions/pi-subagents/test/unit/index-child-registration.test.ts

@@ -476,7 +476,6 @@ describe("subagent extension child mode", () => {
 				const lines = result.render(120);
 				if (lines.length !== 6) throw new Error("expected outer spacer, box rows, and three capped result rows: " + JSON.stringify(lines));
 				if (!lines[4].includes("rows hidden")) throw new Error("compact cap was not applied: " + JSON.stringify(lines));
-				if (!lines[3].includes(" ✓ Agent 1/3: scout")) throw new Error("zero spacing was not applied: " + JSON.stringify(lines));
 			`;
 			const env = parentToolEnv();
 			env.SELESAI_CODING_AGENT_DIR = agentDir;

package/dist/extensions/pi-subagents/test/unit/mcp-direct-tool-grant.test.ts

@@ -19,8 +19,8 @@ test("plans server grants from explicit metadata facts and preserves resource fi
 
 	assert.deepEqual(grant, {
 		selections: [
-			{ name: "browser_mcp_navigate", selector: "browser-mcp/navigate" },
-			{ name: "browser_mcp_get_console_logs", selector: "browser-mcp/get_console_logs" },
+			{ name: "browser-mcp_navigate", selector: "browser-mcp/navigate" },
+			{ name: "browser-mcp_get_console_logs", selector: "browser-mcp/get_console_logs" },
 		],
 		unresolvedSelectors: [],
 	});
@@ -95,7 +95,7 @@ test("enforces server includeTools before exclusions for tools and generated res
 
 test("matches include and exclude patterns against raw and alternate prefix names", () => {
 	for (const [toolPrefix, expectedName] of [
-		["server", "demo_mcp_search-records"],
+		["server", "demo-mcp_search-records"],
 		["short", "demo_search-records"],
 		["none", "search-records"],
 	] as const) {
@@ -117,6 +117,23 @@ test("matches include and exclude patterns against raw and alternate prefix name
 	}
 });
 
+test("matches adapter names for test-mcp/example in every prefix mode", () => {
+	for (const [toolPrefix, expectedName] of [
+		["server", "test-mcp_example"],
+		["short", "test_example"],
+		["none", "example"],
+	] as const) {
+		const grant = planMcpDirectToolGrant({
+			selectors: ["test-mcp"],
+			servers: { "test-mcp": {} },
+			metadata: { "test-mcp": { tools: [{ name: "example" }] } },
+			toolPrefix,
+		});
+
+		assert.deepEqual(grant.selections, [{ name: expectedName, selector: "test-mcp/example" }]);
+	}
+});
+
 test("supports adapter-compatible question-mark patterns", () => {
 	const grant = planMcpDirectToolGrant({
 		selectors: ["demo"],

package/dist/extensions/pi-subagents/test/unit/mutation-evidence.test.ts

@@ -147,4 +147,31 @@ describe("tracked mutation evidence", () => {
 		assert.match(summary.message, /changed tracked files: tracked\.txt/);
 		assert.match(summary.message, /active tool: edit/);
 	});
+
+	it("classifies dirty timeouts with a missing requested report as recovery-needed", () => {
+		const changedFiles = Array.from({ length: 25 }, (_, index) => `src/file-${String(index + 1).padStart(2, "0")}.ts`);
+		const summary = buildTimeoutRecoverySummary({
+			termination: "timed-out",
+			evidence: {
+				source: "tracked-files",
+				trackedOnly: true,
+				changedFiles,
+				attemptedMutation: true,
+			},
+			requiredOutputMissing: true,
+		});
+
+		assert.equal(summary.changedFiles.length, 20);
+		assert.deepEqual(summary.changedFiles.slice(0, 2), ["src/file-01.ts", "src/file-02.ts"]);
+		assert.equal(summary.truncated, true);
+		assert.match(summary.message, /\.\.\. \(5 more\)/);
+		assert.doesNotMatch(summary.message, /src\/file-25\.ts/);
+		assert.equal(summary.recoveryNeeded, true);
+		assert.equal(summary.reason, "timed-out-with-dirty-worktree");
+		assert.equal(summary.reportStatus, "missing");
+		assert.match(summary.message, /Recovery needed/i);
+		assert.match(summary.message, /requested report: missing/i);
+		assert.match(summary.message, /review (?:the )?diff and artifacts before resuming/i);
+		assert.match(summary.message, /dependent stages/i);
+	});
 });