@selesai/code 0.8.4 → 0.8.5

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

@@ -55,6 +55,7 @@ describe("below-editor subagent FleetView", () => {
 
 	it("renders main plus active children below the editor and bounds every line", () => {
 		const state = stateForTest();
+		state.activeAsyncCapacity = { used: 2, limit: 4 };
 		const now = Date.now();
 		for (let index = 0; index < 7; index++) {
 			state.foregroundControls.set(`run-${index}`, {
@@ -98,7 +99,7 @@ describe("below-editor subagent FleetView", () => {
 			const component = widgetFactory!(tui, theme);
 			const compactLines = component.render(80);
 			assert.equal(compactLines.length, 1);
-			assert.ok(compactLines[0]!.includes("7 active agents"));
+			assert.ok(compactLines[0]!.includes("7 active agents · Async runs 2/4"));
 			assert.ok(compactLines[0]!.includes("↓ 13.7k tokens"));
 			assert.ok(compactLines[0]!.includes("↓/← to inspect"));
 			assert.ok(visibleWidth(compactLines[0]!) <= 80);
@@ -122,6 +123,31 @@ describe("below-editor subagent FleetView", () => {
 		}
 	});
 
+	it("keeps occupied capacity visible without active child rows", () => {
+		const state = stateForTest();
+		state.activeAsyncCapacity = { used: 1, limit: 2 };
+		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
+		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);
+			assert.deepEqual(widgetFactory!({ requestRender() {} }, theme).render(80), ["  Async runs 1/2 · ↓ 0 tokens · ↓/← to inspect"]);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
 	it("keeps one queued agent visible in the compact summary", () => {
 		const state = stateForTest();
 		state.asyncJobs.set("run-worker", {
@@ -596,7 +622,7 @@ describe("below-editor subagent FleetView", () => {
 		assert.deepEqual(statusKeys, inspectorKeys);
 	});
 
-	it("uses tracked async task descriptions and per-child token totals", () => {
+	it("hides tracked async task descriptions and shows per-child token totals", () => {
 		const state = stateForTest();
 		state.asyncJobs.set("async-run", {
 			asyncId: "async-run",
@@ -630,9 +656,9 @@ describe("below-editor subagent FleetView", () => {
 			const component = widgetFactory!(tui, theme);
 			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
 			const lines = component.render(180);
-			assert.ok(lines.some((line) => line.includes("reviewer (gpt-5 · thinking medium)") && line.includes("Review only authentication")));
-			assert.ok(lines.some((line) => line.includes("worker") && line.includes("Implement only billing")));
-			assert.ok(lines.every((line) => !line.includes("Review the authentication changes")), "per-child descriptions should replace the run-level fallback when present");
+			assert.ok(lines.some((line) => line.includes("reviewer (gpt-5 · thinking medium)")));
+			assert.ok(lines.some((line) => line.includes("worker")));
+			assert.ok(lines.every((line) => !line.includes("Review only authentication") && !line.includes("Implement only billing") && !line.includes("Review the authentication changes")));
 			assert.ok(lines.some((line) => line.includes("↓ 4.2k tokens")));
 		} finally {
 			fleet.dispose();

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

@@ -7,8 +7,11 @@ import { visibleWidth, type MarkdownTheme } from "@earendil-works/pi-tui";
 import { collectFleetSnapshot, openSubagentFleet, SubagentFleetComponent } from "../../src/tui/fleet.ts";
 import { persistForegroundRunHistory, restoreForegroundRunHistory } from "../../src/runs/foreground/foreground-history.ts";
 import { FLEET_STATUS_WIDGET_KEY } from "../../src/tui/fleet-status.ts";
+import { registerLivePromptAudit, rewritePromptWithGuidance } from "../../src/runs/foreground/prompt-audit.ts";
 import { getArtifactPaths, getArtifactsDir, getProjectArtifactsDir } from "../../src/shared/artifacts.ts";
 import type { SubagentState } from "../../src/shared/types.ts";
+import { fauxAssistantMessage } from "@earendil-works/pi-ai/providers/faux";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 
 function stateForTest(): SubagentState {
 	return {
@@ -92,6 +95,35 @@ const markdownTheme: MarkdownTheme = {
 };
 
 describe("native subagent fleet", () => {
+	it("rewrites an authored prompt from guidance without persistence", async () => {
+		const calls: unknown[] = [];
+		const streamFn = (_model: never, context: unknown) => {
+			calls.push(context);
+			const stream = createAssistantMessageEventStream();
+			queueMicrotask(() => stream.push({ type: "done", reason: "stop", message: fauxAssistantMessage("Rewritten task", { stopReason: "stop" }) }));
+			return stream;
+		};
+		const model = { provider: "faux", id: "rewrite", api: "faux", input: ["text"], reasoning: false, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1000, maxTokens: 100 };
+		const ctx = {
+			model,
+			signal: undefined,
+			modelRegistry: {
+				async getApiKeyAndHeaders() { return { ok: true as const, apiKey: "test" }; },
+				getRegisteredProviderConfig() { return { api: "faux", streamSimple: streamFn }; },
+			},
+		} as never;
+		const rewritten = await rewritePromptWithGuidance({
+			ctx,
+			authoredTask: "Original task",
+			runtimeAdditions: "Runtime context",
+			finalEffectivePrompt: "Runtime context\n\nOriginal task",
+			guidance: "Make it narrower",
+		});
+		assert.equal(rewritten, "Rewritten task");
+		assert.match(JSON.stringify(calls), /Original task/);
+		assert.match(JSON.stringify(calls), /Make it narrower/);
+	});
+
 	it("collects current-session foreground and flattened async children", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-collect-"));
 		try {
@@ -136,6 +168,112 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("shows live prompt summaries and opens Prompt Audit with the authored prompt visible", async () => {
+		const sentinel = "PROMPT_AUDIT_SENTINEL_1021";
+		const secondSentinel = "PROMPT_AUDIT_SECOND_CHILD";
+		const state = stateForTest();
+		const control = {
+			runId: "prompt-run",
+			sessionId: "session-current",
+			mode: "parallel" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([
+				[0, { index: 0, agent: "worker", startedAt: 10, updatedAt: 20 }],
+				[1, { index: 1, agent: "reviewer", startedAt: 11, updatedAt: 21 }],
+			]),
+		};
+		state.foregroundControls.set(control.runId, control);
+		registerLivePromptAudit(control, 0, sentinel, `[Read from: context.md]\n\n${sentinel}\n\n---\nRuntime acceptance`, { rerun: { params: { agent: "worker", task: sentinel } } });
+		registerLivePromptAudit(control, 1, secondSentinel, secondSentinel);
+		assert.doesNotMatch(JSON.stringify(control), new RegExp(sentinel), "live prompts must not enter serializable Fleet state");
+		const clipboardWrites: string[] = [];
+		const redoCalls: Array<{ runId: string; index: number; guidance: string }> = [];
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{
+				refreshMs: 60_000,
+				markdownTheme,
+				copyText: (text) => { clipboardWrites.push(text); },
+				actions: {
+					async steer() { return { text: "unused" }; },
+					stop() { return { text: "unused" }; },
+					async redoPrompt(input) {
+						redoCalls.push(input);
+						return { text: "Prompt redo started redo-run." };
+					},
+				},
+			},
+		);
+		try {
+			const initialRender = component.render(100).join("\n");
+			assert.match(initialRender, new RegExp(`Task: ${sentinel}`));
+			assert.match(initialRender, /Prompt audit: 2 live · 3 views · p opens/);
+			component.handleInput("p");
+			assert.doesNotMatch(component.render(100).join("\n"), /Prompt text hidden|Enter reveal|r hide/);
+			assert.match(component.render(100).join("\n"), new RegExp(sentinel));
+			component.handleInput("2");
+			assert.match(component.render(100).join("\n"), /Read from: context\.md/);
+			component.handleInput("3");
+			assert.match(component.render(100).join("\n"), /Runtime acceptance/);
+			component.handleInput("c");
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual(clipboardWrites, [`[Read from: context.md]\n\n${sentinel}\n\n---\nRuntime acceptance`]);
+			assert.match(component.render(100).join("\n"), /Copied visible prompt view/);
+			component.handleInput("g");
+			for (const char of "make narrower") component.handleInput(char);
+			component.handleInput("\r");
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual(redoCalls, [{ runId: "prompt-run", index: 0, guidance: "make narrower", control }]);
+			assert.match(component.render(100).join("\n"), /Prompt redo started redo-run/);
+			component.handleInput("j");
+			assert.match(component.render(100).join("\n"), /Selected: 2\/2/);
+			assert.match(component.render(100).join("\n"), /Agent: reviewer/);
+			assert.match(component.render(100).join("\n"), new RegExp(secondSentinel));
+			component.handleInput("k");
+			component.handleInput("1");
+			assert.match(component.render(100).join("\n"), /Selected: 1\/2/);
+			assert.match(component.render(100).join("\n"), /Agent: worker/);
+			assert.match(component.render(100).join("\n"), new RegExp(sentinel));
+			component.handleInput("\x1b");
+			assert.match(component.render(100).join("\n"), /Prompt audit: 2 live · 3 views · p opens/);
+		} finally {
+			component.dispose();
+		}
+	});
+
+	it("rejects Prompt Audit for a child owned by another session", () => {
+		const state = stateForTest();
+		const control = {
+			runId: "other-run",
+			sessionId: "session-other",
+			mode: "single" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "worker", startedAt: 10, updatedAt: 20 }]]),
+		};
+		state.foregroundControls.set(control.runId, control);
+		registerLivePromptAudit(control, 0, "SECRET", "SECRET");
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 60_000, markdownTheme },
+		);
+		try {
+			component.handleInput("p");
+			const rendered = component.render(100).join("\n");
+			assert.match(rendered, /Prompt Audit is available only/);
+			assert.doesNotMatch(rendered, /SECRET/);
+		} finally {
+			component.dispose();
+		}
+	});
+
 	it("keeps tracked active workflows ahead of older failed terminal history", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-history-"));
 		try {
@@ -778,7 +916,7 @@ describe("native subagent fleet", () => {
 				assert.ok(lines.some((line) => line.includes("reviewer")));
 				assert.ok(lines.some((line) => line.includes("foreground · live")));
 				assert.ok(lines.some((line) => line.includes("live-model · thinking high")));
-				assert.ok(lines.some((line) => line.includes("Task") && line.includes("Implement the active task")));
+				assert.ok(lines.every((line) => !line.includes("Implement the active task") && !line.includes("Review the active task")));
 				assert.ok(lines.some((line) => line.includes("Conversation") && line.includes("assistant response")));
 				assert.ok(lines.some((line) => line.includes("Worker live result")));
 			} finally {

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

@@ -9,6 +9,7 @@ import {
 	settleForegroundSchedulingOwner,
 	updateForegroundChild,
 } from "../../src/runs/foreground/foreground-control.ts";
+import { getLivePromptAudit } from "../../src/runs/foreground/prompt-audit.ts";
 
 function progress(index: number, agent: string, tokens: number): AgentProgress {
 	return {
@@ -43,6 +44,8 @@ describe("foreground child control", () => {
 		beginForegroundChild(control, {
 			index: 0,
 			agent: "reviewer",
+			authoredTask: "review",
+			effectivePrompt: "review",
 			description: "Review correctness",
 			interrupt: () => { firstInterrupts++; return true; },
 			detach: () => { firstDetaches++; return true; },
@@ -50,11 +53,17 @@ describe("foreground child control", () => {
 		beginForegroundChild(control, {
 			index: 1,
 			agent: "reviewer",
+			authoredTask: "review next",
+			effectivePrompt: "review next",
 			description: "Review quality",
+			rerun: { params: { agent: "reviewer", task: "review next" } },
 			interrupt: () => { secondInterrupts++; return true; },
 		});
 
 		assert.equal(control.activeChildren?.size, 2);
+		assert.equal(getLivePromptAudit(control, 1)?.authoredTask, "review next");
+		assert.deepEqual(getLivePromptAudit(control, 1)?.rerun?.params, { agent: "reviewer", task: "review next" });
+		assert.doesNotMatch(JSON.stringify(control), /review next/);
 		assert.equal(control.currentIndex, 1);
 		updateForegroundChild(control, 0, progress(0, "reviewer", 120));
 		assert.equal(control.currentIndex, 0);
@@ -72,6 +81,7 @@ describe("foreground child control", () => {
 
 		updateForegroundChild(control, 1, progress(1, "reviewer", 240));
 		finishForegroundChild(control, 1);
+		assert.equal(getLivePromptAudit(control, 1), undefined);
 		assert.equal(control.currentIndex, 0);
 		assert.equal(control.tokens, 120);
 		assert.deepEqual([...control.activeChildren!.keys()], [0]);

package/dist/extensions/pi-subagents/test/unit/intercom-bridge.test.ts

@@ -52,7 +52,8 @@ describe("resolveIntercomSessionTarget", () => {
 	});
 
 	it("uses the current pi-intercom runtime id for unnamed fallback when present", () => {
-		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678", "session-stableabcdef"), "subagent-chat-stableab");
+		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678", "session-stableabcdef"), "subagent-chat-stableabcdef");
+		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678", "session-abcdefghijklmnopqrst"), "subagent-chat-abcdefghijklmnopqr");
 	});
 });
 

package/dist/extensions/pi-subagents/test/unit/llm-intent-arbiter.test.ts

@@ -0,0 +1,171 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	arbitrateCompletionGuardRescue,
+	createTaskMutationArbiter,
+	isCompletionGuardFailure,
+	maybeRescueCompletionGuardFailure,
+	type TaskMutationArbiter,
+} from "../../src/runs/shared/llm-intent-arbiter.ts";
+
+const GUARD_ERROR =
+	"Subagent completed without making edits for an implementation task.\nIt appears to have returned planning or scratchpad output instead of applying changes.";
+
+function fakeCtx(overrides: { models?: Array<{ provider?: string; id?: string; api?: string }> } = {}) {
+	const models = overrides.models ?? [{ provider: "test", id: "model-1", api: "test-api" }];
+	return {
+		model: models[0],
+		modelRegistry: {
+			getAvailable: () => models,
+			getRegisteredProviderConfig: () => undefined,
+		},
+	} as never;
+}
+
+function stubArbiter(verdict: "read-only" | "implementation" | "unavailable" | "throw"): TaskMutationArbiter {
+	return async () => {
+		if (verdict === "throw") throw new Error("boom");
+		return verdict;
+	};
+}
+
+describe("arbitrateCompletionGuardRescue", () => {
+	it("rescues only a confident read-only verdict", async () => {
+		const rescued = await arbitrateCompletionGuardRescue({
+			guardTriggered: true,
+			task: "t",
+			arbiter: stubArbiter("read-only"),
+		});
+		assert.deepEqual(rescued, { triggered: false, rescued: true });
+		for (const verdict of ["implementation", "unavailable"] as const) {
+			const kept = await arbitrateCompletionGuardRescue({
+				guardTriggered: true,
+				task: "t",
+				arbiter: stubArbiter(verdict),
+			});
+			assert.deepEqual(kept, { triggered: true, rescued: false }, verdict);
+		}
+	});
+
+	it("keeps the guard verdict without an arbiter or on arbiter failure", async () => {
+		assert.deepEqual(
+			await arbitrateCompletionGuardRescue({ guardTriggered: true, task: "t" }),
+			{ triggered: true, rescued: false },
+		);
+		assert.deepEqual(
+			await arbitrateCompletionGuardRescue({ guardTriggered: true, task: "t", arbiter: stubArbiter("throw") }),
+			{ triggered: true, rescued: false },
+		);
+		assert.deepEqual(
+			await arbitrateCompletionGuardRescue({ guardTriggered: false, task: "t", arbiter: stubArbiter("read-only") }),
+			{ triggered: false, rescued: false },
+		);
+	});
+});
+
+describe("isCompletionGuardFailure", () => {
+	it("recognizes the guard error prefix", () => {
+		assert.equal(isCompletionGuardFailure({ error: GUARD_ERROR }), true);
+		assert.equal(isCompletionGuardFailure({ error: "Some other failure." }), false);
+		assert.equal(isCompletionGuardFailure({}), false);
+	});
+});
+
+describe("maybeRescueCompletionGuardFailure", () => {
+	it("keeps the failure without an arbiter", async () => {
+		const result = { exitCode: 1, error: GUARD_ERROR };
+		const rescued = await maybeRescueCompletionGuardFailure(result, "task", undefined);
+		assert.equal(rescued, false);
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.error, GUARD_ERROR);
+	});
+
+	it("rescues only a confident read-only verdict", async () => {
+		for (const verdict of ["implementation", "unavailable"] as const) {
+			const result = { exitCode: 1, error: GUARD_ERROR };
+			const rescued = await maybeRescueCompletionGuardFailure(result, "task", stubArbiter(verdict));
+			assert.equal(rescued, false, verdict);
+			assert.equal(result.exitCode, 1);
+			assert.equal(result.error, GUARD_ERROR);
+		}
+		const result = { exitCode: 1, error: GUARD_ERROR };
+		const rescued = await maybeRescueCompletionGuardFailure(result, "task", stubArbiter("read-only"));
+		assert.equal(rescued, true);
+		assert.equal(result.exitCode, 0);
+		assert.equal(result.error, undefined);
+	});
+
+	it("fails closed when the arbiter throws", async () => {
+		const result = { exitCode: 1, error: GUARD_ERROR };
+		const rescued = await maybeRescueCompletionGuardFailure(result, "task", stubArbiter("throw"));
+		assert.equal(rescued, false);
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.error, GUARD_ERROR);
+	});
+
+	it("does not touch unrelated failures", async () => {
+		const result = { exitCode: 1, error: "Something else broke." };
+		const rescued = await maybeRescueCompletionGuardFailure(result, "task", stubArbiter("read-only"));
+		assert.equal(rescued, false);
+		assert.equal(result.exitCode, 1);
+	});
+});
+
+describe("createTaskMutationArbiter", () => {
+	it("is disabled by the env opt-out", () => {
+		const previous = process.env.SELESAI_SUBAGENTS_LLM_INTENT_ARBITER;
+		process.env.SELESAI_SUBAGENTS_LLM_INTENT_ARBITER = "0";
+		try {
+			assert.equal(createTaskMutationArbiter(fakeCtx()), undefined);
+		} finally {
+			if (previous === undefined) delete process.env.SELESAI_SUBAGENTS_LLM_INTENT_ARBITER;
+			else process.env.SELESAI_SUBAGENTS_LLM_INTENT_ARBITER = previous;
+		}
+	});
+
+	it("returns undefined when no model can be resolved", () => {
+		assert.equal(createTaskMutationArbiter(fakeCtx({ models: [] })), undefined);
+	});
+
+	it("returns a working arbiter bound to the host model", async () => {
+		const arbiter = createTaskMutationArbiter(fakeCtx(), {
+			streamFn: async () => {
+				throw new Error("not reached in this seam test");
+			},
+		});
+		assert.notEqual(arbiter, undefined);
+		// Without a scripted stream the underlying Agent call cannot succeed;
+		// the arbiter must degrade to "unavailable" rather than throw.
+		const verdict = await arbiter!("task");
+		assert.equal(verdict, "unavailable");
+	});
+
+	it("memoizes verdicts per task", async () => {
+		let streamCalls = 0;
+		const arbiter = createTaskMutationArbiter(fakeCtx(), {
+			streamFn: async () => {
+				streamCalls += 1;
+				throw new Error("fail");
+			},
+		})!;
+		const v1 = await arbiter("t");
+		const v2 = await arbiter("t");
+		assert.equal(v1, "unavailable");
+		assert.equal(v2, "unavailable");
+		assert.equal(streamCalls, 1);
+	});
+
+	it("uses the full task as the cache key", async () => {
+		let streamCalls = 0;
+		const arbiter = createTaskMutationArbiter(fakeCtx(), {
+			streamFn: async () => {
+				streamCalls += 1;
+				throw new Error("fail");
+			},
+		})!;
+		const prefix = "x".repeat(180);
+		await arbiter(`${prefix}A`);
+		await arbiter(`${prefix}B`);
+		assert.equal(streamCalls, 2);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/mission-lifecycle.test.ts

@@ -11,6 +11,7 @@ import {
 	syncMissionFromAsyncCompletion,
 } from "../../src/missions/lifecycle.ts";
 import { readMission } from "../../src/missions/store.ts";
+import { PROMPT_REDACTED } from "../../src/shared/utils.ts";
 
 function projectFixture() {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-mission-lifecycle-"));
@@ -52,7 +53,8 @@ describe("mission launch lifecycle", () => {
 			});
 			assert.ok(binding);
 			const mission = readMission(binding.location, binding.missionId);
-			assert.equal(mission.objective, "Map the auth flow");
+			assert.equal(mission.objective, PROMPT_REDACTED);
+			assert.equal(mission.title, PROMPT_REDACTED);
 			assert.equal(mission.status, "active");
 			const result = attachMissionToLaunchResult({
 				binding,
@@ -80,7 +82,7 @@ describe("mission launch lifecycle", () => {
 				config: test.missionConfig,
 			});
 			assert.ok(parallelOnly);
-			assert.equal(readMission(parallelOnly.location, parallelOnly.missionId).objective, "Review parallel work");
+			assert.equal(readMission(parallelOnly.location, parallelOnly.missionId).objective, PROMPT_REDACTED);
 
 			assert.throws(() => prepareMissionLaunch({
 				params: { missionId: "" },
@@ -107,7 +109,7 @@ describe("mission launch lifecycle", () => {
 				config: { ...test.missionConfig, enabled: false },
 			});
 			assert.ok(explicit);
-			assert.equal(readMission(explicit.location, explicit.missionId).objective, "Tiny one-off");
+			assert.equal(readMission(explicit.location, explicit.missionId).objective, "Explicit mission");
 
 			const summaryAlias = prepareMissionLaunch({
 				params: { mission: { summary: "Review active backlog", labels: ["review"] }, task: "Review the current diff" },
@@ -117,7 +119,31 @@ describe("mission launch lifecycle", () => {
 			assert.ok(summaryAlias);
 			assert.deepEqual(readMission(summaryAlias.location, summaryAlias.missionId).labels, ["review"]);
 			assert.equal(readMission(summaryAlias.location, summaryAlias.missionId).title, "Review active backlog");
-			assert.equal(readMission(summaryAlias.location, summaryAlias.missionId).objective, "Review the current diff");
+			assert.equal(readMission(summaryAlias.location, summaryAlias.missionId).objective, "Review active backlog");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("explains when an explicit mission belongs to another worktree", () => {
+		const test = projectFixture();
+		const worktreeRoot = path.join(test.root, "worktree");
+		fs.mkdirSync(worktreeRoot, { recursive: true });
+		try {
+			const binding = prepareMissionLaunch({
+				params: { mission: { title: "Root mission" }, task: "Prepare root work" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			assert.ok(binding);
+			const missionDir = path.join(worktreeRoot, ".pi-subagents", "missions");
+			assert.throws(() => prepareMissionLaunch({
+				params: { missionId: binding.missionId, task: "Prepare worktree work" },
+				projectRoot: worktreeRoot,
+				config: test.missionConfig,
+			}), {
+				message: `Mission '${binding.missionId}' was not found in mission directory '${missionDir}' for project root '${worktreeRoot}'. If it was created in another worktree, run the request from that worktree.`,
+			});
 		} finally {
 			fs.rmSync(test.root, { recursive: true, force: true });
 		}

package/dist/extensions/pi-subagents/test/unit/model-fallback.test.ts

@@ -2,8 +2,10 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
 	buildModelCandidates,
+	formatModelRetryNote,
 	fuzzyResolveModel,
 	isRetryableModelFailure,
+	MODEL_RETRY_DELAYS_MS,
 	normalizeModelSegment,
 	resolveEffectiveSubagentModel,
 	resolveModelCandidate,
@@ -74,6 +76,18 @@ describe("model fallback helpers", () => {
 		assert.equal(isRetryableModelFailure("model load failed"), true);
 		assert.equal(isRetryableModelFailure("Stream ended without finish_reason"), true);
 		assert.equal(isRetryableModelFailure("Request timed out."), true);
+		assert.equal(isRetryableModelFailure("503 Service Unavailable"), true);
+		assert.equal(isRetryableModelFailure("No body returned for response"), true);
+		assert.equal(isRetryableModelFailure("no response body"), true);
+		assert.equal(isRetryableModelFailure("ECONNRESET"), true);
+	});
+
+	it("ships a bounded same-model retry schedule and note", () => {
+		assert.deepEqual(MODEL_RETRY_DELAYS_MS, [500, 1500, 4000]);
+		assert.match(
+			formatModelRetryNote({ model: "anthropic/claude-sonnet-4", attempt: 1, maxAttempts: 4, delayMs: 500 }),
+			/\[model-retry\] anthropic\/claude-sonnet-4.*attempt 1\/4.*500ms/,
+		);
 	});
 
 	it("does not treat ordinary task/tool failures as retryable model failures", () => {

package/dist/extensions/pi-subagents/test/unit/owned-process-tree.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import { createOwnedProcessTreeController } from "../../src/runs/background/owned-process-tree.ts";
+
+function processIsActive(pid: number): boolean {
+	const result = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf-8" });
+	return result.status === 0 && Boolean(result.stdout.trim()) && !result.stdout.trim().startsWith("Z");
+}
+
+test("owned process tree fails closed when process-group ownership is unsupported", { skip: process.platform !== "win32" }, async () => {
+	const proof = await createOwnedProcessTreeController(999_999).terminate();
+	assert.deepEqual(proof, { state: "unknown", reason: "unsupported-platform" });
+});
+
+test("owned process tree kills descendants and verifies a TERM-resistant POSIX group", { skip: process.platform === "win32" }, async () => {
+	const writer = spawn(process.execPath, ["-e", `
+		const { spawn } = require("node:child_process");
+		const child = spawn(process.execPath, ["-e", "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000)"], { stdio: "ignore" });
+		process.on("SIGTERM", () => {});
+		process.stdout.write(String(child.pid) + "\\n");
+		setInterval(() => {}, 1000);
+	`], { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+	assert.ok(writer.pid);
+	const grandchildPid = await new Promise<number>((resolve, reject) => {
+		writer.once("error", reject);
+		writer.stdout!.once("data", (chunk) => resolve(Number(String(chunk).trim())));
+	});
+	const proof = await createOwnedProcessTreeController(writer.pid, { termGraceMs: 50, killVerifyMs: 1000 }).terminate();
+	assert.equal(proof.state, "observed", JSON.stringify(proof));
+	assert.equal(processIsActive(writer.pid), false);
+	assert.equal(processIsActive(grandchildPid), false);
+
+	const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-tree-ps-"));
+	const realPs = spawnSync("sh", ["-c", "command -v ps"], { encoding: "utf-8" }).stdout.trim();
+	const marker = path.join(fixtureDir, "failed-once");
+	const originalPath = process.env.PATH;
+	try {
+		fs.writeFileSync(path.join(fixtureDir, "ps"), `#!/bin/sh\nif [ ! -e "$PI_TEST_PS_MARKER" ]; then\n  : > "$PI_TEST_PS_MARKER"\n  exit 1\nfi\nexec "$PI_TEST_REAL_PS" "$@"\n`);
+		fs.chmodSync(path.join(fixtureDir, "ps"), 0o755);
+		process.env.PATH = `${fixtureDir}${path.delimiter}${originalPath ?? ""}`;
+		process.env.PI_TEST_PS_MARKER = marker;
+		process.env.PI_TEST_REAL_PS = realPs;
+		const enumerationFailureWriter = spawn(process.execPath, ["-e", `
+			process.on("SIGTERM", () => {});
+			process.stdout.write("ready\\n");
+			setInterval(() => {}, 1000);
+		`], { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+		assert.ok(enumerationFailureWriter.pid);
+		await new Promise<void>((resolve, reject) => {
+			enumerationFailureWriter.once("error", reject);
+			enumerationFailureWriter.stdout!.once("data", () => resolve());
+		});
+		const termGraceMs = 50;
+		const startedAt = Date.now();
+		const failedProof = await createOwnedProcessTreeController(enumerationFailureWriter.pid, { termGraceMs, killVerifyMs: 1000 }).terminate();
+		assert.ok(Date.now() - startedAt >= termGraceMs, "enumeration failure still waits through the TERM grace before SIGKILL");
+		assert.equal(failedProof.state, "observed", JSON.stringify(failedProof));
+		assert.equal(processIsActive(enumerationFailureWriter.pid), false);
+	} finally {
+		process.env.PATH = originalPath;
+		delete process.env.PI_TEST_PS_MARKER;
+		delete process.env.PI_TEST_REAL_PS;
+		fs.rmSync(fixtureDir, { recursive: true, force: true });
+	}
+});