@selesai/code 0.8.4 → 0.8.6

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/handoff-adoption.test.ts

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { describe, it } from "node:test";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+describe("handoff workflow carry-over", () => {
+	it("adopts the previous session's active async workflows and tells the agent", () => {
+		const script = String.raw`
+			import os from "node:os";
+			import path from "node:path";
+			import fs from "node:fs";
+			import { DIRS } from "./src/shared/types.ts";
+			import registerSubagentExtension from "./index.ts";
+			const handlers = new Map();
+			const events = { listeners: new Map(), on(name, handler) { this.listeners.set(name, handler); return () => this.listeners.delete(name); }, emit(name, payload) { this.listeners.get(name)?.(payload); } };
+			const sent = [];
+			const widgets = [];
+			const pi = new Proxy({
+				events,
+				on(name, handler) { handlers.set(name, handler); },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage(message, options) { sent.push({ message, options }); }, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+
+			const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-handoff-"));
+			const oldSession = path.join(tmp, "old-session.jsonl");
+			const newSession = path.join(tmp, "new-session.jsonl");
+			fs.writeFileSync(oldSession, JSON.stringify({ type: "session", version: 1, id: "old-session", timestamp: new Date().toISOString(), cwd: process.cwd() }) + "\n");
+			fs.writeFileSync(newSession, JSON.stringify({ type: "session", version: 1, id: "new-session", timestamp: new Date().toISOString(), cwd: process.cwd(), parentSession: oldSession }) + "\n");
+
+			// One active async workflow owned by the previous session.
+			const runId = "adopted-workflow-run";
+			const asyncDir = path.join(DIRS.async, runId);
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId,
+				state: "running",
+				sessionId: oldSession,
+				mode: "workflow",
+				workflowKey: "task",
+				agent: "builder",
+				startedAt: Date.now(),
+				steps: [{ agent: "builder", status: "running", phase: "build-1", description: "Implement the carry-over plan" }],
+			}));
+			fs.mkdirSync(path.join(DIRS.async, ".active-runs"), { recursive: true });
+			fs.writeFileSync(path.join(DIRS.async, ".active-runs", runId), "");
+
+			// A result file for an old-session run written during the switch window.
+			const resultRunId = "adopted-completed-run";
+			const resultPath = path.join(DIRS.results, resultRunId + ".json");
+			fs.mkdirSync(DIRS.results, { recursive: true });
+			fs.writeFileSync(resultPath, JSON.stringify({ runId: resultRunId, sessionId: oldSession, agent: "explorer", summary: "done", success: true }));
+
+			const ctx = { cwd: process.cwd(), hasUI: true, ui: { setWidget(key, value) { widgets.push([key, value]); }, requestRender() {}, onTerminalInput() { return () => {}; }, getEditorText() { return ""; }, notify() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager: { getSessionId() { return "new-session"; }, getSessionFile() { return newSession; }, getHeader() { return { parentSession: oldSession }; }, getEntries() { return []; } }, modelRegistry: { getAvailable() { return []; } } };
+
+			registerSubagentExtension(pi);
+			handlers.get("session_start")({ reason: "new", previousSessionFile: oldSession }, ctx);
+			sent.length = 0;
+
+			// No handoff notice until a turn settles.
+			if (sent.length !== 0) throw new Error("handoff notice sent before the first settled turn");
+
+			handlers.get("agent_settled")();
+			const handoff = sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume");
+			if (handoff.length !== 1) throw new Error(JSON.stringify(sent.map((entry) => entry.message)));
+			if (handoff[0].options?.triggerTurn !== true) throw new Error("handoff notice did not trigger a turn");
+			if (typeof handoff[0].message?.content !== "string" || !handoff[0].message.content.includes(runId) || !handoff[0].message.content.includes("carried over")) {
+				throw new Error("handoff notice lacks the adopted workflow: " + JSON.stringify(handoff[0].message));
+			}
+
+			// Only once per adoption.
+			handlers.get("agent_settled")();
+			if (sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume").length !== 1) throw new Error("handoff notice repeated");
+
+			// Compaction resume message now lists the live workflows.
+			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
+			handlers.get("session_compact")({ reason: "threshold" });
+			const compaction = sent.filter((entry) => entry.message?.customType === "subagent-compaction-resume");
+			if (compaction.length !== 1) throw new Error("compaction resume missing: " + JSON.stringify(sent.map((entry) => entry.message?.customType)));
+			if (typeof compaction[0].message?.content !== "string" || !compaction[0].message.content.includes(runId)) {
+				throw new Error("compaction resume lacks the workflow manifest: " + JSON.stringify(compaction[0].message));
+			}
+
+			// Adopted old-session result gets delivered and cleaned up (batched
+			// notification debounces, so poll with a generous bound).
+			let delivered = false;
+			for (let attempt = 0; attempt < 40 && !delivered; attempt++) {
+				await new Promise((resolve) => setTimeout(resolve, 250));
+				delivered = !fs.existsSync(resultPath);
+			}
+			if (!delivered) throw new Error("adopted result file was not delivered");
+
+			await handlers.get("session_shutdown")();
+		`;
+		const env = { ...process.env };
+		delete env.SELESAI_SUBAGENT_CHILD;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		assert.ok(true);
+	});
+});

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

@@ -103,6 +103,28 @@ describe("subagent extension child mode", () => {
 		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
 	});
 
+	it("declares packaged prompts through resources_discover", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./index.ts";
+			import * as fs from "node:fs";
+			const handlers = new Map();
+			const fakePi = new Proxy({
+				events: { on() { return () => {}; }, emit() {} },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				on(event, handler) { handlers.set(event, handler); },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			registerSubagentExtension(fakePi);
+			const handler = handlers.get("resources_discover");
+			if (!handler) throw new Error("resources_discover handler not registered");
+			const result = handler({ type: "resources_discover", cwd: process.cwd(), reason: "startup" });
+			if (!result || !Array.isArray(result.promptPaths) || result.promptPaths.length !== 1) throw new Error("expected one promptPath, got " + JSON.stringify(result));
+			const promptDir = result.promptPaths[0];
+			if (!fs.existsSync(promptDir + "/review-loop.md")) throw new Error("review-loop.md not found under " + promptDir);
+			if (!fs.existsSync(promptDir + "/parallel-review.md")) throw new Error("parallel-review.md not found under " + promptDir);
+		`;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
+	});
+
 	it("shows omitted workflow async as background even when asyncByDefault is false", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-workflow-manifest-config-"));
 		try {

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 });
 		}