@selesai/code 0.8.3 → 0.8.4

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

@@ -117,7 +117,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 +335,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 +388,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", () => {

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

@@ -81,6 +81,11 @@ describe("checkModelScope", () => {
 		assert.equal(violation?.severity, "warn");
 	});
 
+	it("returns an error violation for an inherited model in strict mode", () => {
+		const violation = checkModelScope("deepseek/deepseek-v4", { ...scope, strict: true }, "inherited");
+		assert.equal(violation?.severity, "error");
+	});
+
 	it("defaults to inherited (warn) severity when source is omitted-ish via inherited", () => {
 		// Caller passes "inherited" for frontmatter/parent-inherited models.
 		assert.equal(checkModelScope("meta/llama-4", scope, "inherited")?.severity, "warn");
@@ -105,8 +110,8 @@ describe("parseModelScopeConfig", () => {
 
 	it("parses a well-formed config", () => {
 		assert.deepEqual(
-			parseModelScopeConfig({ enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] }, meta),
-			{ enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] },
+			parseModelScopeConfig({ enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"] }, meta),
+			{ enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"] },
 		);
 	});
 
@@ -130,6 +135,10 @@ describe("parseModelScopeConfig", () => {
 		assert.throws(() => parseModelScopeConfig({ enforce: "yes" }, meta), /invalid 'modelScope.enforce'/);
 	});
 
+	it("rejects a non-boolean strict value", () => {
+		assert.throws(() => parseModelScopeConfig({ strict: "yes" }, meta), /invalid 'modelScope.strict'/);
+	});
+
 	it("rejects a non-array allow", () => {
 		assert.throws(() => parseModelScopeConfig({ allow: "anthropic/*" }, meta), /invalid 'modelScope.allow'/);
 	});

package/dist/extensions/pi-subagents/test/unit/native-supervisor-channel.test.ts

@@ -49,7 +49,7 @@ function makeState(sessionId: string | null, ctx: unknown): SubagentState {
 }
 
 function writeRequest(input: { sessionId: string; runId: string; agent?: string; index?: number; message?: string; createdAt?: number; expiresAt?: number }): string {
-	const agent = input.agent ?? "builder";
+	const agent = input.agent ?? "worker";
 	const index = input.index ?? 0;
 	const channelDir = resolveSupervisorChannelDir(input.runId, agent, index);
 	createdChannels.push(channelDir);
@@ -72,16 +72,16 @@ function writeRequest(input: { sessionId: string; runId: string; agent?: string;
 	return requestId;
 }
 
-function requestFile(runId: string, requestId: string, agent = "builder", index = 0): string {
+function requestFile(runId: string, requestId: string, agent = "worker", index = 0): string {
 	return path.join(resolveSupervisorChannelDir(runId, agent, index), "requests", `${requestId}.json`);
 }
 
-function replyFile(runId: string, requestId: string, agent = "builder", index = 0): string {
+function replyFile(runId: string, requestId: string, agent = "worker", index = 0): string {
 	return path.join(resolveSupervisorChannelDir(runId, agent, index), "replies", `${requestId}.json`);
 }
 
 function makeEmptyChannel(runId: string): string {
-	const channelDir = resolveSupervisorChannelDir(runId, "builder", 0);
+	const channelDir = resolveSupervisorChannelDir(runId, "worker", 0);
 	createdChannels.push(channelDir);
 	ensureSupervisorChannelDir(channelDir);
 	return channelDir;
@@ -94,6 +94,14 @@ function ageChannel(channelDir: string, ageMs: number): void {
 	}
 }
 
+async function waitForCondition(condition: () => boolean, description: string): Promise<void> {
+	const deadline = Date.now() + 1000;
+	while (!condition()) {
+		if (Date.now() > deadline) assert.fail(`Timed out waiting for ${description}`);
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+}
+
 function restoreEnv(): void {
 	for (const [key, value] of Object.entries(savedEnv)) {
 		if (value === undefined) delete process.env[key];
@@ -149,6 +157,72 @@ describe("native supervisor channel", () => {
 		assert.equal(sent.some(({ message }) => message.details?.id === otherId), false);
 	});
 
+	it("uses polling instead of native watchers on Windows", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const requestId = writeRequest({ sessionId: currentSessionId, runId: `run-${randomUUID()}` });
+		const sent: Array<{ details?: { id?: string } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: (message: { details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		let watchCalls = 0;
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx), {
+			platform: "win32",
+			watch: (() => {
+				watchCalls += 1;
+				throw new Error("Windows supervisor channel must not call fs.watch.");
+			}) as never,
+		});
+
+		channel.start();
+		channel.dispose();
+
+		assert.equal(watchCalls, 0);
+		assert.deepEqual(sent.map((message) => message.details?.id), [requestId]);
+	});
+
+	it("delivers requests written under an existing request directory by watch event", async () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		makeEmptyChannel(runId);
+		const sent: Array<{ details?: { id?: string } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: (message: { details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		try {
+			channel.start();
+			const requestId = writeRequest({ sessionId: currentSessionId, runId });
+			await waitForCondition(() => sent.some((message) => message.details?.id === requestId), "supervisor request watch delivery");
+		} finally {
+			channel.dispose();
+		}
+	});
+
 	it("prunes stale empty supervisor channel directories before polling", () => {
 		const currentSessionId = `session-${randomUUID()}`;
 		const staleEmptyChannel = makeEmptyChannel(`run-${randomUUID()}`);
@@ -211,7 +285,7 @@ describe("native supervisor channel", () => {
 	it("emits foreground detach only after displaying a pending supervisor request", () => {
 		const currentSessionId = `session-${randomUUID()}`;
 		const runId = `run-${randomUUID()}`;
-		const requestId = writeRequest({ sessionId: currentSessionId, runId, agent: "builder", index: 2 });
+		const requestId = writeRequest({ sessionId: currentSessionId, runId, agent: "worker", index: 2 });
 		const log: string[] = [];
 		const emitted: Array<{ channel: string; payload: { requestId?: string; runId?: string; agent?: string; childIndex?: number } }> = [];
 		const ctx = {
@@ -242,7 +316,7 @@ describe("native supervisor channel", () => {
 			assert.deepEqual(log, ["send", "emit"]);
 			assert.deepEqual(emitted, [{
 				channel: INTERCOM_DETACH_REQUEST_EVENT,
-				payload: { requestId, runId, agent: "builder", childIndex: 2 },
+				payload: { requestId, runId, agent: "worker", childIndex: 2 },
 			}]);
 			assert.equal(channel.pending.has(requestId), true);
 		} finally {
@@ -271,7 +345,7 @@ describe("native supervisor channel", () => {
 			cwd: process.cwd(),
 			sessionId: currentSessionId,
 			updatedAt: 1,
-			children: [{ agent: "builder", index: 0, status: "detached", updatedAt: 1 }],
+			children: [{ agent: "worker", index: 0, status: "detached", updatedAt: 1 }],
 		}]]);
 		const pi = {
 			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
@@ -398,7 +472,7 @@ describe("native supervisor channel", () => {
 			mode: "single",
 			cwd: process.cwd(),
 			updatedAt: Date.now(),
-			children: [{ agent: "builder", index: 0, status: "completed", updatedAt: Date.now() }],
+			children: [{ agent: "worker", index: 0, status: "completed", updatedAt: Date.now() }],
 		}]]);
 		const pi = {
 			getAllTools: () => [],
@@ -464,13 +538,13 @@ describe("native supervisor channel", () => {
 
 	it("removes the request file when a child supervisor ask is cancelled", async () => {
 		const runId = `run-${randomUUID()}`;
-		const channelDir = resolveSupervisorChannelDir(runId, "builder", 0);
+		const channelDir = resolveSupervisorChannelDir(runId, "worker", 0);
 		createdChannels.push(channelDir);
 		process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = "shared-name";
 		process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = "session-parent";
 		process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = channelDir;
 		process.env[SUBAGENT_RUN_ID_ENV] = runId;
-		process.env[SUBAGENT_CHILD_AGENT_ENV] = "builder";
+		process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
 		process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
 		const registeredTools = new Map<string, { execute: (_id: string, params: { reason: string; message?: string }, signal?: AbortSignal) => Promise<unknown> | unknown }>();
 		const pi = {