@selesai/code 0.8.3 → 0.8.5

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

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
+import { validateMissionLaunch } from "../../src/missions/actions.ts";
 import {
 	attachMissionToLaunchResult,
 	prepareMissionLaunch,
@@ -10,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-"));
@@ -19,6 +21,27 @@ function projectFixture() {
 }
 
 describe("mission launch lifecycle", () => {
+	it("validates the public mission launch shape", () => {
+		assert.deepEqual(validateMissionLaunch({
+			summary: "Review the active backlog",
+			objective: "Find ready work",
+			goal: true,
+			budget: { tokens: 400000 },
+			labels: ["review"],
+		}), {
+			title: "Review the active backlog",
+			objective: "Find ready work",
+			goal: true,
+			budget: { tokens: 400000 },
+			labels: ["review"],
+		});
+		assert.throws(() => validateMissionLaunch({}), /title or mission\.summary/);
+		assert.throws(() => validateMissionLaunch({ title: "Title", summary: "Summary" }), /cannot both be set/);
+		assert.throws(() => validateMissionLaunch({ title: " " }), /non-empty string/);
+		assert.throws(() => validateMissionLaunch({ title: "Title", goal: false }), /must be true/);
+		assert.throws(() => validateMissionLaunch({ title: "Title", goal: true }), /budget is required/);
+	});
+
 	it("creates missions by default for task launches and honors explicit opt-out", () => {
 		const test = projectFixture();
 		try {
@@ -30,7 +53,8 @@ describe("mission launch lifecycle", () => {
 			});
 			assert.ok(binding);
 			const mission = readMission(binding.location, binding.missionId);
-			assert.equal(mission.goal, "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,
@@ -39,7 +63,7 @@ describe("mission launch lifecycle", () => {
 					details: {
 						mode: "single",
 						runId: "default-mission-run",
-						results: [{ index: 0, agent: "builder", task: "Map the auth flow", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
+						results: [{ index: 0, agent: "worker", task: "Map the auth flow", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
 					},
 				},
 			});
@@ -52,6 +76,20 @@ describe("mission launch lifecycle", () => {
 			});
 			assert.equal(disabled, undefined);
 
+			const parallelOnly = prepareMissionLaunch({
+				params: { chain: [{ parallel: [{ task: "" }, { task: "Review parallel work" }] }] },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			assert.ok(parallelOnly);
+			assert.equal(readMission(parallelOnly.location, parallelOnly.missionId).objective, PROMPT_REDACTED);
+
+			assert.throws(() => prepareMissionLaunch({
+				params: { missionId: "" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			}), /missionId/);
+
 			const perLaunchDisabled = prepareMissionLaunch({
 				params: { mission: false, task: "Ephemeral check" },
 				projectRoot: test.projectRoot,
@@ -71,6 +109,41 @@ describe("mission launch lifecycle", () => {
 				config: { ...test.missionConfig, enabled: false },
 			});
 			assert.ok(explicit);
+			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" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			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 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 });
 		}
@@ -80,7 +153,7 @@ describe("mission launch lifecycle", () => {
 		const test = projectFixture();
 		try {
 			const binding = prepareMissionLaunch({
-				params: { mission: { title: "Implement feature", goal: "Ship it", labels: ["phase-1"] }, task: "Do the work" },
+				params: { mission: { title: "Implement feature", objective: "Ship it", labels: ["phase-1"] }, task: "Do the work" },
 				projectRoot: test.projectRoot,
 				config: test.missionConfig,
 				ownerSessionId: "session-1",
@@ -93,7 +166,7 @@ describe("mission launch lifecycle", () => {
 					details: {
 						mode: "single",
 						runId: "foreground-1",
-						results: [{ index: 0, agent: "builder", task: "Do the work", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
+						results: [{ index: 0, agent: "worker", task: "Do the work", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
 					},
 				},
 			});
@@ -176,7 +249,7 @@ describe("mission launch lifecycle", () => {
 		}
 	});
 
-	it("binds an async launch and reconciles terminal status and artifacts", () => {
+	it("binds an async workflow launch and preserves its mode through completion", () => {
 		const test = projectFixture();
 		try {
 			const asyncDir = path.join(test.root, "async-run");
@@ -191,7 +264,7 @@ describe("mission launch lifecycle", () => {
 				binding,
 				result: {
 					content: [{ type: "text", text: "Async started" }],
-					details: { mode: "chain", runId: "async-1", asyncId: "async-1", asyncDir, results: [] },
+					details: { mode: "workflow", runId: "async-1", asyncId: "async-1", asyncDir, results: [] },
 				},
 			});
 			assert.equal(readMissionBinding(asyncDir)?.missionId, binding.missionId);
@@ -201,7 +274,7 @@ describe("mission launch lifecycle", () => {
 				id: "async-1",
 				runId: "async-1",
 				asyncDir,
-				mode: "chain",
+				mode: "workflow",
 				state: "complete",
 				success: true,
 				summary: "Background work completed",
@@ -209,6 +282,7 @@ describe("mission launch lifecycle", () => {
 			});
 			assert.equal(completed?.status, "completed");
 			assert.equal(completed?.runs[0]?.status, "complete");
+			assert.equal(completed?.runs[0]?.mode, "workflow");
 			assert.ok(completed?.artifacts.some((artifact) => artifact.kind === "output"));
 		} finally {
 			fs.rmSync(test.root, { recursive: true, force: true });

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

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -12,6 +13,7 @@ import {
 	resolveMissionStoreLocation,
 	updateMission,
 } from "../../src/missions/store.ts";
+import { createMissionWorkflowState, MISSION_STATE_MAX_BYTES, missionStatePath } from "../../src/missions/workflow-state.ts";
 
 function fixture() {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-missions-"));
@@ -22,13 +24,22 @@ function fixture() {
 	return { root, projectRoot, agentDir, location };
 }
 
+async function waitForFile(filePath: string, timeoutMs = 10_000): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (fs.existsSync(filePath)) return;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	throw new Error(`Timed out waiting for ${filePath} after ${timeoutMs} ms`);
+}
+
 describe("mission store", () => {
 	it("creates, reads, updates, lists, and globally indexes project missions", () => {
 		const test = fixture();
 		try {
 			const created = createMission(test.location, {
 				title: "Ship durable missions",
-				goal: "Make delegated work resumable",
+				objective: "Make delegated work resumable",
 				labels: ["phase-1"],
 			});
 			const updated = updateMission(test.location, created.id, {
@@ -43,7 +54,7 @@ describe("mission store", () => {
 				addDecisions: [{ title: "Choose release window", options: ["now", "later"] }],
 			});
 
-			assert.equal(readMission(test.location, created.id).status, "active");
+			assert.equal(readMission(test.location, created.id).status, "needs_decision");
 			assert.equal(updated.runs[0]?.runId, "run-1");
 			assert.equal(readMission(test.location, created.id).runs[1]?.mode, "workflow");
 			assert.equal(updated.decisions[0]?.status, "open");
@@ -62,15 +73,279 @@ describe("mission store", () => {
 		}
 	});
 
-	it("loads older records that do not have receipts", () => {
+	it("persists workflow child attempts and projects their latest heartbeat", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, { title: "Dispatch ledger", objective: "Track workflow children", status: "active" });
+			updateMission(test.location, mission.id, {
+				upsertWorkflowChildren: [{
+					workflowRunId: "workflow-1",
+					key: "review",
+					status: "running",
+					agent: "reviewer",
+					task: "Review the diff",
+					phase: "review",
+					sessionPath: "/tmp/review.jsonl",
+					heartbeat: { status: "running", phase: "review" },
+				}],
+			}, new Date("2026-08-11T10:00:00.000Z"));
+			const completed = updateMission(test.location, mission.id, {
+				upsertWorkflowChildren: [{
+					workflowRunId: "workflow-1",
+					key: "review",
+					status: "completed",
+					runId: "child-1",
+					completedAt: "2026-08-11T10:05:00.000Z",
+					artifactPaths: ["/tmp/review.md"],
+					heartbeat: { status: "completed", phase: "review" },
+				}],
+			}, new Date("2026-08-11T10:05:00.000Z"));
+
+			assert.equal(completed.workflowChildren.length, 1);
+			assert.deepEqual(completed.workflowChildren[0], {
+				workflowRunId: "workflow-1",
+				key: "review",
+				status: "completed",
+				startedAt: "2026-08-11T10:00:00.000Z",
+				updatedAt: "2026-08-11T10:05:00.000Z",
+				runId: "child-1",
+				agent: "reviewer",
+				task: "Review the diff",
+				phase: "review",
+				completedAt: "2026-08-11T10:05:00.000Z",
+				sessionPath: "/tmp/review.jsonl",
+				artifactPaths: ["/tmp/review.md"],
+				heartbeat: { status: "completed", phase: "review", updatedAt: "2026-08-11T10:05:00.000Z" },
+			});
+			const shown = handleMissionAction("mission.show", { missionId: mission.id }, { cwd: test.projectRoot, agentDir: test.agentDir });
+			assert.match(shown.content[0]?.type === "text" ? shown.content[0].text : "", /review \(child-1\): completed — reviewer \[review\]; updated .*; heartbeat completed\/review at/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("gates a mission on open decisions and resolves them explicitly", () => {
+		const test = fixture();
+		try {
+			const ctx = { cwd: test.projectRoot, agentDir: test.agentDir };
+			const mission = createMission(test.location, { title: "Decision gate", objective: "Wait for owner", status: "active" });
+			const pending = handleMissionAction("mission.update", {
+				missionId: mission.id,
+				missionUpdate: { decisions: [{ title: "Choose release window", options: ["now", "later"], recommendation: "later" }] },
+			}, ctx);
+			const decisionId = pending.details?.mission?.decisions[0]?.id;
+			assert.ok(decisionId);
+			assert.equal(pending.details?.mission?.status, "needs_decision");
+			assert.match(handleMissionAction("mission.list", {}, ctx).content[0]?.type === "text" ? handleMissionAction("mission.list", {}, ctx).content[0].text : "", /decisions: 1 open, 0 resolved/);
+
+			const refreshed = updateMission(test.location, mission.id, {
+				status: "active",
+				addRuns: [{ runId: "run-1", mode: "single", status: "running" }],
+			});
+			assert.equal(refreshed.status, "needs_decision");
+
+			const resolved = handleMissionAction("mission.resolve-decision", { missionId: mission.id, id: decisionId, summary: "Release later" }, ctx);
+			assert.equal(resolved.details?.mission?.status, "active");
+			assert.equal(resolved.details?.mission?.decisions[0]?.status, "resolved");
+			assert.equal(resolved.details?.mission?.decisions[0]?.resolution, "Release later");
+			assert.match(resolved.content[0]?.type === "text" ? resolved.content[0].text : "", /resolved — Choose release window; resolution: Release later/);
+			assert.throws(() => handleMissionAction("mission.resolve-decision", { missionId: mission.id, id: decisionId, summary: "Again" }, ctx), /already resolved/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps planned and waiting missions in their lifecycle state while decisions are resolved", () => {
+		const test = fixture();
+		try {
+			for (const status of ["planned", "waiting"] as const) {
+				const mission = createMission(test.location, { title: `${status} decision`, objective: "Keep state", status });
+				const pending = updateMission(test.location, mission.id, { addDecisions: [{ title: "Choose next step" }] });
+				const decisionId = pending.decisions[0]?.id;
+				assert.ok(decisionId);
+				assert.equal(pending.status, status);
+
+				const resolved = updateMission(test.location, mission.id, { resolveDecision: { id: decisionId, resolution: "Later" } });
+				assert.equal(resolved.status, status);
+				assert.equal(resolved.decisions[0]?.status, "resolved");
+			}
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("persists bounded workflow state and reads its file once per workflow", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, { title: "Stateful mission", objective: "Keep workflow state" });
+			const state = createMissionWorkflowState(test.location, mission.id);
+			assert.equal(state.get("missing"), undefined);
+			fs.mkdirSync(path.dirname(state.path), { recursive: true });
+			fs.writeFileSync(state.path, JSON.stringify({ external: true }), "utf-8");
+			assert.equal(state.get("external"), undefined);
+
+			const nextWorkflow = createMissionWorkflowState(test.location, mission.id);
+			assert.equal(nextWorkflow.get("external"), true);
+			nextWorkflow.set("review.stage", { count: 2 });
+			const concurrentWorkflow = createMissionWorkflowState(test.location, mission.id);
+			assert.deepEqual(concurrentWorkflow.get("review.stage"), { count: 2 });
+			nextWorkflow.set("approved", false);
+			concurrentWorkflow.set("reviewer", "ready");
+			assert.deepEqual(JSON.parse(fs.readFileSync(missionStatePath(test.location, mission.id), "utf-8")), {
+				external: true,
+				"review.stage": { count: 2 },
+				approved: false,
+				reviewer: "ready",
+			});
+			assert.throws(() => nextWorkflow.set("bad key", true), /state key must be 1-128 characters/);
+			assert.throws(() => nextWorkflow.set("too-large", "x".repeat(MISSION_STATE_MAX_BYTES)), /256 KiB limit/);
+			assert.equal(nextWorkflow.get("too-large"), undefined);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("serializes workflow state writes behind the state-file lock", async () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, { title: "Locked state", objective: "Serialize state writes" });
+			const statePath = missionStatePath(test.location, mission.id);
+			fs.mkdirSync(path.dirname(statePath), { recursive: true });
+			fs.writeFileSync(statePath, JSON.stringify({ external: true }, null, 2), "utf-8");
+			const lockPath = `${statePath}.lock`;
+			const readyPath = path.join(test.root, "writer-ready");
+			fs.mkdirSync(lockPath);
+			const script = `
+				import * as fs from "node:fs";
+				import { createMissionWorkflowState } from "./src/missions/workflow-state.ts";
+				const location = JSON.parse(process.env.MISSION_LOCATION);
+				fs.writeFileSync(process.env.READY_FILE, "ready", "utf-8");
+				createMissionWorkflowState(location, process.env.MISSION_ID).set("reviewer", "ready");
+			`;
+			const child = spawn(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", script], {
+				cwd: process.cwd(),
+				env: { ...process.env, MISSION_LOCATION: JSON.stringify(test.location), MISSION_ID: mission.id, READY_FILE: readyPath },
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+			let stderr = "";
+			child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+			await waitForFile(readyPath);
+			fs.writeFileSync(statePath, JSON.stringify({ external: true, approved: false }, null, 2), "utf-8");
+			fs.rmSync(lockPath, { recursive: true, force: true });
+			const exit = await Promise.race([
+				new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve) => child.on("exit", (code, signal) => resolve({ code, signal }))),
+				new Promise<{ code: "timeout"; signal: null }>((resolve) => setTimeout(() => { child.kill(); resolve({ code: "timeout", signal: null }); }, 5_000)),
+			]);
+			assert.deepEqual(exit, { code: 0, signal: null }, stderr);
+			assert.deepEqual(JSON.parse(fs.readFileSync(statePath, "utf-8")), {
+				external: true,
+				approved: false,
+				reviewer: "ready",
+			});
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("recovers abandoned workflow state locks", () => {
 		const test = fixture();
 		try {
-			const created = createMission(test.location, { title: "Older record", goal: "Stay readable" });
+			const mission = createMission(test.location, { title: "Stale lock", objective: "Recover state writes" });
+			const state = createMissionWorkflowState(test.location, mission.id);
+			const lockPath = `${state.path}.lock`;
+			fs.mkdirSync(lockPath, { recursive: true });
+			const staleAt = new Date(Date.now() - 120_000);
+			fs.utimesSync(lockPath, staleAt, staleAt);
+
+			state.set("reviewer", "ready");
+
+			assert.equal(fs.existsSync(lockPath), false);
+			assert.deepEqual(JSON.parse(fs.readFileSync(state.path, "utf-8")), { reviewer: "ready" });
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("recovers abandoned workflow state locks even when the owner pid was reused", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, { title: "Reused pid", objective: "Recover by lock age" });
+			const state = createMissionWorkflowState(test.location, mission.id);
+			const lockPath = `${state.path}.lock`;
+			fs.mkdirSync(lockPath, { recursive: true });
+			fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, token: "abandoned", createdAt: Date.now(), processKey: "stale-process" }), "utf-8");
+
+			state.set("reviewer", "ready");
+
+			assert.equal(fs.existsSync(lockPath), false);
+			assert.deepEqual(JSON.parse(fs.readFileSync(state.path, "utf-8")), { reviewer: "ready" });
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("serializes competing abandoned-lock recovery", async () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, { title: "Competing stale lock", objective: "Recover once" });
+			const statePath = missionStatePath(test.location, mission.id);
+			fs.mkdirSync(path.dirname(statePath), { recursive: true });
+			fs.writeFileSync(statePath, JSON.stringify({ external: true }, null, 2), "utf-8");
+			const lockPath = `${statePath}.lock`;
+			fs.mkdirSync(lockPath, { recursive: true });
+			const staleAt = new Date(Date.now() - 120_000);
+			fs.utimesSync(lockPath, staleAt, staleAt);
+			const script = `
+				import { createMissionWorkflowState } from "./src/missions/workflow-state.ts";
+				const location = JSON.parse(process.env.MISSION_LOCATION);
+				createMissionWorkflowState(location, process.env.MISSION_ID).set(process.env.STATE_KEY, process.env.STATE_VALUE);
+			`;
+			const spawnWriter = (key: string, value: string) => {
+				let stderr = "";
+				const child = spawn(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", script], {
+					cwd: process.cwd(),
+					env: { ...process.env, MISSION_LOCATION: JSON.stringify(test.location), MISSION_ID: mission.id, STATE_KEY: key, STATE_VALUE: value },
+					stdio: ["ignore", "pipe", "pipe"],
+				});
+				child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+				return new Promise<void>((resolve, reject) => {
+					const timeout = setTimeout(() => { child.kill(); reject(new Error(`${key} writer timed out`)); }, 5_000);
+					child.on("exit", (code, signal) => {
+						clearTimeout(timeout);
+						if (code === 0 && signal === null) resolve();
+						else reject(new Error(`${key} writer failed with code ${code} signal ${signal}: ${stderr}`));
+					});
+				});
+			};
+
+			await Promise.all([spawnWriter("reviewer", "ready"), spawnWriter("approved", "false")]);
+
+			assert.deepEqual(JSON.parse(fs.readFileSync(statePath, "utf-8")), {
+				external: true,
+				reviewer: "ready",
+				approved: "false",
+			});
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("loads older records that do not have receipts or objective", () => {
+		const test = fixture();
+		try {
+			const created = createMission(test.location, { title: "Older record", objective: "Stay readable" });
 			const recordPath = path.join(test.location.missionDir, `${created.id}.json`);
 			const raw = JSON.parse(fs.readFileSync(recordPath, "utf-8")) as Record<string, unknown>;
 			delete raw.receipts;
+			delete raw.objective;
+			raw.goal = "Stay readable";
 			fs.writeFileSync(recordPath, JSON.stringify(raw), "utf-8");
-			assert.deepEqual(readMission(test.location, created.id).receipts, []);
+
+			const mission = readMission(test.location, created.id);
+			assert.equal(mission.objective, "Stay readable");
+			assert.equal(mission.goal, undefined);
+			assert.deepEqual(mission.receipts, []);
+			assert.deepEqual(mission.workflowChildren, []);
 		} finally {
 			fs.rmSync(test.root, { recursive: true, force: true });
 		}
@@ -79,8 +354,8 @@ describe("mission store", () => {
 	it("skips corrupt records, removes missing pointers, and preserves parse-error pointers", () => {
 		const test = fixture();
 		try {
-			const missing = createMission(test.location, { title: "Missing record", goal: "Heal its pointer" });
-			const corrupt = createMission(test.location, { title: "Corrupt record", goal: "Keep evidence" });
+			const missing = createMission(test.location, { title: "Missing record", objective: "Heal its pointer" });
+			const corrupt = createMission(test.location, { title: "Corrupt record", objective: "Keep evidence" });
 			fs.writeFileSync(path.join(test.location.missionDir, "broken.json"), "{not json", "utf-8");
 			assert.equal(listMissions(test.location).warnings.length, 1);
 
@@ -100,10 +375,10 @@ describe("mission store", () => {
 		const test = fixture();
 		const location = { ...test.location, retainTerminal: 1 };
 		try {
-			const oldest = createMission(location, { title: "Old terminal", goal: "Prune me" }, new Date("2026-01-01T00:00:00Z"));
-			const newest = createMission(location, { title: "New terminal", goal: "Keep me" }, new Date("2026-01-02T00:00:00Z"));
-			const active = createMission(location, { title: "Active", goal: "Never prune", status: "active" }, new Date("2026-01-03T00:00:00Z"));
-			const planned = createMission(location, { title: "Planned", goal: "Never prune", status: "planned" }, new Date("2026-01-04T00:00:00Z"));
+			const oldest = createMission(location, { title: "Old terminal", objective: "Prune me" }, new Date("2026-01-01T00:00:00Z"));
+			const newest = createMission(location, { title: "New terminal", objective: "Keep me" }, new Date("2026-01-02T00:00:00Z"));
+			const active = createMission(location, { title: "Active", objective: "Never prune", status: "active" }, new Date("2026-01-03T00:00:00Z"));
+			const planned = createMission(location, { title: "Planned", objective: "Never prune", status: "planned" }, new Date("2026-01-04T00:00:00Z"));
 			updateMission(location, oldest.id, { status: "completed" }, new Date("2026-01-05T00:00:00Z"));
 			updateMission(location, newest.id, { status: "failed" }, new Date("2026-01-06T00:00:00Z"));
 
@@ -121,7 +396,7 @@ describe("mission store", () => {
 		const test = fixture();
 		try {
 			const ctx = { cwd: test.projectRoot, agentDir: test.agentDir, currentSessionId: "session-1" };
-			const created = handleMissionAction("mission.create", { mission: { title: "Unreadable status", goal: "Keep mission readable" } }, ctx);
+			const created = handleMissionAction("mission.create", { mission: { title: "Unreadable status", objective: "Keep mission readable" } }, ctx);
 			const missionId = created.details?.missionId;
 			assert.ok(missionId);
 			const asyncDir = path.join(test.root, "async-run");
@@ -143,7 +418,7 @@ describe("mission store", () => {
 		const test = fixture();
 		try {
 			const ctx = { cwd: test.projectRoot, agentDir: test.agentDir, currentSessionId: "session-1" };
-			const created = handleMissionAction("mission.create", { mission: { title: "Action mission", goal: "Exercise actions" } }, ctx);
+			const created = handleMissionAction("mission.create", { mission: { title: "Action mission", objective: "Exercise actions" } }, ctx);
 			const missionId = created.details?.missionId;
 			assert.ok(missionId);
 			const asyncDir = path.join(test.root, "async-run");
@@ -153,6 +428,7 @@ describe("mission store", () => {
 			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ state: "complete" }), "utf-8");
 			const shown = handleMissionAction("mission.show", { missionId }, ctx);
 			assert.equal(shown.details?.mission?.status, "completed");
+			assert.match(shown.content[0]?.type === "text" ? shown.content[0].text : "", new RegExp(`State: .*${missionId}[/\\\\]state\\.json`));
 			assert.equal(shown.details?.mission?.runs[0]?.status, "complete");
 			const receipt = handleMissionAction("mission.update", {
 				missionId,

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", () => {
@@ -117,7 +131,7 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
-	it("inherits the parent session model when the agent config sets model: false (explorer)", () => {
+	it("inherits the parent session model when the agent config sets model: false (delegate)", () => {
 		assert.equal(
 			resolveSubagentModelOverride(false, parentModel, availableModels),
 			"deepseek/deepseek-v4-flash",
@@ -335,6 +349,15 @@ describe("resolveSubagentModelOverride scope enforcement", () => {
 		assert.equal(warnings.length, 1);
 	});
 
+	it("throws for an inherited parent-session model in strict mode", () => {
+		assert.throws(
+			() => resolveSubagentModelOverride(undefined, parentModel, availableModels, undefined, {
+				scope: { ...scope, strict: true },
+			}),
+			/deepseek\/deepseek-v4.*outside the configured subagent model scope/,
+		);
+	});
+
 	it("passes through an in-scope explicit model without warning or error", () => {
 		const warnings: string[] = [];
 		const resolved = resolveSubagentModelOverride("gpt-5-mini", parentModel, availableModels, undefined, {
@@ -379,4 +402,22 @@ describe("resolveSubagentModelOverride scope enforcement", () => {
 		assert.equal(warnings.length, 1);
 		assert.match(warnings[0]!, /deepseek\/deepseek-v4/);
 	});
+
+	it("throws for an out-of-scope primary candidate in strict mode", () => {
+		assert.throws(
+			() => buildModelCandidates("deepseek/deepseek-v4", undefined, availableModels, undefined, {
+				scope: { ...scope, strict: true },
+			}),
+			/deepseek\/deepseek-v4.*outside the configured subagent model scope/,
+		);
+	});
+
+	it("throws instead of pruning an out-of-scope fallback in strict mode", () => {
+		assert.throws(
+			() => buildModelCandidates("gpt-5-mini", ["deepseek/deepseek-v4"], availableModels, undefined, {
+				scope: { ...scope, strict: true },
+			}),
+			/deepseek\/deepseek-v4.*outside the configured subagent model scope/,
+		);
+	});
 });

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

@@ -42,10 +42,10 @@ describe("subagents.modelScope discovery", () => {
 
 	it("exposes a user modelScope from discoverAgents", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] } },
+			subagents: { modelScope: { enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"] } },
 		});
 		const result = discoverAgents(tempProject, "both");
-		assert.deepEqual(result.modelScope, { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] });
+		assert.deepEqual(result.modelScope, { enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"] });
 	});
 
 	it("returns undefined when no modelScope is configured", () => {