@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/live-async-resume.test.ts

@@ -0,0 +1,170 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import {
+	ASYNC_RESUME_INTERRUPT_SIGNAL,
+	interruptLiveAsyncResumeTarget,
+	resolveAsyncResumeTarget,
+} from "../../src/runs/background/async-resume.ts";
+
+function writeJson(filePath: string, value: object): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+describe("live async resume interrupt", () => {
+	it("interrupts a resolved live async child before the caller sends a follow-up", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-live-async-resume-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			const asyncDir = path.join(asyncRoot, "run-live");
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-live",
+				mode: "single",
+				state: "running",
+				pid: process.pid,
+				cwd: root,
+				startedAt: 100,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+			});
+			const target = resolveAsyncResumeTarget({ id: "run-live" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(target.kind, "live");
+
+			const kills: Array<{ pid: number; signal?: NodeJS.Signals | 0 }> = [];
+			const state = {
+				asyncJobs: new Map([["run-live", {
+					asyncId: "run-live",
+					asyncDir,
+					status: "running" as const,
+					pid: process.pid,
+					activityState: "needs_attention" as const,
+					updatedAt: 100,
+				}]]),
+			};
+
+			const result = interruptLiveAsyncResumeTarget({
+				target,
+				state,
+				now: () => 1234,
+				resultsDir,
+				kill: (pid, signal) => {
+					kills.push({ pid, signal });
+					return true;
+				},
+			});
+
+			assert.deepEqual(result, { ok: true, asyncId: "run-live" });
+			assert.deepEqual(kills, [{ pid: process.pid, signal: 0 }, { pid: process.pid, signal: ASYNC_RESUME_INTERRUPT_SIGNAL }]);
+			assert.equal(state.asyncJobs.get("run-live")?.activityState, undefined);
+			assert.equal(state.asyncJobs.get("run-live")?.updatedAt, 1234);
+			// The portable control request is dropped regardless of the signal path.
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("still interrupts a live async child when the OS signal is unavailable (ENOSYS on Windows)", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-live-async-resume-enosys-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			const asyncDir = path.join(asyncRoot, "run-live");
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-live",
+				mode: "single",
+				state: "running",
+				pid: process.pid,
+				cwd: root,
+				startedAt: 100,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+			});
+			const target = resolveAsyncResumeTarget({ id: "run-live" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(target.kind, "live");
+
+			const state = {
+				asyncJobs: new Map([["run-live", {
+					asyncId: "run-live",
+					asyncDir,
+					status: "running" as const,
+					pid: process.pid,
+					activityState: "needs_attention" as const,
+					updatedAt: 100,
+				}]]),
+			};
+
+			const result = interruptLiveAsyncResumeTarget({
+				target,
+				state,
+				now: () => 7,
+				resultsDir,
+				kill: () => {
+					const error = new Error("kill ENOSYS") as NodeJS.ErrnoException;
+					error.code = "ENOSYS";
+					throw error;
+				},
+			});
+
+			// The signal failed, but the file-based control inbox makes the interrupt succeed.
+			assert.deepEqual(result, { ok: true, asyncId: "run-live" });
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), true);
+			assert.equal(state.asyncJobs.get("run-live")?.activityState, undefined);
+			assert.equal(state.asyncJobs.get("run-live")?.updatedAt, 7);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not report success or leave a stale request when the runner pid is gone", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-live-async-resume-esrch-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			const asyncDir = path.join(asyncRoot, "run-live");
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-live",
+				mode: "single",
+				state: "running",
+				pid: 12345,
+				cwd: root,
+				startedAt: 100,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+			});
+			const target = resolveAsyncResumeTarget({ id: "run-live" }, {
+				asyncDirRoot: asyncRoot,
+				resultsDir,
+				kill: (_pid, signal) => {
+					if (signal === 0) return true;
+					const error = new Error("missing process") as NodeJS.ErrnoException;
+					error.code = "ESRCH";
+					throw error;
+				},
+			});
+			assert.equal(target.kind, "live");
+
+			const result = interruptLiveAsyncResumeTarget({
+				target,
+				resultsDir,
+				kill: () => {
+					const error = new Error("missing process") as NodeJS.ErrnoException;
+					error.code = "ESRCH";
+					throw error;
+				},
+			});
+
+			assert.deepEqual(result, { ok: false, message: "Async run run-live is live but no interrupt-capable runner pid was found." });
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), false);
+			const repairedStatus = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+			assert.equal(repairedStatus.state, "failed");
+			assert.equal(fs.existsSync(path.join(resultsDir, "run-live.json")), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -0,0 +1,346 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	buildModelCandidates,
+	fuzzyResolveModel,
+	isRetryableModelFailure,
+	normalizeModelSegment,
+	resolveModelCandidate,
+	resolveSubagentModelOverride,
+} from "../../src/runs/shared/model-fallback.ts";
+
+describe("model fallback helpers", () => {
+	const availableModels = [
+		{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+		{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+	];
+
+	it("keeps explicit provider/model ids unchanged", () => {
+		assert.equal(resolveModelCandidate("openai/gpt-5-mini", availableModels), "openai/gpt-5-mini");
+	});
+
+	it("resolves a bare id when there is exactly one registry match", () => {
+		assert.equal(resolveModelCandidate("gpt-5-mini", availableModels), "openai/gpt-5-mini");
+	});
+
+	it("preserves thinking suffix when resolving a bare id", () => {
+		assert.equal(resolveModelCandidate("gpt-5-mini:high", availableModels), "openai/gpt-5-mini:high");
+	});
+
+	it("leaves ambiguous bare ids untouched", () => {
+		const ambiguous = [
+			...availableModels,
+			{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini" },
+		];
+		assert.equal(resolveModelCandidate("gpt-5-mini", ambiguous), "gpt-5-mini");
+	});
+
+	it("prefers the current provider when an ambiguous bare id exists there", () => {
+		const ambiguous = [
+			...availableModels,
+			{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini" },
+		];
+		assert.equal(resolveModelCandidate("gpt-5-mini", ambiguous, "github-copilot"), "github-copilot/gpt-5-mini");
+	});
+
+	it("falls back to the unique registry match when the current provider does not offer the model", () => {
+		assert.equal(resolveModelCandidate("claude-sonnet-4", availableModels, "github-copilot"), "anthropic/claude-sonnet-4");
+	});
+
+	it("builds a deduplicated ordered candidate list", () => {
+		assert.deepEqual(
+			buildModelCandidates("gpt-5-mini", ["openai/gpt-5-mini", "anthropic/claude-sonnet-4", "gpt-5-mini"], availableModels),
+			["openai/gpt-5-mini", "anthropic/claude-sonnet-4"],
+		);
+	});
+
+	it("applies the current provider preference to fallback candidates too", () => {
+		const ambiguous = [
+			...availableModels,
+			{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini" },
+		];
+		assert.deepEqual(
+			buildModelCandidates("gpt-5-mini", ["gpt-5-mini", "anthropic/claude-sonnet-4"], ambiguous, "github-copilot"),
+			["github-copilot/gpt-5-mini", "anthropic/claude-sonnet-4"],
+		);
+	});
+
+	it("detects retryable provider/model failures", () => {
+		assert.equal(isRetryableModelFailure("rate limit exceeded for provider"), true);
+		assert.equal(isRetryableModelFailure("model unavailable"), true);
+		assert.equal(isRetryableModelFailure("authentication failed"), true);
+		assert.equal(isRetryableModelFailure("Subagent produced no output (possible model cold-start or empty response)."), true);
+		assert.equal(isRetryableModelFailure("model load failed"), true);
+	});
+
+	it("does not treat ordinary task/tool failures as retryable model failures", () => {
+		assert.equal(isRetryableModelFailure("bash failed (exit 1): command not found"), false);
+		assert.equal(isRetryableModelFailure("read failed (exit 1): no such file or directory"), false);
+		assert.equal(isRetryableModelFailure(undefined), false);
+	});
+});
+
+describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", () => {
+	const availableModels = [
+		{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+		{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+	];
+	const parentModel = { provider: "deepseek", id: "deepseek-v4-flash" };
+
+	it("inherits the parent session model when no model is requested", () => {
+		// The crux of the bug: an undefined model must NOT collapse to `undefined`
+		// (which leaves the child to read the shared global settings.json), but
+		// must pin the parent session's in-memory provider/id.
+		assert.equal(
+			resolveSubagentModelOverride(undefined, parentModel, availableModels),
+			"deepseek/deepseek-v4-flash",
+		);
+	});
+
+	it("inherits the parent session model when the model is the \"inherit\" sentinel", () => {
+		assert.equal(
+			resolveSubagentModelOverride("inherit", parentModel, availableModels),
+			"deepseek/deepseek-v4-flash",
+		);
+	});
+
+	it("inherits the parent session model when the agent config sets model: false (delegate)", () => {
+		assert.equal(
+			resolveSubagentModelOverride(false, parentModel, availableModels),
+			"deepseek/deepseek-v4-flash",
+		);
+	});
+
+	it("treats an empty or whitespace-only model as inherit", () => {
+		assert.equal(resolveSubagentModelOverride("", parentModel, availableModels), "deepseek/deepseek-v4-flash");
+		assert.equal(resolveSubagentModelOverride("   ", parentModel, availableModels), "deepseek/deepseek-v4-flash");
+	});
+
+	it("trims surrounding whitespace from the \"inherit\" sentinel", () => {
+		assert.equal(resolveSubagentModelOverride("  inherit  ", parentModel, availableModels), "deepseek/deepseek-v4-flash");
+	});
+
+	it("keeps an explicit provider/id model unchanged", () => {
+		assert.equal(
+			resolveSubagentModelOverride("anthropic/claude-sonnet-4", parentModel, availableModels),
+			"anthropic/claude-sonnet-4",
+		);
+	});
+
+	it("resolves an explicit bare id against the registry, not the parent", () => {
+		assert.equal(
+			resolveSubagentModelOverride("gpt-5-mini", parentModel, availableModels),
+			"openai/gpt-5-mini",
+		);
+	});
+
+	it("returns undefined when inheriting but no parent model is known", () => {
+		// No parent session model available: fall back to the prior behavior of
+		// emitting no override rather than inventing an invalid one.
+		assert.equal(resolveSubagentModelOverride(undefined, undefined, availableModels), undefined);
+		assert.equal(resolveSubagentModelOverride("inherit", undefined, availableModels), undefined);
+		assert.equal(resolveSubagentModelOverride(false, undefined, availableModels), undefined);
+	});
+
+	it("never emits the literal \"inherit\" string as a model", () => {
+		// Regression guard: the old resolveModelCandidate returned "inherit" verbatim
+		// (no registry match), which the child rejected and silently fell back to
+		// the global default.
+		assert.notEqual(resolveSubagentModelOverride("inherit", parentModel, availableModels), "inherit");
+		assert.notEqual(resolveSubagentModelOverride("inherit", undefined, availableModels), "inherit");
+	});
+});
+
+describe("fuzzyResolveModel / normalizeModelSegment", () => {
+	const registry = [
+		{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+		{ provider: "anthropic", id: "claude-haiku-4-5", fullId: "anthropic/claude-haiku-4-5" },
+		{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+		{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini" },
+	];
+
+	it("normalizes dots, underscores, case, and repeated dashes", () => {
+		assert.equal(normalizeModelSegment("Claude.Sonnet_4"), "claude-sonnet-4");
+		assert.equal(normalizeModelSegment("GPT--5.Mini"), "gpt-5-mini");
+	});
+
+	it("fuzzy-matches a bare id with separator/case differences", () => {
+		assert.equal(fuzzyResolveModel("Claude-Sonnet-4", registry), "anthropic/claude-sonnet-4");
+		assert.equal(fuzzyResolveModel("claude.haiku.4.5", registry), "anthropic/claude-haiku-4-5");
+	});
+
+	it("fuzzy-matches a bare id with an optional trailing date stamp", () => {
+		assert.equal(fuzzyResolveModel("claude-haiku-4-5-20251001", registry), "anthropic/claude-haiku-4-5");
+		assert.equal(fuzzyResolveModel("claude-haiku-4-5-2025-10-01", registry), "anthropic/claude-haiku-4-5");
+	});
+
+	it("does not strip arbitrary trailing 8-digit numbers as date stamps", () => {
+		const numbered = [{ provider: "test", id: "model", fullId: "test/model" }];
+		assert.equal(fuzzyResolveModel("model-12345678", numbered), undefined);
+	});
+
+	it("fuzzy-matches an undated query against a dated registry id", () => {
+		const dated = [
+			{ provider: "anthropic", id: "claude-3-5-sonnet-20241022", fullId: "anthropic/claude-3-5-sonnet-20241022" },
+			{ provider: "openai", id: "gpt-5-2025-10-01", fullId: "openai/gpt-5-2025-10-01" },
+		];
+		assert.equal(fuzzyResolveModel("claude-3-5-sonnet", dated), "anthropic/claude-3-5-sonnet-20241022");
+		assert.equal(fuzzyResolveModel("gpt-5", dated), "openai/gpt-5-2025-10-01");
+	});
+
+	it("fuzzy-matches a qualified provider/id with case/separator differences", () => {
+		assert.equal(fuzzyResolveModel("Anthropic/Claude-Sonnet-4", registry), "anthropic/claude-sonnet-4");
+		assert.equal(fuzzyResolveModel("Anthropic:Claude-Sonnet-4", registry), "anthropic/claude-sonnet-4");
+		assert.equal(fuzzyResolveModel("anthropic.claude.haiku.4.5", registry), "anthropic/claude-haiku-4-5");
+		assert.equal(fuzzyResolveModel("anthropic/claude.haiku.4.5", registry), "anthropic/claude-haiku-4-5");
+	});
+
+	it("does not switch providers for a qualified query", () => {
+		// Named provider has no such model; do not fall back to another provider.
+		assert.equal(fuzzyResolveModel("openai/claude-sonnet-4", registry), undefined);
+		assert.equal(fuzzyResolveModel("github-copilot/claude-haiku-4-5", registry), undefined);
+	});
+
+	it("prefers the current provider for an ambiguous bare fuzzy id", () => {
+		assert.equal(fuzzyResolveModel("GPT.5.Mini", registry, "github-copilot"), "github-copilot/gpt-5-mini");
+	});
+
+	it("returns undefined for an ambiguous bare fuzzy id with no preferred provider", () => {
+		assert.equal(fuzzyResolveModel("gpt-5-mini", registry), undefined);
+	});
+
+	it("returns undefined when nothing fuzzy-matches", () => {
+		assert.equal(fuzzyResolveModel("does-not-exist", registry), undefined);
+		assert.equal(fuzzyResolveModel("anthropic/does-not-exist", registry), undefined);
+	});
+});
+
+describe("resolveModelCandidate fuzzy fallback", () => {
+	const registry = [
+		{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+		{ provider: "anthropic", id: "claude-haiku-4-5", fullId: "anthropic/claude-haiku-4-5" },
+	];
+
+	it("resolves a bare id with case/separator differences via fuzzy fallback", () => {
+		assert.equal(resolveModelCandidate("Claude-Sonnet-4", registry), "anthropic/claude-sonnet-4");
+		assert.equal(resolveModelCandidate("claude.haiku.4.5", registry), "anthropic/claude-haiku-4-5");
+	});
+
+	it("resolves a bare id with a trailing date stamp via fuzzy fallback", () => {
+		assert.equal(resolveModelCandidate("claude-haiku-4-5-20251001", registry), "anthropic/claude-haiku-4-5");
+	});
+
+	it("resolves a qualified provider/id with case differences via fuzzy fallback", () => {
+		assert.equal(resolveModelCandidate("Anthropic/Claude-Sonnet-4", registry), "anthropic/claude-sonnet-4");
+		assert.equal(resolveModelCandidate("Anthropic:Claude-Sonnet-4", registry), "anthropic/claude-sonnet-4");
+	});
+
+	it("preserves the thinking suffix through fuzzy resolution", () => {
+		assert.equal(resolveModelCandidate("claude.haiku.4.5:high", registry), "anthropic/claude-haiku-4-5:high");
+		assert.equal(resolveModelCandidate("anthropic:claude.sonnet.4:high", registry), "anthropic/claude-sonnet-4:high");
+	});
+
+	it("still prefers exact registry matches over fuzzy", () => {
+		assert.equal(resolveModelCandidate("anthropic/claude-sonnet-4", registry), "anthropic/claude-sonnet-4");
+	});
+
+	it("leaves an unknown qualified model unchanged instead of switching providers", () => {
+		assert.equal(resolveModelCandidate("openai/claude-sonnet-4", registry), "openai/claude-sonnet-4");
+	});
+
+	it("leaves an unknown bare id unchanged when no fuzzy match exists", () => {
+		assert.equal(resolveModelCandidate("does-not-exist", registry), "does-not-exist");
+	});
+});
+
+describe("resolveSubagentModelOverride scope enforcement", () => {
+	const availableModels = [
+		{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+		{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+		{ provider: "deepseek", id: "deepseek-v4", fullId: "deepseek/deepseek-v4" },
+	];
+	const parentModel = { provider: "deepseek", id: "deepseek-v4" };
+	const scope = { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] } as const;
+
+	it("is a no-op when scope is not enforced", () => {
+		assert.equal(
+			resolveSubagentModelOverride("deepseek/deepseek-v4", parentModel, availableModels, undefined, { scope: { enforce: false, allow: ["anthropic/*"] }, source: "explicit" }),
+			"deepseek/deepseek-v4",
+		);
+	});
+
+	it("throws for an explicit out-of-scope model", () => {
+		assert.throws(
+			() => resolveSubagentModelOverride("deepseek/deepseek-v4", parentModel, availableModels, undefined, { scope, source: "explicit" }),
+			/outside the configured subagent model scope/,
+		);
+	});
+
+	it("warns (and still returns the model) for an inherited out-of-scope model", () => {
+		const warnings: string[] = [];
+		const resolved = resolveSubagentModelOverride("deepseek/deepseek-v4", parentModel, availableModels, undefined, {
+			scope,
+			source: "inherited",
+			onWarn: (v) => warnings.push(v.message),
+		});
+		assert.equal(resolved, "deepseek/deepseek-v4");
+		assert.equal(warnings.length, 1);
+		assert.match(warnings[0]!, /outside the configured subagent model scope/);
+	});
+
+	it("warns for an inherited parent-session model that is out of scope", () => {
+		const warnings: string[] = [];
+		// No explicit model requested: inherits the parent (deepseek), which is out of scope.
+		const resolved = resolveSubagentModelOverride(undefined, parentModel, availableModels, undefined, {
+			scope,
+			onWarn: (v) => warnings.push(v.message),
+		});
+		assert.equal(resolved, "deepseek/deepseek-v4");
+		assert.equal(warnings.length, 1);
+	});
+
+	it("passes through an in-scope explicit model without warning or error", () => {
+		const warnings: string[] = [];
+		const resolved = resolveSubagentModelOverride("gpt-5-mini", parentModel, availableModels, undefined, {
+			scope,
+			source: "explicit",
+			onWarn: (v) => warnings.push(v.message),
+		});
+		assert.equal(resolved, "openai/gpt-5-mini");
+		assert.equal(warnings.length, 0);
+	});
+
+	it("checks the resolved (canonicalized) model against the scope", () => {
+		// Fuzzy-resolves Claude-Sonnet-4 -> anthropic/claude-sonnet-4, which is in scope.
+		const warnings: string[] = [];
+		const resolved = resolveSubagentModelOverride("Claude-Sonnet-4", parentModel, availableModels, undefined, {
+			scope,
+			source: "explicit",
+			onWarn: (v) => warnings.push(v.message),
+		});
+		assert.equal(resolved, "anthropic/claude-sonnet-4");
+		assert.equal(warnings.length, 0);
+	});
+
+	it("ignores a thinking suffix when checking scope", () => {
+		const warnings: string[] = [];
+		const resolved = resolveSubagentModelOverride("gpt-5-mini:high", parentModel, availableModels, undefined, {
+			scope,
+			source: "explicit",
+			onWarn: (v) => warnings.push(v.message),
+		});
+		assert.equal(resolved, "openai/gpt-5-mini:high");
+		assert.equal(warnings.length, 0);
+	});
+
+	it("warns for out-of-scope fallback models while keeping them available", () => {
+		const warnings: string[] = [];
+		const candidates = buildModelCandidates("gpt-5-mini", ["deepseek/deepseek-v4"], availableModels, undefined, {
+			scope,
+			onWarn: (v) => warnings.push(v.message),
+		});
+		assert.deepEqual(candidates, ["openai/gpt-5-mini", "deepseek/deepseek-v4"]);
+		assert.equal(warnings.length, 1);
+		assert.match(warnings[0]!, /deepseek\/deepseek-v4/);
+	});
+});

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

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { findModelInfo, getSupportedThinkingLevels, type ModelInfo } from "../../src/shared/model-info.ts";
+
+describe("model info helpers", () => {
+	const ambiguousModels: ModelInfo[] = [
+		{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini", reasoning: true, thinkingLevelMap: { high: "high" } },
+		{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini", reasoning: true, thinkingLevelMap: { off: null, high: "high", xhigh: "xhigh" } },
+	];
+
+	it("does not choose arbitrary metadata for ambiguous bare model ids", () => {
+		assert.equal(findModelInfo("gpt-5-mini", ambiguousModels), undefined);
+	});
+
+	it("uses the preferred provider for ambiguous bare model metadata", () => {
+		assert.equal(findModelInfo("gpt-5-mini", ambiguousModels, "github-copilot")?.fullId, "github-copilot/gpt-5-mini");
+	});
+
+	it("matches provider-qualified model metadata before bare ids", () => {
+		assert.equal(findModelInfo("openai/gpt-5-mini:high", ambiguousModels, "github-copilot")?.fullId, "openai/gpt-5-mini");
+	});
+
+	it("keeps the legacy full thinking list for reasoning models without per-level metadata", () => {
+		assert.deepEqual(
+			getSupportedThinkingLevels({ provider: "openai", id: "gpt-5", fullId: "openai/gpt-5", reasoning: true }),
+			["off", "minimal", "low", "medium", "high", "xhigh"],
+		);
+	});
+
+	it("keeps the legacy full thinking list when older model metadata omits reasoning", () => {
+		assert.deepEqual(
+			getSupportedThinkingLevels({ provider: "openai", id: "gpt-5", fullId: "openai/gpt-5" }),
+			["off", "minimal", "low", "medium", "high", "xhigh"],
+		);
+	});
+
+	it("filters levels only when per-level metadata is present", () => {
+		assert.deepEqual(
+			getSupportedThinkingLevels({
+				provider: "deepseek",
+				id: "deepseek-v4-pro",
+				fullId: "deepseek/deepseek-v4-pro",
+				reasoning: true,
+				thinkingLevelMap: { minimal: null, low: null, medium: null, high: "high", xhigh: "max" },
+			}),
+			["off", "high", "xhigh"],
+		);
+	});
+
+	it("honors metadata that marks off unsupported", () => {
+		assert.deepEqual(
+			getSupportedThinkingLevels({
+				provider: "always-thinking",
+				id: "model",
+				fullId: "always-thinking/model",
+				reasoning: true,
+				thinkingLevelMap: { off: null, minimal: null, low: null, medium: null, high: "high" },
+			}),
+			["high"],
+		);
+	});
+});

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

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { discoverAgents } from "../../src/agents/agents.ts";
+
+let tempHome = "";
+let tempProject = "";
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalPiCodingAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+const originalExtraAgentDirs = process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+describe("subagents.modelScope discovery", () => {
+	beforeEach(() => {
+		tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-scope-home-"));
+		tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-scope-project-"));
+		process.env.HOME = tempHome;
+		process.env.USERPROFILE = tempHome;
+		delete process.env.SELESAI_CODING_AGENT_DIR;
+		delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) delete process.env.HOME;
+		else process.env.HOME = originalHome;
+		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = originalUserProfile;
+		if (originalPiCodingAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = originalPiCodingAgentDir;
+		if (originalExtraAgentDirs === undefined) delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
+		else process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = originalExtraAgentDirs;
+		fs.rmSync(tempHome, { recursive: true, force: true });
+		fs.rmSync(tempProject, { recursive: true, force: true });
+	});
+
+	it("exposes a user modelScope from discoverAgents", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { modelScope: { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] } },
+		});
+		const result = discoverAgents(tempProject, "both");
+		assert.deepEqual(result.modelScope, { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] });
+	});
+
+	it("returns undefined when no modelScope is configured", () => {
+		assert.equal(discoverAgents(tempProject, "both").modelScope, undefined);
+	});
+
+	it("prefers project modelScope over user modelScope", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { modelScope: { enforce: true, allow: ["anthropic/*"] } },
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { modelScope: { enforce: false, allow: ["deepseek/*"] } },
+		});
+		const result = discoverAgents(tempProject, "both");
+		assert.deepEqual(result.modelScope, { enforce: false, allow: ["deepseek/*"] });
+	});
+
+	it("falls back to user modelScope when project does not set one", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { modelScope: { enforce: true, allow: ["anthropic/*"] } },
+		});
+		const result = discoverAgents(tempProject, "both");
+		assert.deepEqual(result.modelScope, { enforce: true, allow: ["anthropic/*"] });
+	});
+
+	it("rejects an invalid modelScope config at discovery time", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { modelScope: { enforce: true } },
+		});
+		assert.throws(() => discoverAgents(tempProject, "both"), /without a non-empty 'allow'/);
+	});
+
+	it("rejects a malformed modelScope value at discovery time", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { modelScope: "anthropic/*" },
+		});
+		assert.throws(() => discoverAgents(tempProject, "both"), /invalid 'modelScope'/);
+	});
+});