@selesai/code 0.13.40 → 0.14.3

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

@@ -0,0 +1,215 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+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 { pathToFileURL } from "node:url";
+import { createMission, listGlobalMissions, readMission, resolveMissionStoreLocation, updateMission } from "../../src/missions/store.ts";
+
+function fixture() {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-mission-projection-"));
+	const projectRoot = path.join(root, "project");
+	const agentDir = path.join(root, "agent");
+	fs.mkdirSync(projectRoot, { recursive: true });
+	const location = resolveMissionStoreLocation({
+		projectRoot,
+		agentDir,
+		config: { directory: path.join(root, "missions"), globalIndexDir: path.join(root, "global-index") },
+	});
+	return { root, location };
+}
+
+function indexPathFor(globalIndexDir: string, missionId: string): string {
+	const filePath = fs.readdirSync(globalIndexDir)
+		.filter((name) => name.endsWith(".json"))
+		.map((name) => path.join(globalIndexDir, name))
+		.find((candidate) => JSON.parse(fs.readFileSync(candidate, "utf-8")).missionId === missionId);
+	assert.ok(filePath, `missing index pointer for ${missionId}`);
+	return filePath;
+}
+
+describe("mission global projection", () => {
+	it("uses the updated record after the index rename fails, without rewriting the pointer", { timeout: 15_000 }, () => {
+		const harness = String.raw`
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { syncBuiltinESMExports } from "node:module";
+
+const [storeUrl] = process.argv.slice(1);
+const store = await import(storeUrl);
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-mission-global-projection-repro-"));
+const projectRoot = path.join(root, "project");
+const location = store.resolveMissionStoreLocation({
+	projectRoot,
+	agentDir: path.join(root, "agent"),
+	config: { directory: path.join(root, "missions"), globalIndexDir: path.join(root, "global-index") },
+});
+const pointerPathFor = (missionId) => fs.readdirSync(location.globalIndexDir)
+	.map((name) => path.join(location.globalIndexDir, name))
+	.find((file) => JSON.parse(fs.readFileSync(file, "utf-8")).missionId === missionId);
+const fields = (entry) => entry ? {
+	title: entry.title,
+	status: entry.status,
+	updatedAt: entry.updatedAt,
+	lastRunId: entry.lastRunId ?? entry.runs?.at(-1)?.runId,
+	stale: entry.stale,
+} : null;
+
+try {
+	fs.mkdirSync(projectRoot, { recursive: true });
+	const original = store.createMission(location, {
+		title: "Before partial commit",
+		objective: "Use authoritative record fields",
+		status: "planned",
+	}, new Date("2026-01-01T00:00:00.000Z"));
+	store.updateMission(location, original.id, {
+		addRuns: [{ runId: "run-old", mode: "single", status: "running" }],
+	}, new Date("2026-01-01T01:00:00.000Z"));
+	const control = store.createMission(location, {
+		title: "Healthy before",
+		objective: "Check normal writes",
+		status: "planned",
+	}, new Date("2026-01-02T00:00:00.000Z"));
+	const recordPath = store.missionRecordPath(location, original.id);
+	const indexPath = pointerPathFor(original.id);
+	const oldPointer = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+	const originalRenameSync = fs.renameSync;
+	let recordRenameCompleted = false;
+	let indexRenameAttempted = false;
+	let injectedIndexRenameFailure = false;
+	fs.renameSync = function (source, destination, ...args) {
+		const destinationPath = path.resolve(String(destination));
+		if (destinationPath === path.resolve(recordPath)) {
+			const result = originalRenameSync.call(this, source, destination, ...args);
+			recordRenameCompleted = true;
+			return result;
+		}
+		if (!indexRenameAttempted && path.dirname(destinationPath) === path.resolve(location.globalIndexDir)) {
+			indexRenameAttempted = true;
+			injectedIndexRenameFailure = true;
+			const error = new Error("Injected EIO at global mission index rename boundary");
+			Object.assign(error, { code: "EIO" });
+			throw error;
+		}
+		return originalRenameSync.call(this, source, destination, ...args);
+	};
+	syncBuiltinESMExports();
+	let updateError = null;
+	try {
+		store.updateMission(location, original.id, {
+			title: "After partial commit",
+			status: "completed",
+			addRuns: [{ runId: "run-new", mode: "single", status: "completed" }],
+		}, new Date("2026-01-03T00:00:00.000Z"));
+	} catch (error) {
+		updateError = { code: error?.code ?? null, message: String(error?.message ?? error) };
+	} finally {
+		fs.renameSync = originalRenameSync;
+		syncBuiltinESMExports();
+	}
+	const recordAfterFailure = store.readMission(location, original.id);
+	const firstList = store.listGlobalMissions(location.globalIndexDir);
+	const immediateProjection = firstList.entries.find((entry) => entry.missionId === original.id);
+	const pointerAfterFailure = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+	const healthyRecord = store.updateMission(location, control.id, {
+		title: "Healthy after",
+		status: "active",
+	}, new Date("2026-01-02T12:00:00.000Z"));
+	const healthyProjection = store.listGlobalMissions(location.globalIndexDir).entries.find((entry) => entry.missionId === control.id);
+	const laterList = store.listGlobalMissions(location.globalIndexDir);
+	process.stdout.write(JSON.stringify({
+		updateError,
+		renameBoundary: { recordRenameCompleted, indexRenameAttempted, injectedIndexRenameFailure },
+		record: fields(recordAfterFailure),
+		oldPointer,
+		pointerAfterFailure,
+		immediateProjection: fields(immediateProjection),
+		laterProjection: fields(laterList.entries.find((entry) => entry.missionId === original.id)),
+		order: laterList.entries.map((entry) => entry.missionId),
+		expectedOrder: [original.id, control.id],
+		healthyControlMatchesRecord: Boolean(healthyProjection)
+			&& healthyProjection.title === healthyRecord.title
+			&& healthyProjection.status === healthyRecord.status
+			&& healthyProjection.updatedAt === healthyRecord.updatedAt,
+	}));
+} finally {
+	fs.rmSync(root, { recursive: true, force: true });
+}
+`;
+		const storeUrl = pathToFileURL(path.resolve("src/missions/store.ts")).href;
+		const child = spawnSync(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", harness, storeUrl], {
+			cwd: process.cwd(),
+			encoding: "utf-8",
+			timeout: 10_000,
+		});
+		const observed = child.stdout?.trim() ? JSON.parse(child.stdout.trim()) as Record<string, any> : null;
+		assert.equal(child.status, 0, child.stderr || child.error?.message || "isolated mission projection harness produced no output");
+		assert.ok(observed, child.stderr || "isolated mission projection harness produced no JSON");
+		assert.equal(observed.updateError?.code, "EIO");
+		assert.deepEqual(observed.renameBoundary, { recordRenameCompleted: true, indexRenameAttempted: true, injectedIndexRenameFailure: true });
+		assert.deepEqual(observed.record, { title: "After partial commit", status: "completed", updatedAt: "2026-01-03T00:00:00.000Z", lastRunId: "run-new" });
+		assert.equal(observed.oldPointer.title, "Before partial commit");
+		assert.equal(observed.oldPointer.lastRunId, "run-old");
+		assert.deepEqual(observed.pointerAfterFailure, observed.oldPointer, "the list read must not rewrite the persisted pointer");
+		assert.deepEqual(observed.immediateProjection, { title: "After partial commit", status: "completed", updatedAt: "2026-01-03T00:00:00.000Z", lastRunId: "run-new", stale: false });
+		assert.deepEqual(observed.laterProjection, observed.immediateProjection);
+		assert.deepEqual(observed.order, observed.expectedOrder, "global list sorting uses the authoritative updatedAt");
+		assert.equal(observed.healthyControlMatchesRecord, true);
+	});
+
+	it("uses record timestamps for sorting and removes an index lastRunId when runs are empty", () => {
+		const test = fixture();
+		try {
+			const first = createMission(test.location, { title: "First pointer", objective: "Current record should sort first" }, new Date("2026-01-01T00:00:00.000Z"));
+			updateMission(test.location, first.id, { addRuns: [{ runId: "run-stale", mode: "single", status: "running" }] }, new Date("2026-01-01T01:00:00.000Z"));
+			const second = createMission(test.location, { title: "Second pointer", objective: "Current record should sort second" }, new Date("2026-01-02T00:00:00.000Z"));
+			const firstRecordPath = path.join(test.location.missionDir, `${first.id}.json`);
+			const secondRecordPath = path.join(test.location.missionDir, `${second.id}.json`);
+			const indexedFirst = listGlobalMissions(test.location.globalIndexDir).entries.find((entry) => entry.missionId === first.id);
+			assert.equal(indexedFirst?.lastRunId, "run-stale");
+
+			const firstRecord = readMission(test.location, first.id);
+			firstRecord.title = "First record is newest";
+			firstRecord.status = "completed";
+			firstRecord.updatedAt = "2026-01-04T00:00:00.000Z";
+			firstRecord.runs = [];
+			fs.writeFileSync(firstRecordPath, JSON.stringify(firstRecord, null, 2), "utf-8");
+			const secondRecord = readMission(test.location, second.id);
+			secondRecord.title = "Second record is older";
+			secondRecord.updatedAt = "2026-01-03T00:00:00.000Z";
+			fs.writeFileSync(secondRecordPath, JSON.stringify(secondRecord, null, 2), "utf-8");
+
+			const global = listGlobalMissions(test.location.globalIndexDir);
+			assert.deepEqual(global.entries.map((entry) => entry.missionId), [first.id, second.id]);
+			assert.equal(global.entries[0]?.title, "First record is newest");
+			assert.equal(global.entries[0]?.updatedAt, "2026-01-04T00:00:00.000Z");
+			assert.equal(Object.hasOwn(global.entries[0] ?? {}, "lastRunId"), false, "a stale pointer run id must not survive when the current record has no runs");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps mismatched and unreadable pointers on their existing paths", () => {
+		const test = fixture();
+		try {
+			const mismatch = createMission(test.location, { title: "Mismatched record", objective: "Keep its pointer stale" });
+			const mismatchPointerPath = indexPathFor(test.location.globalIndexDir, mismatch.id);
+			const mismatchPointer = JSON.parse(fs.readFileSync(mismatchPointerPath, "utf-8")) as Record<string, unknown>;
+			mismatchPointer.missionId = "wrong-record-id";
+			fs.writeFileSync(mismatchPointerPath, JSON.stringify(mismatchPointer), "utf-8");
+			const corruptPointerPath = path.join(test.location.globalIndexDir, "corrupt-pointer.json");
+			fs.writeFileSync(corruptPointerPath, "{not json", "utf-8");
+
+			const global = listGlobalMissions(test.location.globalIndexDir);
+			assert.deepEqual(global.entries.map((entry) => entry.missionId), ["wrong-record-id"]);
+			assert.match(global.entries.find((entry) => entry.missionId === "wrong-record-id")?.staleReason ?? "", /does not match index id/);
+			assert.match(global.warnings.join("\n"), /Skipped corrupt global mission index entry/);
+			assert.equal(fs.existsSync(corruptPointerPath), true, "an unreadable index pointer remains available for inspection");
+			assert.equal(fs.existsSync(mismatchPointerPath), true, "an ID-mismatched pointer remains marked stale rather than being rewritten");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -64,6 +64,70 @@ describe("goal mission continuation", () => {
 		}
 	});
 
+	for (const damaged of [
+		{ name: "malformed linked-run JSON", contents: "{not-json", file: "run" },
+		{ name: "null linked-run status", contents: "null", file: "run" },
+		{ name: "array linked-run status", contents: "[]", file: "run" },
+		{ name: "missing linked-run state", contents: "{}", file: "run" },
+		{ name: "malformed mission state", contents: "{not-json", file: "mission" },
+	]) {
+		it(`isolates ${damaged.name} without suppressing healthy goal notices`, () => {
+			const test = fixture();
+			try {
+				const broken = createMission(test.location, {
+					title: "Broken linked run",
+					objective: "Recover corrupt state",
+					goal: true,
+					budget: { tokens: 100 },
+					status: "active",
+					ownerSessionId: "session-1",
+				});
+				const brokenDir = path.join(test.root, "broken-run");
+				fs.mkdirSync(brokenDir);
+				fs.writeFileSync(path.join(brokenDir, "status.json"), damaged.file === "run" ? damaged.contents : JSON.stringify({ state: "complete" }), "utf-8");
+				updateMission(test.location, broken.id, {
+					addRuns: [{ runId: "broken-workflow", mode: "workflow", asyncDir: brokenDir, status: "running" }],
+				});
+				if (damaged.file === "mission") {
+					const statePath = missionStatePath(test.location, broken.id);
+					fs.mkdirSync(path.dirname(statePath), { recursive: true });
+					fs.writeFileSync(statePath, damaged.contents, "utf-8");
+				}
+
+				const healthy = createMission(test.location, {
+					title: "Healthy mission",
+					objective: "Continue healthy work",
+					goal: true,
+					budget: { tokens: 100 },
+					status: "active",
+					ownerSessionId: "session-1",
+				});
+				const errors: Array<{ missionId: string; error: unknown }> = [];
+				const notices = collectGoalContinuationNotices({
+					location: test.location,
+					ownerSessionId: "session-1",
+					retainedChildren: [],
+					turnId: 7,
+					now: 123,
+					onError: (missionId, error) => errors.push({ missionId, error }),
+				});
+
+				assert.equal(notices.length, 1);
+				assert.equal(notices[0]!.missionId, healthy.id);
+				assert.match(notices[0]!.message, /Next ready action: Continue objective: Continue healthy work/);
+				assert.equal(errors.length, 1);
+				assert.equal(errors[0]!.missionId, broken.id);
+				if (damaged.file === "run") {
+					assert.match(errors[0]!.error instanceof Error ? errors[0]!.error.message : String(errors[0]!.error), /status\.json/);
+				} else {
+					assert.ok(errors[0]!.error instanceof SyntaxError);
+				}
+			} finally {
+				fs.rmSync(test.root, { recursive: true, force: true });
+			}
+		});
+	}
+
 	it("resumes retained children from the latest linked run", () => {
 		const test = fixture();
 		try {
@@ -177,4 +241,4 @@ describe("goal mission continuation", () => {
 			fs.rmSync(test.root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -353,7 +353,8 @@ describe("mission store", () => {
 				});
 				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);
+					// On Windows each writer cold-starts Node and spawns powershell.exe for lock process identity, so 5s was too short under CI load.
+					const timeout = setTimeout(() => { child.kill(); reject(new Error(`${key} writer timed out`)); }, 20_000);
 					child.on("exit", (code, signal) => {
 						clearTimeout(timeout);
 						if (code === 0 && signal === null) resolve();

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

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../../src/runs/shared/model-resolution-diagnostic.ts";
+
+const CORE_MESSAGE = 'Model "pengepul/commandcode/deepseek/deepseek-v4.1-flash:max" not found. Use --list-models to see available models.';
+const CORE_PROVIDER_MESSAGE = 'Unknown provider "pengepul/commandcode". Use --list-models to see available providers/models.';
+
+describe("child model resolution diagnostic", () => {
+	it("matches core's model-resolution failure text and leaves other failures alone", () => {
+		assert.equal(isChildModelResolutionFailure(CORE_MESSAGE), true);
+		assert.equal(isChildModelResolutionFailure(`  ${CORE_PROVIDER_MESSAGE}  `), true);
+		assert.equal(isChildModelResolutionFailure('Model "openai/gpt-5" is temporarily unavailable (HTTP 503).'), false);
+		assert.equal(isChildModelResolutionFailure('Model "openai/gpt-5" is disabled for this account.'), false);
+		assert.equal(isChildModelResolutionFailure("Subagent session failed before its first turn."), false);
+		assert.equal(isChildModelResolutionFailure(""), false);
+		assert.equal(isChildModelResolutionFailure(undefined), false);
+	});
+
+	it("names the foreground provider-inheritance rule, the model, and the remedies", () => {
+		const text = formatChildModelResolutionDiagnostic({
+			agent: "provider-model-worker",
+			model: "pengepul/commandcode/deepseek/deepseek-v4.1-flash",
+			host: "parent",
+		});
+		assert.match(text, /Agent 'provider-model-worker' ran as a foreground child, which never loads the parent's ambient extensions but inherits the providers they registered/);
+		assert.match(text, /If 'pengepul\/commandcode\/deepseek\/deepseek-v4\.1-flash' is served by a provider extension, check the parent's `\/model` list and the child extension diagnostics/);
+		assert.doesNotMatch(text, /`async: true`/);
+		assert.match(text, /`subagentOnlyExtensions` or `extensions` in the agent frontmatter/);
+		assert.doesNotMatch(text, /background child without the ambient extensions/);
+		assert.doesNotMatch(text, /Capability ceiling/);
+	});
+
+	it("tells a foreground child that a capability ceiling denies the extension", () => {
+		const text = formatChildModelResolutionDiagnostic({
+			agent: "provider-model-worker",
+			model: "pengepul/commandcode/deepseek/deepseek-v4.1-flash",
+			host: "parent",
+			capabilityCeiling: { denyExtensions: true, sources: ["policy-fixture"] },
+		});
+		assert.match(text, /Capability ceiling from policy-fixture denies extensions/);
+		assert.match(text, /`async: true` does not help either/);
+		assert.match(text, /Relax the capability ceiling to allow extensions/);
+		assert.doesNotMatch(text, /must run as background children/);
+		assert.doesNotMatch(text, /load the provider extension explicitly/);
+	});
+
+	it("tells a background child that a capability ceiling denies the extension", () => {
+		const text = formatChildModelResolutionDiagnostic({
+			model: "pengepul/commandcode/deepseek/deepseek-v4.1-flash",
+			host: "runner",
+			capabilityCeiling: { denyExtensions: true },
+		});
+		assert.match(text, /^Subagent ran as a background child without the ambient extensions/);
+		assert.match(text, /Capability ceiling from an unnamed source denies extensions/);
+		assert.match(text, /does not enable ambient loading/);
+		assert.match(text, /Relax the capability ceiling to allow extensions/);
+		assert.doesNotMatch(text, /leave `extensions` unset so the child loads the ambient extensions/);
+	});
+
+	it("explains a background child launched without the ambient extensions", () => {
+		const text = formatChildModelResolutionDiagnostic({
+			model: "pengepul/commandcode/deepseek/deepseek-v4.1-flash",
+			host: "runner",
+		});
+		assert.match(text, /^Subagent ran as a background child without the ambient extensions/);
+		assert.match(text, /that extension is not loaded for this child: list it in `subagentOnlyExtensions` or `extensions` in the agent frontmatter/);
+		assert.match(text, /leave `extensions` unset/);
+		assert.doesNotMatch(text, /foreground child/);
+		assert.doesNotMatch(text, /Capability ceiling/);
+	});
+
+	it("defaults to the background branch and tolerates a missing model", () => {
+		const text = formatChildModelResolutionDiagnostic({});
+		assert.match(text, /^Subagent ran as a background child without the ambient extensions/);
+		assert.match(text, /If this model is served by a provider extension/);
+		assert.doesNotMatch(text, /Capability ceiling/);
+	});
+});

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

@@ -0,0 +1,153 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	formatSubagentModelVerificationError,
+	fuzzyResolveModel,
+	isContextOverflow,
+	normalizeModelSegment,
+	normalizeParentModel,
+	resolveEffectiveSubagentModel,
+	resolveModelCandidate,
+	resolveModelSelection,
+	resolveSubagentModelOverride,
+} from "../../src/runs/shared/model-resolution.ts";
+import { resolveModelScopesForAgent } from "../../src/runs/shared/model-scope.ts";
+
+const models = [
+	{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+	{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+	{ provider: "openai", id: "shared", fullId: "openai/shared" },
+	{ provider: "anthropic", id: "shared", fullId: "anthropic/shared" },
+	{ provider: "huggingface", id: "org/model-v1", fullId: "huggingface/org/model-v1" },
+];
+
+describe("single model resolution", () => {
+	it("resolves exactly one configured model and preserves thinking suffixes", () => {
+		assert.deepEqual(resolveModelSelection("gpt-5-mini", models), {
+			model: "openai/gpt-5-mini",
+			requestedModel: "gpt-5-mini",
+		});
+		assert.equal(resolveModelCandidate("gpt-5-mini:high", models), "openai/gpt-5-mini:high");
+	});
+
+	it("inherits the current parent model for omitted, false, empty, and inherit values", () => {
+		const parent = normalizeParentModel({ provider: "anthropic", id: "claude-sonnet-4" });
+		for (const requested of [undefined, false, "", "  ", "inherit", " inherit "] as const) {
+			assert.equal(resolveSubagentModelOverride(requested, parent, models), "anthropic/claude-sonnet-4");
+		}
+		assert.equal(resolveEffectiveSubagentModel(undefined, undefined, parent, models), "anthropic/claude-sonnet-4");
+		assert.equal(resolveSubagentModelOverride("inherit", undefined, models), undefined);
+	});
+
+	it("resolves explicit models against the registry instead of the parent", () => {
+		const parent = { provider: "anthropic", id: "claude-sonnet-4" };
+		assert.equal(resolveSubagentModelOverride("gpt-5-mini", parent, models, undefined, { source: "explicit" }), "openai/gpt-5-mini");
+		assert.equal(resolveSubagentModelOverride("openai/gpt-5-mini", parent, models, undefined, { source: "explicit" }), "openai/gpt-5-mini");
+	});
+
+	it("uses provider preference for ambiguous bare and owner/name ids", () => {
+		assert.equal(resolveModelCandidate("shared", models), "shared");
+		assert.equal(resolveModelCandidate("shared", models, "anthropic"), "anthropic/shared");
+		assert.equal(resolveModelCandidate("org/model-v1", models), "huggingface/org/model-v1");
+	});
+
+	it("rejects unknown explicit/configured models and suggests a unique alternate provider", () => {
+		assert.throws(
+			() => resolveSubagentModelOverride("openai/claude-sonnet-4", undefined, models, undefined, { source: "explicit" }),
+			/Unknown subagent model 'openai\/claude-sonnet-4'.*Did you mean 'anthropic\/claude-sonnet-4'/,
+		);
+		assert.throws(() => resolveModelSelection("missing", models), /Unknown subagent model 'missing'/);
+		assert.equal(resolveEffectiveSubagentModel("missing", "gpt-5-mini", undefined, models, undefined, { source: "inherited" }), "missing");
+	});
+
+	it("normalizes registry spelling without switching a qualified provider", () => {
+		assert.equal(normalizeModelSegment("GPT_5--MINI"), "gpt-5-mini");
+		assert.equal(fuzzyResolveModel("GPT_5_MINI", models), "openai/gpt-5-mini");
+		assert.equal(resolveModelCandidate("openai/claude-sonnet-4", models), "openai/claude-sonnet-4");
+	});
+
+	it("resolves ids that already carry their provider prefix within that provider", () => {
+		const registry = [
+			{ provider: "openrouter", id: "openrouter/auto-beta", fullId: "openrouter/openrouter/auto-beta" },
+			{ provider: "openrouter", id: "auto", fullId: "openrouter/auto" },
+			{ provider: "other", id: "openrouter/free", fullId: "other/openrouter/free" },
+		];
+		assert.equal(resolveModelSelection("openrouter/auto-beta", registry).model, "openrouter/openrouter/auto-beta");
+		assert.equal(resolveModelSelection("OpenRouter/Auto_Beta", registry).model, "openrouter/openrouter/auto-beta");
+		assert.equal(resolveModelSelection("openrouter/auto", registry).model, "openrouter/auto");
+		assert.throws(() => resolveModelSelection("openrouter/free", registry), /Unknown subagent model 'openrouter\/free'/);
+		// An ordinary id that already resolved keeps winning over a provider-prefixed one.
+		const collision = [...registry, { provider: "openrouter", id: "auto_beta", fullId: "openrouter/auto_beta" }];
+		assert.equal(resolveModelSelection("OpenRouter/Auto-Beta", collision).model, "openrouter/auto_beta");
+	});
+
+	it("fuzzy matches case, separators, dates, and owner/name ids", () => {
+		const registry = [
+			{ provider: "openai", id: "GPT_5.Mini-2025-10-01", fullId: "openai/GPT_5.Mini-2025-10-01" },
+			{ provider: "huggingface", id: "Org/Model_One", fullId: "huggingface/Org/Model_One" },
+		];
+		assert.equal(fuzzyResolveModel("gpt-5-mini", registry), "openai/GPT_5.Mini-2025-10-01");
+		assert.equal(fuzzyResolveModel("openai/gpt-5-mini-20251001", registry), "openai/GPT_5.Mini-2025-10-01");
+		assert.equal(fuzzyResolveModel("org/model-one", registry), "huggingface/Org/Model_One");
+		assert.equal(fuzzyResolveModel("missing", registry), undefined);
+	});
+
+	it("enforces explicit and strict scopes while warning for inherited violations", () => {
+		const scope = resolveModelScopesForAgent({ allow: ["anthropic/*"], enforce: true }, "worker", undefined);
+		assert.throws(() => resolveModelSelection("openai/gpt-5-mini", models, undefined, { scope, origin: "explicit" }), /outside the configured subagent model scope/);
+		const warnings: string[] = [];
+		assert.equal(resolveSubagentModelOverride("openai/gpt-5-mini", undefined, models, undefined, {
+			scope,
+			source: "inherited",
+			onWarn: (violation) => warnings.push(violation.message),
+		}), "openai/gpt-5-mini");
+		assert.equal(warnings.length, 1);
+		const strict = resolveModelScopesForAgent({ allow: ["anthropic/*"], enforce: true, strict: true }, "worker", undefined);
+		assert.throws(() => resolveModelSelection("openai/gpt-5-mini", models, undefined, { scope: strict, origin: "inherited" }), /outside the configured subagent model scope/);
+	});
+
+	it("fails closed when enforced inherit has no parent model", () => {
+		const scope = resolveModelScopesForAgent({ allow: ["inherit"], enforce: true }, "worker", undefined);
+		assert.throws(() => resolveModelSelection(undefined, models, undefined, { scope }), /'inherit' requires a current parent session model/);
+	});
+});
+
+describe("model response identity", () => {
+	it("accepts exact, bare, leaf, and declared alias response ids", () => {
+		assert.equal(formatSubagentModelVerificationError("openai/gpt-5-mini:high", "gpt-5-mini", models), undefined);
+		assert.equal(formatSubagentModelVerificationError("huggingface/org/model-v1", "model-v1", models), undefined);
+		assert.equal(formatSubagentModelVerificationError("openai/gpt-5-mini", "gateway-model", models, {
+			"openai/gpt-5-mini": ["gateway-model"],
+		}), undefined);
+	});
+
+	it("rejects a different response route and does not apply another model's alias", () => {
+		assert.match(formatSubagentModelVerificationError("openai/gpt-5-mini", "anthropic/claude-sonnet-4", models) ?? "", /model_verification_failed/);
+		assert.match(formatSubagentModelVerificationError("openai/gpt-5-mini", "gateway-model", models, {
+			"anthropic/claude-sonnet-4": ["gateway-model"],
+		}) ?? "", /model_verification_failed/);
+	});
+
+	it("verifies a virtual-model child against its exact selection, not the dispatched model", () => {
+		assert.equal(formatSubagentModelVerificationError("openai/gpt-5-mini:high", "anthropic/claude-sonnet-4", models, undefined, "openai/gpt-5-mini"), undefined);
+		const virtualMismatch = formatSubagentModelVerificationError("openai/gpt-5-mini", "gpt-5-mini", models, undefined, "other-router/gpt-5-mini") ?? "";
+		assert.match(virtualMismatch, /model_verification_failed: native Pi child selected virtual model 'other-router\/gpt-5-mini'/);
+		assert.doesNotMatch(virtualMismatch, /declare the exact mapping/);
+		assert.match(formatSubagentModelVerificationError("openai/gpt-5-mini", "gpt-5-mini", models, undefined, "gpt-5-mini") ?? "", /model_verification_failed/);
+		assert.match(formatSubagentModelVerificationError("openai/gpt-5-mini", "anthropic/claude-sonnet-4", models) ?? "", /model_verification_failed/);
+	});
+});
+
+describe("context overflow classification", () => {
+	it("detects common context overflow errors", () => {
+		for (const error of ["maximum context length exceeded", "context window overflow", "too many tokens", "context_length_exceeded", "input too long"]) {
+			assert.equal(isContextOverflow(error), true, error);
+		}
+	});
+
+	it("does not classify tool failures, provider failures, or empty input as overflow", () => {
+		assert.equal(isContextOverflow("bash failed (exit 1): input too long"), false);
+		assert.equal(isContextOverflow("429 rate limit exceeded"), false);
+		assert.equal(isContextOverflow(undefined), false);
+	});
+});

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

@@ -131,6 +131,48 @@ describe("resolveModelScopesForAgent", () => {
 	});
 });
 
+describe("expandReservedPatterns via resolveModelScopesForAgent", () => {
+	const parent = { provider: "anthropic", id: "claude-sonnet-4" };
+	const scopedIds = ["anthropic/claude-sonnet-4", "openai/gpt-5-mini"];
+
+	it("expands scoped to the full scoped-model snapshot", () => {
+		const [scope] = resolveModelScopesForAgent({ enforce: true, allow: ["scoped"] }, "worker", parent, scopedIds);
+		assert.deepEqual(scope.allow, scopedIds);
+	});
+
+	it("does not expand other patterns alongside scoped", () => {
+		const [scope] = resolveModelScopesForAgent({ enforce: true, allow: ["scoped", "anthropic/*"] }, "worker", parent, scopedIds);
+		assert.deepEqual(scope.allow, [...scopedIds, "anthropic/*"]);
+	});
+
+	it("expands scoped per agent scope", () => {
+		const [agent] = resolveModelScopesForAgent({ enforce: true, agents: { reviewer: { allow: ["scoped"] } } }, "reviewer", parent, scopedIds);
+		assert.deepEqual(agent.allow, scopedIds);
+	});
+
+	it("degrades scoped to the parent model when the snapshot is empty", () => {
+		const [empty] = resolveModelScopesForAgent({ enforce: true, allow: ["scoped"] }, "worker", parent, []);
+		const [missing] = resolveModelScopesForAgent({ enforce: true, allow: ["scoped"] }, "worker", parent, undefined);
+		assert.deepEqual(empty.allow, ["anthropic/claude-sonnet-4"]);
+		assert.deepEqual(missing.allow, ["anthropic/claude-sonnet-4"]);
+	});
+
+	it("keeps scoped literal when neither snapshot nor parent exists so enforcement fails closed", () => {
+		const [scope] = resolveModelScopesForAgent({ enforce: true, allow: ["scoped"] }, "worker", undefined, undefined);
+		const violation = checkModelScope("openai/gpt-5-mini", scope, "explicit");
+		assert.equal(violation?.severity, "error");
+		assert.deepEqual(violation?.allowedPatterns, ["scoped"]);
+	});
+
+	it("summarizes the rendered pattern list for large scoped sets", () => {
+		const manyIds = Array.from({ length: 12 }, (_, i) => `prov/model-${i}`);
+		const [scope] = resolveModelScopesForAgent({ enforce: true, allow: ["scoped"] }, "worker", undefined, manyIds);
+		const violation = checkModelScope("other/model", scope, "explicit");
+		assert.match(violation?.message ?? "", /prov\/model-7, … \(12 patterns total\)/);
+		assert.deepEqual(violation?.allowedPatterns, manyIds);
+	});
+});
+
 describe("parseModelScopeConfig", () => {
 	const meta = { filePath: "~/.selesai/agent/settings.json" };
 
@@ -195,4 +237,4 @@ describe("parseModelScopeConfig", () => {
 		assert.throws(() => parseModelScopeConfig({ agents: { worker: { agents: {} } } }, meta), /modelScope\.agents\.worker\.agents/);
 		assert.throws(() => parseModelScopeConfig({ agents: { " ": { allow: ["inherit"] } } }, meta), /non-empty agent name/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/mutation-evidence.test.ts

@@ -5,7 +5,6 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../../src/runs/shared/mutation-evidence.ts";
-import { evaluateCompletionMutationGuard } from "../../src/runs/shared/completion-guard.ts";
 
 function git(cwd: string, args: string[]): void {
 	execFileSync("git", args, { cwd, stdio: "ignore" });
@@ -109,25 +108,6 @@ describe("tracked mutation evidence", () => {
 		});
 	});
 
-	it("uses tracked evidence as completion guard mutation proof", () => {
-		const guard = evaluateCompletionMutationGuard({
-			agent: "worker",
-			task: "Implement the requested fix.",
-			messages: [{ role: "assistant", content: [{ type: "text", text: "Implemented." }] }],
-			tools: ["edit"],
-			mutationEvidence: {
-				source: "tracked-files",
-				trackedOnly: true,
-				changedFiles: ["tracked.txt"],
-				attemptedMutation: true,
-			},
-		});
-
-		assert.equal(guard.expectedMutation, true);
-		assert.equal(guard.attemptedMutation, true);
-		assert.equal(guard.triggered, false);
-	});
-
 	it("formats bounded timeout recovery data", () => {
 		const summary = buildTimeoutRecoverySummary({
 			termination: "timed-out",
@@ -174,4 +154,4 @@ describe("tracked mutation evidence", () => {
 		assert.match(summary.message, /review (?:the )?diff and artifacts before resuming/i);
 		assert.match(summary.message, /dependent stages/i);
 	});
-});
+});