@selesai/code 0.8.3 → 0.8.5

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

@@ -10,11 +10,12 @@ import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/sh
 
 const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 
-function parentToolEnv(): NodeJS.ProcessEnv {
+function parentToolEnv(agentDir?: string): NodeJS.ProcessEnv {
 	const env = { ...process.env };
 	delete env[SUBAGENT_CHILD_ENV];
 	delete env[SUBAGENT_FANOUT_CHILD_ENV];
 	delete env[WAIT_TOOL_ENABLED_ENV];
+	if (agentDir) env.SELESAI_CODING_AGENT_DIR = agentDir;
 	return env;
 }
 
@@ -71,7 +72,7 @@ describe("subagent extension child mode", () => {
 		);
 	});
 
-	it("renders only the public single and workflow execution modes", () => {
+	it("renders only the public workflow execution mode", () => {
 		const script = String.raw`
 			import registerSubagentExtension from "./index.ts";
 			const events = { on() { return () => {}; }, emit() {} };
@@ -84,20 +85,16 @@ describe("subagent extension child mode", () => {
 			registerSubagentExtension(fakePi);
 			if (!registeredTool) throw new Error("tool not registered");
 			const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
-			const single = registeredTool.renderCall({ agent: "builder", async: true }, theme).text;
 			const workflow = registeredTool.renderCall({
-				workflowScript: "const scan = await runs.run('scan', {agent:'builder'}); return runs.all([{key:'correctness',agent:'commentator'},{key:'tests',agent:'commentator'}]);",
+				workflowScript: "const scan = await runs.run('scan', {agent:'worker'}); return runs.all([{key:'correctness',agent:'reviewer'},{key:'tests',agent:'reviewer'}]);",
 			}, theme).text;
-			const foregroundWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run('publish', {agent:'builder'});", async: false }, theme).text;
-			const clarifiedWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run('clarify', {agent:'builder'});", async: true, clarify: true }, theme).text;
-			const templateWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run(\`template\`, {agent:'builder'});", async: false }, theme).text;
-			const commentedWorkflow = registeredTool.renderCall({ workflowScript: "// runs.run('ignored', {agent:'builder'})\nconst note = \"key: 'also-ignored'\"; return runs.run('real', {agent:'builder'});" }, theme).text;
-			const dynamicKeyWorkflow = registeredTool.renderCall({ workflowScript: "return runs.all([{key: 'review-' + item, agent: 'commentator'}]);" }, theme).text;
-			const ordinaryKeyWorkflow = registeredTool.renderCall({ workflowScript: "const config = {key: 'secret'}; return runs.all([{agent: 'commentator', config: {key: 'nested'}, key: 'review'}]);" }, theme).text;
-			if (!single.includes("builder [async]")) throw new Error("expected async single badge, got " + single);
+			const foregroundWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run('publish', {agent:'worker'});", async: false }, theme).text;
+			const templateWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run(\`template\`, {agent:'worker'});", async: false }, theme).text;
+			const commentedWorkflow = registeredTool.renderCall({ workflowScript: "// runs.run('ignored', {agent:'worker'})\nconst note = \"key: 'also-ignored'\"; return runs.run('real', {agent:'worker'});" }, theme).text;
+			const dynamicKeyWorkflow = registeredTool.renderCall({ workflowScript: "return runs.all([{key: 'review-' + item, agent: 'reviewer'}]);" }, theme).text;
+			const ordinaryKeyWorkflow = registeredTool.renderCall({ workflowScript: "const config = {key: 'secret'}; return runs.all([{agent: 'reviewer', config: {key: 'nested'}, key: 'review'}]);" }, theme).text;
 			if (!workflow.includes("background · 3 lanes: scan, correctness, tests")) throw new Error("expected workflow manifest, got " + workflow);
 			if (!foregroundWorkflow.includes("foreground · 1 lane: publish")) throw new Error("expected foreground workflow manifest, got " + foregroundWorkflow);
-			if (!clarifiedWorkflow.includes("rejected: clarify UI unsupported")) throw new Error("expected clarified workflow rejection, got " + clarifiedWorkflow);
 			if (!templateWorkflow.includes("foreground · 1 lane: template")) throw new Error("expected static template lane, got " + templateWorkflow);
 			if (!commentedWorkflow.includes("background · 1 lane: real")) throw new Error("expected lexical lane filtering, got " + commentedWorkflow);
 			if (!dynamicKeyWorkflow.includes("workflow script · background")) throw new Error("expected dynamic key fallback, got " + dynamicKeyWorkflow);
@@ -123,10 +120,10 @@ describe("subagent extension child mode", () => {
 				registerSubagentExtension(fakePi);
 				const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
 				const result = registeredTool.renderCall({
-					workflowScript: "return runs.run('scan' /* stable lane */, {agent:'builder'});",
+					workflowScript: "return runs.run('scan' /* stable lane */, {agent:'worker'});",
 				}, theme).text;
 				const explicitForeground = registeredTool.renderCall({
-					workflowScript: "return runs.run('publish', {agent:'builder'});",
+					workflowScript: "return runs.run('publish', {agent:'worker'});",
 					async: false,
 				}, theme).text;
 				if (!result.includes("background · 1 lane: scan")) throw new Error("expected workflow executor background manifest, got " + result);
@@ -165,9 +162,41 @@ describe("subagent extension child mode", () => {
 			if (!error.includes("Retry the subagent call.")) throw new Error("error retry guidance was hidden: " + error);
 			if (error.includes("3 lines")) throw new Error("error was collapsed: " + error);
 
-			const success = render("Managed agents:\n- commentator\n- writer", false);
+			const success = render("Managed agents:\n- reviewer\n- writer", false);
 			if (!success.includes("Managed agents: · 3 lines")) throw new Error("success summary was not collapsed: " + success);
-			if (success.includes("- commentator") || success.includes("- writer")) throw new Error("success details were not collapsed: " + success);
+			if (success.includes("- reviewer") || success.includes("- writer")) throw new Error("success details were not collapsed: " + success);
+		`;
+
+		execFileSync(
+			process.execPath,
+			[
+				"--experimental-strip-types",
+				"--import",
+				"./test/support/register-loader.mjs",
+				"--input-type=module",
+				"--eval",
+				script,
+			],
+			{ cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" },
+		);
+	});
+
+	it("rejects blank action at the public executor boundary", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./index.ts";
+			const events = { on() { return () => {}; }, emit() {} };
+			let registeredTool;
+			const fakePi = new Proxy({
+				events,
+				registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+				registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			registerSubagentExtension(fakePi);
+			if (!registeredTool) throw new Error("tool not registered");
+			const result = await registeredTool.execute("blank-action", { action: "", agent: "reviewer" }, new AbortController().signal, undefined, { cwd: process.cwd(), hasUI: false });
+			if (!result.isError) throw new Error("blank action should be rejected");
+			const text = result.content?.[0]?.text ?? "";
+			if (!text.includes("action must be a non-empty")) throw new Error("unexpected blank action error: " + text);
 		`;
 
 		execFileSync(
@@ -208,9 +237,9 @@ describe("subagent extension child mode", () => {
 				details: {
 					mode: "single",
 					results: [{
-						agent: "builder", task: "quiet", exitCode: 0, messages: [],
+						agent: "worker", task: "quiet", exitCode: 0, messages: [],
 						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-						progress: { status: "running", index: 0, agent: "builder", toolCount: 0, tokens: 0, durationMs: 0 },
+						progress: { status: "running", index: 0, agent: "worker", toolCount: 0, tokens: 0, durationMs: 0 },
 					}],
 				},
 			}, { expanded: false }, { fg(_name, text) { return text; }, bold(text) { return text; } }, context);
@@ -255,15 +284,15 @@ describe("subagent extension child mode", () => {
 				if (!registeredTool) throw new Error("tool not registered");
 				const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
 				const base = {
-					agent: "explorer", task: "quiet", messages: [],
+					agent: "delegate", task: "quiet", messages: [],
 					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
 				};
 				const running = registeredTool.renderResult({
 					content: [{ type: "text", text: "partial output that must not appear" }],
-					details: { mode: "single", results: [{ ...base, exitCode: 0, progress: { status: "running", index: 0, agent: "explorer", toolCount: 2, tokens: 300, durationMs: 20_000 } }] },
+					details: { mode: "single", results: [{ ...base, exitCode: 0, progress: { status: "running", index: 0, agent: "delegate", toolCount: 2, tokens: 300, durationMs: 20_000 } }] },
 				}, { expanded: false, isPartial: true }, theme, { state: {} }).render(120);
 				const asyncSingle = registeredTool.renderResult({
-					content: [{ type: "text", text: "Async: explorer [single-run]" }],
+					content: [{ type: "text", text: "Async: delegate [single-run]" }],
 					details: { mode: "single", runId: "single-run", asyncId: "single-run", asyncDir: "/tmp/single-run", results: [] },
 				}, { expanded: false }, theme, { state: {} }).render(120);
 				const asyncChain = registeredTool.renderResult({
@@ -298,13 +327,13 @@ describe("subagent extension child mode", () => {
 					content: [{ type: "text", text: "Agent configuration is invalid." }],
 					details: { mode: "management", results: [] },
 				}, { expanded: false, isPartial: false }, theme, { isError: true, state: {} }).render(120);
-				if (running.length !== 1 || running[0] !== "● explorer · running") throw new Error("unexpected running summary: " + JSON.stringify(running));
+				if (running.length !== 1 || running[0] !== "● delegate · running") throw new Error("unexpected running summary: " + JSON.stringify(running));
 				if (asyncSingle.length !== 1 || asyncSingle[0] !== "● single · running") throw new Error("unexpected async single summary: " + JSON.stringify(asyncSingle));
 				if (asyncChain.length !== 1 || asyncChain[0] !== "● chain · running") throw new Error("unexpected async chain summary: " + JSON.stringify(asyncChain));
-				if (completed.length !== 1 || completed[0] !== "✓ explorer · completed") throw new Error("unexpected completed summary: " + JSON.stringify(completed));
-				if (stopped.length !== 1 || stopped[0] !== "■ explorer · stopped") throw new Error("unexpected stopped summary: " + JSON.stringify(stopped));
-				if (paused.length !== 1 || paused[0] !== "■ explorer · paused") throw new Error("unexpected paused summary: " + JSON.stringify(paused));
-				if (failed.length !== 1 || failed[0] !== "✗ explorer · failed") throw new Error("unexpected failed summary: " + JSON.stringify(failed));
+				if (completed.length !== 1 || completed[0] !== "✓ delegate · completed") throw new Error("unexpected completed summary: " + JSON.stringify(completed));
+				if (stopped.length !== 1 || stopped[0] !== "■ delegate · stopped") throw new Error("unexpected stopped summary: " + JSON.stringify(stopped));
+				if (paused.length !== 1 || paused[0] !== "■ delegate · paused") throw new Error("unexpected paused summary: " + JSON.stringify(paused));
+				if (failed.length !== 1 || failed[0] !== "✗ delegate · failed") throw new Error("unexpected failed summary: " + JSON.stringify(failed));
 				if (failedWithPaused.length !== 1 || failedWithPaused[0] !== "✗ parallel · failed") throw new Error("unexpected paused aggregate summary: " + JSON.stringify(failedWithPaused));
 				if (failedWithStopped.length !== 1 || failedWithStopped[0] !== "✗ parallel · failed") throw new Error("unexpected stopped aggregate summary: " + JSON.stringify(failedWithStopped));
 				if (contextError.length !== 1 || contextError[0] !== "✗ management · failed") throw new Error("unexpected context error summary: " + JSON.stringify(contextError));
@@ -400,7 +429,7 @@ describe("subagent extension child mode", () => {
 				registerSubagentExtension(fakePi);
 				handlers.get("session_start")({}, ctx);
 				widgets.length = 0;
-				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "single", agent: "builder", asyncDir: "/tmp/widget-run" });
+				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "single", agent: "worker", asyncDir: "/tmp/widget-run" });
 				handlers.get("tool_result")({ toolName: "subagent" }, ctx);
 				const asyncWidgets = widgets.filter((entry) => entry.key === "subagent-async");
 				if (asyncWidgets.length < 2 || asyncWidgets.some((entry) => entry.value !== undefined)) throw new Error("async widget rendered despite disabled config: " + JSON.stringify(asyncWidgets));
@@ -441,7 +470,7 @@ describe("subagent extension child mode", () => {
 				registerSubagentExtension(fakePi);
 				handlers.get("session_start")({}, ctx);
 				widgets.length = 0;
-				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "workflow", agent: "builder", asyncDir: "/tmp/widget-run" });
+				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "workflow", agent: "worker", asyncDir: "/tmp/widget-run" });
 				handlers.get("tool_result")({ toolName: "subagent" }, ctx);
 				const asyncWidgets = widgets.filter((entry) => entry.key === "subagent-async");
 				if (!asyncWidgets.some((entry) => entry.value !== undefined)) throw new Error("async widget was not rendered with FleetView enabled: " + JSON.stringify(asyncWidgets));
@@ -455,11 +484,12 @@ describe("subagent extension child mode", () => {
 		}
 	});
 
-	it("restores disk-backed active status after a management tool result", () => {
+	it("restores indexed active status after a management tool result", () => {
 		const script = String.raw`
 			import * as fs from "node:fs";
 			import * as path from "node:path";
 			import registerSubagentExtension from "./index.ts";
+			import { updateActiveRunIndex } from "./src/runs/background/active-run-index.ts";
 			import { DIRS } from "./src/shared/types.ts";
 			const eventHandlers = new Map();
 			const handlers = new Map();
@@ -489,6 +519,7 @@ describe("subagent extension child mode", () => {
 				runId, sessionId, mode: "workflow", state: "running",
 				startedAt: Date.now(), lastUpdate: Date.now(), cwd: process.cwd(), pid: process.pid,
 			}), "utf-8");
+			updateActiveRunIndex(asyncDir, "running");
 			handlers.get("tool_result")({ toolName: "subagent" }, ctx);
 			const fleetWidgets = widgets.filter((entry) => entry.key === "subagent-fleet-status");
 			if (!fleetWidgets.some((entry) => typeof entry.value === "function")) throw new Error("management result did not restore active fleet status: " + JSON.stringify(fleetWidgets));
@@ -544,7 +575,7 @@ describe("subagent extension child mode", () => {
 			handlers.get("session_start")({}, ctx);
 			sent.length = 0;
 			events.emit("subagent:async-complete", {
-				id: "shutdown-held-completion", agent: "builder", success: true, summary: "Done",
+				id: "shutdown-held-completion", agent: "worker", success: true, summary: "Done",
 				exitCode: 0, timestamp: Date.now(), sessionId: "notify-shutdown-session",
 			});
 			if (sent.length !== 0) throw new Error("completion was not queued before shutdown");
@@ -622,7 +653,7 @@ describe("subagent extension child mode", () => {
 			oldRuntime.sent.length = 0;
 			const timersBeforeOldCompletion = new Set(pendingTimers.keys());
 			oldRuntime.events.emit("subagent:async-complete", {
-				id: "reload-held-completion", agent: "builder", success: true, summary: "Old",
+				id: "reload-held-completion", agent: "worker", success: true, summary: "Old",
 				exitCode: 0, timestamp: Date.now(), sessionId: "notify-reload-old",
 			});
 			if (oldRuntime.sent.length !== 0) throw new Error("old completion was not queued before reload");
@@ -637,7 +668,7 @@ describe("subagent extension child mode", () => {
 
 			const timersBeforeNewCompletion = new Set(pendingTimers.keys());
 			newRuntime.events.emit("subagent:async-complete", {
-				id: "reload-new-completion", agent: "commentator", success: true, summary: "New",
+				id: "reload-new-completion", agent: "reviewer", success: true, summary: "New",
 				exitCode: 0, timestamp: Date.now(), sessionId: "notify-reload-new",
 			});
 			const newCompletionTimers = [...pendingTimers.entries()].filter(([token]) => !timersBeforeNewCompletion.has(token));
@@ -820,6 +851,37 @@ describe("subagent extension child mode", () => {
 		);
 	});
 
+	it("trims legacy chain controls from the child-safe fanout tool by default", () => {
+		const readRegisteredTool = (legacyChainControls: boolean): { description: string; properties: string[]; id: string; runId: string } => {
+			const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fanout-schema-"));
+			fs.mkdirSync(path.join(agentDir, "extensions", "subagent"), { recursive: true });
+			fs.writeFileSync(path.join(agentDir, "extensions", "subagent", "config.json"), JSON.stringify({ legacyChainControls }), "utf-8");
+			const script = String.raw`
+				import registerFanoutChildSubagentExtension from "./src/extension/fanout-child.ts";
+				import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "./src/runs/shared/pi-args.ts";
+				process.env[SUBAGENT_CHILD_ENV] = "1";
+				process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+				let tool;
+				registerFanoutChildSubagentExtension({ events: { on() { return () => {}; }, emit() {} }, registerTool(value) { tool = value; }, getSessionName() { return undefined; } });
+				process.stdout.write(JSON.stringify({ description: tool.description, properties: Object.keys(tool.parameters.properties), id: tool.parameters.properties.id.description, runId: tool.parameters.properties.runId.description }));
+			`;
+			const output = execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], {
+				cwd: projectRoot,
+				env: parentToolEnv(agentDir),
+				encoding: "utf-8",
+			});
+			return JSON.parse(output) as { description: string; properties: string[]; id: string; runId: string };
+		};
+
+		const trimmed = readRegisteredTool(false);
+		assert.equal(trimmed.properties.includes("step"), false);
+		assert.doesNotMatch(`${trimmed.description}\n${trimmed.id}\n${trimmed.runId}`, /append-step|approve-checkpoint|reject-checkpoint/);
+
+		const legacy = readRegisteredTool(true);
+		assert.equal(legacy.properties.includes("step"), true);
+		assert.match(`${legacy.description}\n${legacy.id}\n${legacy.runId}`, /append-step/);
+	});
+
 	it("lets fanout children call read-only list but blocks mutating management actions", () => {
 		const script = String.raw`
 			import registerFanoutChildSubagentExtension from "./src/extension/fanout-child.ts";
@@ -846,6 +908,10 @@ describe("subagent extension child mode", () => {
 			if (!create.isError) throw new Error("create should be blocked");
 			const text = create.content?.[0]?.text ?? "";
 			if (!text.includes("not available from child-safe subagent fanout mode")) throw new Error("unexpected create error: " + text);
+			const refine = await registeredTool.execute("refine-check", { action: "refine", agent: "worker" }, new AbortController().signal, undefined, ctx);
+			if (!refine.isError) throw new Error("refine should be blocked");
+			const refineText = refine.content?.[0]?.text ?? "";
+			if (!refineText.includes("not available from child-safe subagent fanout mode")) throw new Error("unexpected refine error: " + refineText);
 			const grant = await registeredTool.execute("grant-check", { action: "grant-spawn-budget", additional: 1 }, new AbortController().signal, undefined, { ...ctx, hasUI: true });
 			if (!grant.isError) throw new Error("grant-spawn-budget should be blocked");
 			const grantText = grant.content?.[0]?.text ?? "";

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

@@ -17,14 +17,14 @@ import {
 
 function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
 	return {
-		name: "builder",
-		description: "Test builder",
+		name: "worker",
+		description: "Test worker",
 		systemPrompt: "Base prompt",
 		systemPromptMode: "replace",
 		inheritProjectContext: false,
 		inheritSkills: false,
 		source: "user",
-		filePath: "/tmp/builder.md",
+		filePath: "/tmp/worker.md",
 		...overrides,
 	};
 }
@@ -44,7 +44,7 @@ describe("resolveIntercomBridgeMode", () => {
 
 describe("resolveIntercomSessionTarget", () => {
 	it("prefers an explicit session name", () => {
-		assert.equal(resolveIntercomSessionTarget("architect", "session-12345678", "session-stableabcdef"), "architect");
+		assert.equal(resolveIntercomSessionTarget("planner", "session-12345678", "session-stableabcdef"), "planner");
 	});
 
 	it("uses a runtime-only subagent chat alias when unnamed", () => {
@@ -52,13 +52,14 @@ 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");
 	});
 });
 
 describe("resolveSubagentIntercomTarget", () => {
 	it("builds stable child session targets from run metadata", () => {
-		assert.equal(resolveSubagentIntercomTarget("78f659a3", "builder"), "subagent-builder-78f659a3");
+		assert.equal(resolveSubagentIntercomTarget("78f659a3", "worker"), "subagent-worker-78f659a3");
 		assert.equal(resolveSubagentIntercomTarget("78f659a3", "senior executor", 1), "subagent-senior-executor-78f659a3-2");
 	});
 });

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-goal-driver.test.ts

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+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 { handleMissionAction } from "../../src/missions/actions.ts";
+import { collectGoalContinuationNotices } from "../../src/missions/goal-driver.ts";
+import { createMission, readMission, resolveMissionStoreLocation, updateMission } from "../../src/missions/store.ts";
+import { missionStatePath } from "../../src/missions/workflow-state.ts";
+
+function fixture() {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-goal-mission-"));
+	const projectRoot = path.join(root, "project");
+	fs.mkdirSync(projectRoot, { recursive: true });
+	const location = resolveMissionStoreLocation({ projectRoot, agentDir: path.join(root, "agent") });
+	return { root, projectRoot, location };
+}
+
+describe("goal mission continuation", () => {
+	it("nudges from persisted state only while linked runs are idle and accounts their tokens", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, {
+				title: "Ship auth refresh",
+				objective: "Implement and validate token refresh",
+				goal: true,
+				budget: { tokens: 100 },
+				status: "active",
+				ownerSessionId: "session-1",
+			});
+			fs.mkdirSync(path.dirname(missionStatePath(test.location, mission.id)), { recursive: true });
+			fs.writeFileSync(missionStatePath(test.location, mission.id), JSON.stringify({ lanes: { review: { status: "ready", action: "Review the token refresh diff" } } }));
+
+			const first = collectGoalContinuationNotices({ location: test.location, ownerSessionId: "session-1", retainedChildren: [], turnId: 1 });
+			assert.equal(first.length, 1);
+			assert.match(first[0]!.message, /Remaining budget: 100 tokens/);
+			assert.match(first[0]!.message, /Next ready action: Review the token refresh diff/);
+
+			const asyncDir = path.join(test.root, "run-1");
+			fs.mkdirSync(asyncDir);
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ state: "running", totalTokens: { input: 10, output: 5, total: 15 } }));
+			updateMission(test.location, mission.id, { addRuns: [{ runId: "workflow-1", mode: "workflow", asyncDir, status: "running" }] });
+			assert.deepEqual(collectGoalContinuationNotices({ location: test.location, ownerSessionId: "session-1", retainedChildren: [], turnId: 2 }), []);
+
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ state: "complete", totalTokens: { input: 25, output: 15, total: 40 } }));
+			const resumed = collectGoalContinuationNotices({
+				location: test.location,
+				ownerSessionId: "session-1",
+				retainedChildren: [{ runId: "child-review", parentRunId: "workflow-1", agent: "reviewer", taskSummary: "Review", completedAt: 1, sessionPath: "/tmp/child.jsonl" }],
+				turnId: 3,
+			});
+			assert.equal(resumed.length, 1);
+			assert.match(resumed[0]!.message, /Remaining budget: 60 tokens/);
+			assert.match(resumed[0]!.message, /Resume retained child child-review \(reviewer\)/);
+			assert.equal(readMission(test.location, mission.id).usage?.tokens, 40);
+
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ state: "complete", totalTokens: { input: 60, output: 40, total: 100 } }));
+			assert.deepEqual(collectGoalContinuationNotices({ location: test.location, ownerSessionId: "session-1", retainedChildren: [], turnId: 4 }), []);
+			assert.equal(readMission(test.location, mission.id).goal?.status, "budget-exhausted");
+			assert.equal(readMission(test.location, mission.id).status, "active");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("resumes retained children from the latest linked run", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, {
+				title: "Ship auth refresh",
+				objective: "Implement and validate token refresh",
+				goal: true,
+				budget: { tokens: 100 },
+				status: "active",
+				ownerSessionId: "session-1",
+			});
+			updateMission(test.location, mission.id, {
+				addRuns: [
+					{ runId: "workflow-old", mode: "workflow", status: "complete" },
+					{ runId: "workflow-new", mode: "workflow", status: "complete" },
+				],
+			});
+
+			const notices = collectGoalContinuationNotices({
+				location: test.location,
+				ownerSessionId: "session-1",
+				retainedChildren: [
+					{ runId: "child-old", parentRunId: "workflow-old", agent: "reviewer", taskSummary: "Old", completedAt: 2, sessionPath: "/tmp/old.jsonl" },
+					{ runId: "child-new", parentRunId: "workflow-new", agent: "reviewer", taskSummary: "New", completedAt: 1, sessionPath: "/tmp/new.jsonl" },
+				],
+				turnId: 1,
+			});
+
+			assert.equal(notices.length, 1);
+			assert.match(notices[0]!.message, /Resume retained child child-new \(reviewer\)/);
+			assert.doesNotMatch(notices[0]!.message, /child-old/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("supports pause, resume, and opt-out through mission.update", () => {
+		const test = fixture();
+		try {
+			const ctx = { cwd: test.projectRoot, agentDir: path.join(test.root, "agent"), currentSessionId: "session-1" };
+			const created = handleMissionAction("mission.create", { mission: { title: "Goal controls", objective: "Exercise controls", goal: true, budget: { tokens: 50 } } }, ctx);
+			const missionId = created.details!.missionId!;
+			assert.equal(handleMissionAction("mission.update", { missionId, missionUpdate: { goal: { paused: true } } }, ctx).details?.mission?.goal?.status, "paused");
+			assert.deepEqual(collectGoalContinuationNotices({ location: test.location, ownerSessionId: "session-1", retainedChildren: [], turnId: 1 }), []);
+			assert.equal(handleMissionAction("mission.update", { missionId, missionUpdate: { goal: { paused: false } } }, ctx).details?.mission?.goal?.status, "active");
+			assert.equal(handleMissionAction("mission.update", { missionId, missionUpdate: { goal: false } }, ctx).details?.mission?.goal, undefined);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+});