@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-subagents/test/unit/preflight.test.ts

@@ -4,10 +4,10 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import { registerSubagentCapabilityCeiling, resolveSubagentCapabilityCeiling } from "../../src/api/capability-ceiling.ts";
+import { registerRequiredChildExtensions } from "../../src/api/required-child-extensions.ts";
 import { resolveSubagentLaunchContract, SUBAGENT_LAUNCH_CONTRACT_VERSION } from "../../src/api/preflight.ts";
 import { clearSkillCache } from "../../src/agents/skills.ts";
 import { computeMcpServerHash } from "../../src/runs/shared/mcp-direct-tool-allowlist.ts";
-import { clearExclusions, recordModelFailure } from "../../src/runs/shared/model-exclusions.ts";
 import { TEMP_ARTIFACTS_DIR } from "../../src/shared/types.ts";
 
 let tempDir = "";
@@ -35,7 +35,7 @@ function writeMcpFixture(): void {
 	const agentDir = process.env.SELESAI_CODING_AGENT_DIR;
 	assert.equal(typeof agentDir, "string");
 	const definition = { command: "github-mcp" };
-	writeJson(path.join(agentDir, "mcp.json"), { mcpServers: { github: definition } });
+	writeJson(path.join(agentDir, "mcp-adapter.json"), { mcpServers: { github: definition } });
 	writeJson(path.join(agentDir, "mcp-cache.json"), {
 		version: 1,
 		servers: {
@@ -60,12 +60,10 @@ describe("public launch contract preflight", () => {
 		process.env.USERPROFILE = home;
 		process.env.SELESAI_CODING_AGENT_DIR = path.join(home, ".selesai", "agent");
 		clearSkillCache();
-		clearExclusions();
 	});
 
 	afterEach(() => {
 		clearSkillCache();
-		clearExclusions();
 		if (previousHome === undefined) delete process.env.HOME;
 		else process.env.HOME = previousHome;
 		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
@@ -75,6 +73,57 @@ describe("public launch contract preflight", () => {
 		fs.rmSync(tempDir, { recursive: true, force: true });
 	});
 
+	it("exposes required host IDs without exposing their private paths", async () => {
+		const cwd = path.join(tempDir, "repo");
+		fs.mkdirSync(path.join(cwd, ".selesai", "agents"), { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "required.md"), "---\nname: required\ndescription: Required extension fixture\n---\nFixture.\n");
+		const extensionPath = path.join(tempDir, "required-provider.mjs");
+		fs.writeFileSync(extensionPath, "export default () => {};\n");
+		const registration = registerRequiredChildExtensions({ sessionId: "preflight-required", extensions: [{ id: "safe-provider", path: extensionPath }] });
+		try {
+			const result = await resolveSubagentLaunchContract({ agent: "required", cwd, parentSessionId: "preflight-required" });
+			assert.equal(result.ok, true);
+			if (!result.ok) return;
+			assert.deepEqual(result.contract.tools.requiredExtensionIds, ["safe-provider"]);
+			assert.equal(result.contract.tools.extensionArgs.includes(fs.realpathSync(extensionPath)), false);
+		} finally { registration.dispose(); }
+	});
+
+	it("validates a Claude Code model and level the way the launch does", async () => {
+		const cwd = path.join(tempDir, "cc-repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "cc.md"), `---\nname: cc\ndescription: Claude Code agent\nrunner:\n  type: external-cli\n  adapter: claude-code\n  command: claude\n---\nReview.\n`);
+
+		const overCeiling = await resolveSubagentLaunchContract({ agent: "cc", cwd, model: "sonnet:max", thinkingCeiling: "low" });
+		assert.equal(overCeiling.ok, false);
+		if (overCeiling.ok) return;
+		assert.equal(overCeiling.code, "thinking_ceiling");
+		assert.match(overCeiling.message, /exceeds configured maximum 'low'/u);
+
+		const invalidModel = await resolveSubagentLaunchContract({ agent: "cc", cwd, model: ":turbo" });
+		assert.equal(invalidModel.ok, false);
+		if (invalidModel.ok) return;
+		assert.equal(invalidModel.code, "unsupported_mode");
+		assert.match(invalidModel.message, /Invalid Claude Code model/u);
+
+		const agentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		assert.equal(typeof agentDir, "string");
+		writeJson(path.join(agentDir!, "settings.json"), { subagents: { modelScope: { enforce: true, allow: ["anthropic/claude-opus-4-5"] } } });
+
+		// An enforced scope fails closed, for a model outside it and for a launch with none.
+		const outsideScope = await resolveSubagentLaunchContract({ agent: "cc", cwd, model: "opus" });
+		assert.equal(outsideScope.ok, false);
+		if (outsideScope.ok) return;
+		assert.equal(outsideScope.code, "model_scope");
+		assert.match(outsideScope.message, /outside the configured subagent model scope/u);
+
+		const unnamed = await resolveSubagentLaunchContract({ agent: "cc", cwd });
+		assert.equal(unnamed.ok, false);
+		if (unnamed.ok) return;
+		assert.equal(unnamed.code, "model_scope");
+		assert.match(unnamed.message, /cannot be checked against an enforced subagent model scope/u);
+	});
+
 	it("resolves an ordinary single-agent contract without creating launch directories", async () => {
 		const cwd = path.join(tempDir, "repo");
 		fs.mkdirSync(cwd, { recursive: true });
@@ -87,8 +136,6 @@ tools:
   - write
   - /tmp/private-tool.ts
 model: test/primary
-fallbackModels:
-  - test/fallback
 thinking: high
 skills:
   - project-skill
@@ -116,18 +163,19 @@ Project prompt.
 			assert.equal(result.ok, true);
 			assert.equal(result.contract.version, SUBAGENT_LAUNCH_CONTRACT_VERSION);
 			assert.equal(result.contract.agent.source, "project");
-			assert.equal(result.contract.agent.definitionProjectionVersion, 1);
+			assert.equal(result.contract.agent.definitionProjectionVersion, 2);
 			assert.match(result.contract.agent.definitionDigest, /^[a-f0-9]{64}$/);
 			assert.match(result.contract.launchContractDigest, /^[a-f0-9]{64}$/);
 			assert.ok(result.contract.agent.shadowedCandidates.some((candidate) => candidate.name === "worker" && candidate.source === "builtin"));
 			assert.equal(result.contract.model, "test/primary:high");
-			assert.deepEqual(result.contract.modelCandidates, ["test/primary:high", "test/fallback:high"]);
 			assert.equal(result.contract.thinking, "high");
 			assert.deepEqual(result.contract.skills.requested, ["project-skill"]);
 			assert.equal(result.contract.skills.resolved[0]?.name, "project-skill");
 			assert.deepEqual(result.contract.tools.effectiveAllowlist, ["read"]);
-			assert.deepEqual(result.contract.tools.capabilityAudit?.removedTools, ["write"]);
+			// The bridge adds contact_supervisor before the ceiling applies, exactly as execution does.
+			assert.deepEqual(result.contract.tools.capabilityAudit?.removedTools, ["write", "contact_supervisor"]);
 			assert.equal(result.contract.tools.capabilityAudit?.removedExtensionCount, 1);
+			assert.deepEqual(result.contract.intercomBridge, { mode: "always", active: true });
 			assert.equal(result.contract.tools.disableAmbientExtensions, true);
 			assert.equal(result.contract.roots.sessionFile, path.join(sessionRoot, "run-123", "run-0", "session.jsonl"));
 			assert.equal(result.contract.roots.outputPath, path.join(TEMP_ARTIFACTS_DIR, "outputs", "run-123", "report.md"));
@@ -339,105 +387,25 @@ Project prompt.
 		);
 	});
 
-	it("uses an available configured fallback when the agent primary is unavailable", async () => {
-		const cwd = path.join(tempDir, "repo-unavailable-primary");
-		fs.mkdirSync(cwd, { recursive: true });
-		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
-name: scout
-description: Project scout
-model: test/missing-primary
-fallbackModels:
-  - test/fallback
----
-Project prompt.
-`);
-
-		const result = await resolveSubagentLaunchContract({
-			agent: "scout",
-			cwd,
-			availableModels: [{ provider: "test", id: "fallback", fullId: "test/fallback" }],
-		});
-
-		assert.equal(result.ok, true);
-		assert.deepEqual(result.contract.modelCandidates, ["test/fallback"]);
-	});
-
-	it("rejects an explicit unknown per-call model even when a fallback is configured", async () => {
+	it("rejects an explicit per-call unknown model before launch", async () => {
 		const cwd = path.join(tempDir, "repo-explicit-unknown-model");
 		fs.mkdirSync(cwd, { recursive: true });
-		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
-name: scout
-description: Project scout
-model: test/missing-primary
-fallbackModels:
-  - test/fallback
----
-Project prompt.
-`);
-
-		await assert.rejects(
-			resolveSubagentLaunchContract({
-				agent: "scout",
-				cwd,
-				model: "test/does-not-exist",
-				availableModels: [{ provider: "test", id: "fallback", fullId: "test/fallback" }],
-			}),
-			/Unknown subagent model 'test\/does-not-exist'/,
-		);
-	});
-
-	it("fails closed when every configured candidate is unavailable", async () => {
-		const cwd = path.join(tempDir, "repo-all-unavailable-models");
-		fs.mkdirSync(cwd, { recursive: true });
-		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
-name: scout
-description: Project scout
-model: test/missing-primary
-fallbackModels:
-  - test/missing-fallback
----
-Project prompt.
-`);
-
-		await assert.rejects(
-			resolveSubagentLaunchContract({
-				agent: "scout",
-				cwd,
-				availableModels: [{ provider: "test", id: "other", fullId: "test/other" }],
-			}),
-			/Unknown subagent model 'test\/missing-primary'/,
-		);
-	});
-
-	it("fails closed when cached exclusions leave zero launch candidates", async () => {
-		const cwd = path.join(tempDir, "repo-cached-excluded-models");
-		fs.mkdirSync(cwd, { recursive: true });
-		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
-name: scout
-description: Project scout
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
 model: test/primary
-fallbackModels:
-  - test/fallback
 ---
 Project prompt.
 `);
-		recordModelFailure({ modelId: "primary", provider: "test", reason: "sk-secret-token-xyz" });
-		recordModelFailure({ modelId: "fallback", provider: "test", reason: "sk-secret-token-xyz" });
 
 		await assert.rejects(
 			resolveSubagentLaunchContract({
-				agent: "scout",
+				agent: "worker",
 				cwd,
-				availableModels: [
-					{ provider: "test", id: "primary", fullId: "test/primary" },
-					{ provider: "test", id: "fallback", fullId: "test/fallback" },
-				],
+				model: "test/unknown",
+				availableModels: [{ provider: "test", id: "primary", fullId: "test/primary" }],
 			}),
-			(error: unknown) => {
-				const message = String(error);
-				return /No usable subagent models remain after registry, scope, and cached-exclusion filtering/.test(message)
-					&& !message.includes("sk-secret-token-xyz");
-			},
+			/Unknown subagent model 'test\/unknown'/,
 		);
 	});
 
@@ -460,7 +428,6 @@ Project prompt.
 
 		assert.equal(result.ok, true);
 		assert.equal(result.contract.model, "gateway/parent-model");
-		assert.deepEqual(result.contract.modelCandidates, ["gateway/parent-model"]);
 	});
 
 	it("uses subagents.defaultProvider when resolving launch model ids", async () => {
@@ -489,7 +456,6 @@ Project prompt.
 
 		assert.equal(result.ok, true);
 		assert.equal(result.contract.model, "gpu-b/gpt-5-mini");
-		assert.deepEqual(result.contract.modelCandidates, ["gpu-b/gpt-5-mini"]);
 	});
 
 	it("bypasses native model validation for external CLI runners", async () => {
@@ -516,7 +482,6 @@ Project prompt.
 
 		assert.equal(result.ok, true);
 		assert.equal(result.contract.model, undefined);
-		assert.deepEqual(result.contract.modelCandidates, []);
 	});
 
 	it("resolves agent aliases to the canonical launch contract agent", async () => {
@@ -827,7 +792,7 @@ Project prompt.
 		assert.equal(result.ok, true);
 		assert.equal(result.contract.context, "fork");
 		assert.ok(result.contract.diagnostics.some((diagnostic) => diagnostic.code === "host_required"));
-		assert.deepEqual(result.contract.tools.declaredBuiltin, ["read", "subagent"]);
+		assert.deepEqual(result.contract.tools.declaredBuiltin, ["read", "subagent", "contact_supervisor"]);
 		assert.equal(result.contract.tools.explicitAllowlist, true);
 		assert.equal(result.contract.tools.fanoutAuthorized, true);
 		assert.deepEqual(result.contract.tools.internalTools, ["structured_output"]);
@@ -841,6 +806,39 @@ Project prompt.
 		assert.ok(result.contract.tools.extensionArgs.includes("/tmp/subagent-only.ts"));
 	});
 
+	it("resolves mcp: selectors against the built-in MCP of the given host", async () => {
+		const cwd = path.join(tempDir, "builtin-mcp-repo");
+		writeAgent(path.join(cwd, ".selesai", "agents", "docs.md"), "---\nname: docs\ndescription: Docs\ntools:\n  - read\n  - mcp:docs/search\n---\n");
+		const result = await resolveSubagentLaunchContract({ agent: "docs", cwd, runtimeSnapshotHost: {
+			events: { emit() {} },
+			getCommands: () => [{ name: "mcp", sourceInfo: { path: "builtin:mcp" } }],
+			getAllTools: () => [{ name: "mcp__docs__search", exposure: "codemode", namespace: { name: "mcp__docs" } }],
+		} });
+		assert.equal(result.ok, true);
+		assert.deepEqual(result.contract.tools.effectiveMcpTools, ["mcp__docs__search"]);
+	});
+
+	it("inherits agent structured output and honors false for native and external runners", async () => {
+		const cwd = path.join(tempDir, "schema-default-repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "typed.md"), `---\nname: typed\ndescription: Typed\noutputSchema: {"type":"object","required":["ok"]}\n---\nPrompt.\n`);
+		const inherited = await resolveSubagentLaunchContract({ agent: "typed", cwd, task: "Inspect" });
+		assert.equal(inherited.ok, true);
+		if (!inherited.ok) return;
+		assert.deepEqual(inherited.contract.tools.internalTools, ["structured_output"]);
+		const disabled = await resolveSubagentLaunchContract({ agent: "typed", cwd, task: "Inspect", outputSchema: false });
+		assert.equal(disabled.ok, true);
+		if (!disabled.ok) return;
+		assert.deepEqual(disabled.contract.tools.internalTools, []);
+		assert.notEqual(inherited.contract.launchContractDigest, disabled.contract.launchContractDigest);
+
+		writeAgent(path.join(cwd, ".selesai", "agents", "external.md"), `---\nname: external\ndescription: External\noutputSchema: {"type":"object"}\nrunner:\n  type: external-cli\n  command: ${JSON.stringify(process.execPath)}\n---\nPrompt.\n`);
+		const rejected = await resolveSubagentLaunchContract({ agent: "external", cwd });
+		assert.equal(rejected.ok, false);
+		assert.equal(rejected.code, "unsupported_mode");
+		assert.equal((await resolveSubagentLaunchContract({ agent: "external", cwd, outputSchema: false })).ok, true);
+	});
+
 	it("projects per-agent tool exclusions and binds them into launch identity", async () => {
 		const cwd = path.join(tempDir, "exclude-tools-repo");
 		fs.mkdirSync(cwd, { recursive: true });
@@ -857,12 +855,103 @@ Project prompt.
 		assert.equal(result.ok, true);
 		if (!result.ok) return;
 		assert.deepEqual(result.contract.tools.excludeTools, ["write", "unknown_tool"]);
-		// An explicit tool surface also gets the scoped capability gateway tools, which
-		// this launch does not exclude (see the capability-gateway child policy tests).
-		assert.deepEqual(result.contract.tools.effectiveAllowlist, ["read", "capability_catalog", "capability_discover", "capability_skill_show"]);
+		assert.deepEqual(result.contract.tools.effectiveAllowlist, ["read", "contact_supervisor"]);
 		assert.match(result.contract.launchContractDigest, /^[a-f0-9]{64}$/);
 	});
 
+	it("binds Intercom bridge activation into launch identity without touching definition identity", async () => {
+		const cwd = path.join(tempDir, "bridge-repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
+tools: read
+---
+Project prompt.
+`);
+		const input = { agent: "worker", cwd, task: "Inspect" };
+
+		const base = await resolveSubagentLaunchContract(input);
+		assert.equal(base.ok, true);
+		if (!base.ok) return;
+		assert.deepEqual(base.contract.intercomBridge, { mode: "always", active: true });
+		assert.ok(base.contract.tools.effectiveAllowlist.includes("contact_supervisor"));
+		assert.equal(base.contract.diagnostics.some((diagnostic) => /orchestratorTarget/.test(diagnostic.message)), false);
+
+		// The default template never names the parent session, so a host that
+		// supplies its real target gets the same digest as one that does not.
+		const withTarget = await resolveSubagentLaunchContract({ ...input, orchestratorTarget: "subagent-chat-1234" });
+		assert.equal(withTarget.ok, true);
+		if (!withTarget.ok) return;
+		assert.equal(withTarget.contract.launchContractDigest, base.contract.launchContractDigest);
+
+		const off = await resolveSubagentLaunchContract({ ...input, intercomBridge: { mode: "off" } });
+		assert.equal(off.ok, true);
+		if (!off.ok) return;
+		assert.deepEqual(off.contract.intercomBridge, { mode: "off", active: false });
+		assert.equal(off.contract.tools.effectiveAllowlist.includes("contact_supervisor"), false);
+		assert.notEqual(off.contract.launchContractDigest, base.contract.launchContractDigest);
+		assert.equal(off.contract.agent.definitionDigest, base.contract.agent.definitionDigest);
+
+		// Inactive fork-only for a fresh launch hashes exactly like off: activation, not the mode label, is bound.
+		const forkOnly = await resolveSubagentLaunchContract({ ...input, context: "fresh", intercomBridge: { mode: "fork-only" } });
+		assert.equal(forkOnly.ok, true);
+		if (!forkOnly.ok) return;
+		assert.deepEqual(forkOnly.contract.intercomBridge, { mode: "fork-only", active: false });
+		assert.equal(forkOnly.contract.launchContractDigest, off.contract.launchContractDigest);
+	});
+
+	it("requires a host target only when the bridge instruction file names the session", async () => {
+		const cwd = path.join(tempDir, "bridge-template-repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
+---
+Project prompt.
+`);
+		const instructionFile = path.join(tempDir, "bridge.md");
+		fs.writeFileSync(instructionFile, "Custom bridge for {orchestratorTarget}\nUse ask then send.\n", "utf-8");
+		const input = { agent: "worker", cwd, task: "Inspect", intercomBridge: { mode: "always" as const, instructionFile } };
+
+		const withoutTarget = await resolveSubagentLaunchContract(input);
+		assert.equal(withoutTarget.ok, true);
+		if (!withoutTarget.ok) return;
+		assert.ok(withoutTarget.contract.diagnostics.some((diagnostic) => diagnostic.code === "host_required" && /orchestratorTarget/.test(diagnostic.message)));
+
+		const withTarget = await resolveSubagentLaunchContract({ ...input, orchestratorTarget: "main" });
+		assert.equal(withTarget.ok, true);
+		if (!withTarget.ok) return;
+		assert.equal(withTarget.contract.diagnostics.some((diagnostic) => /orchestratorTarget/.test(diagnostic.message)), false);
+		assert.notEqual(withTarget.contract.launchContractDigest, withoutTarget.contract.launchContractDigest);
+	});
+
+	it("fails closed for an invalid intercomBridge override", async () => {
+		const cwd = path.join(tempDir, "bridge-invalid-repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
+---
+Project prompt.
+`);
+		for (const intercomBridge of [{ mode: "loud" }, { extra: true }, "always"]) {
+			const result = await resolveSubagentLaunchContract({ agent: "worker", cwd, intercomBridge: intercomBridge as never });
+			assert.equal(result.ok, false);
+			if (!result.ok) assert.equal(result.code, "invalid_intercom_bridge");
+		}
+		// Execution never has an empty target, so accepting one would silently
+		// deactivate the bridge in preflight only.
+		for (const orchestratorTarget of ["", "   ", 7]) {
+			const result = await resolveSubagentLaunchContract({ agent: "worker", cwd, orchestratorTarget: orchestratorTarget as never });
+			assert.equal(result.ok, false);
+			if (!result.ok) {
+				assert.equal(result.code, "invalid_intercom_bridge");
+				assert.match(result.message, /orchestratorTarget/);
+			}
+		}
+	});
+
 	it("falls back implicit default fork to fresh when the parent session is not forkable", async () => {
 		const cwd = path.join(tempDir, "repo-implicit-fork");
 		fs.mkdirSync(cwd, { recursive: true });

package/dist/extensions/pi-subagents/test/unit/proactive-skills.test.ts

@@ -55,6 +55,21 @@ describe("proactive skill subagent recommendations", () => {
 		assert.deepEqual(recommendations[0]?.sources, ["agent:ui-reviewer", "chain:ui-check"]);
 	});
 
+	it("does not recommend hidden skills (disable-model-invocation: true)", () => {
+		const recommendations = recommendProactiveSkillSubagents({
+			agents: [
+				agent("one", ["hidden-skill", "visible-skill"]),
+				agent("two", ["hidden-skill", "visible-skill"]),
+			],
+			availableSkills: [
+				{ name: "hidden-skill", description: "User-only.", disableModelInvocation: true },
+				{ name: "visible-skill", description: "Model-invocable." },
+			],
+		});
+
+		assert.deepEqual(recommendations.map((entry) => entry.skill), ["visible-skill"]);
+	});
+
 	it("filters unavailable orchestration skills and honors config bounds", () => {
 		const recommendations = recommendProactiveSkillSubagents({
 			agents: [
@@ -115,4 +130,4 @@ describe("proactive skill subagent recommendations", () => {
 		assert.deepEqual(failedDiscoveryLines, []);
 		assert.equal(discoveryCalls, 1);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/process-identity.test.ts

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { computeProcessStartKey, processLiveness, processStartKey, psProcessStartKey, startKeyScheme } from "../../src/shared/process-identity.ts";
+
+function resolvers() {
+	const calls: string[] = [];
+	return {
+		calls,
+		linux: (pid: number) => { calls.push(`linux:${pid}`); return undefined as string | undefined; },
+		ps: (pid: number) => { calls.push(`ps:${pid}`); return `ps:started-${pid}` as string | undefined; },
+		windows: (pid: number) => { calls.push(`win:${pid}`); return `win:started-${pid}` as string | undefined; },
+	};
+}
+
+describe("process start key", () => {
+	it("uses ps on darwin and other non-linux, non-windows unixes", () => {
+		for (const platform of ["darwin", "freebsd", "openbsd", "sunos"] as const) {
+			const fakes = resolvers();
+			assert.equal(computeProcessStartKey(42, platform, fakes), "ps:started-42", platform);
+			assert.deepEqual(fakes.calls, ["ps:42"], platform);
+		}
+	});
+
+	it("keeps Linux on /proc with a ps fallback and Windows on CIM", () => {
+		const fakes = resolvers();
+		assert.equal(computeProcessStartKey(7, "linux", { ...fakes, linux: () => "linux:123" }), "linux:123");
+		assert.equal(computeProcessStartKey(7, "linux", fakes), "ps:started-7");
+		assert.deepEqual(fakes.calls, ["linux:7", "ps:7"]);
+		const win = resolvers();
+		assert.equal(computeProcessStartKey(9, "win32", win), "win:started-9");
+		assert.deepEqual(win.calls, ["win:9"]);
+	});
+
+	it("returns undefined when the identity cannot be established", () => {
+		assert.equal(computeProcessStartKey(1, "darwin", { ps: () => undefined }), undefined);
+		assert.equal(computeProcessStartKey(1, "win32", { windows: () => undefined }), undefined);
+	});
+
+	it("caches only this process's own key", () => {
+		const own = processStartKey(process.pid);
+		assert.equal(processStartKey(process.pid), own);
+		if (process.platform === "darwin") assert.match(own ?? "", /^ps:\S/);
+	});
+
+	it("reads a real ps start key on darwin", { skip: process.platform !== "darwin" }, () => {
+		const key = psProcessStartKey(process.pid);
+		assert.match(key ?? "", /^ps:\S/);
+		assert.equal(startKeyScheme(key!), "ps");
+		assert.equal(psProcessStartKey(2 ** 22 + 12345), undefined);
+	});
+
+	it("names key schemes so unlike keys are never compared", () => {
+		assert.equal(startKeyScheme("linux:123"), "linux");
+		assert.equal(startKeyScheme("ps:Mon Oct 4 10:00:00 2026"), "ps");
+		assert.equal(startKeyScheme("win:2026"), "win");
+		assert.equal(startKeyScheme("opaque"), "");
+	});
+});
+
+describe("process liveness", () => {
+	const killing = (code: string | undefined) => () => { throw Object.assign(new Error(code ?? "boom"), code ? { code } : {}); };
+
+	it("maps kill(pid, 0) outcomes to alive, dead, or unknown", () => {
+		assert.equal(processLiveness(10, () => true), "alive");
+		assert.equal(processLiveness(10, killing("ESRCH")), "dead");
+		assert.equal(processLiveness(10, killing("EPERM")), "alive");
+		assert.equal(processLiveness(10, killing("EINVAL")), "unknown");
+		assert.equal(processLiveness(10, killing(undefined)), "unknown");
+	});
+
+	it("never probes non-positive or fractional pids (kill(0) would signal the process group)", () => {
+		const probe = () => { throw new Error("must not be called"); };
+		for (const pid of [0, -1, 1.5, Number.NaN]) assert.equal(processLiveness(pid, probe), "unknown");
+	});
+});

package/dist/extensions/pi-subagents/test/unit/process-terminal.test.ts

@@ -272,8 +272,24 @@ test("process-terminal reports unknown when the runner candidate is unavailable"
 			runId: "run-2",
 			runnerProcessInstanceId: "runner-2",
 			reason: "runner-candidate-missing",
+			instances: [{ kind: "runner", processInstanceId: "runner-2", closeObservedAt: 40, exitCode: 1, signal: null }],
 		});
 	} finally {
 		fs.rmSync(asyncDir, { recursive: true, force: true });
 	}
-});
+});
+
+test("process-terminal adds the observed runner exit to a sticky runner-published unknown proof", () => {
+	const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-terminal-"));
+	try {
+		const sticky = { version: 1, state: "unknown", runId: "run-3", runnerProcessInstanceId: "runner-3", reason: "process-tree-unverified", diagnostic: "Worktree setup settlement unknown" };
+		fs.writeFileSync(path.join(asyncDir, "process-terminal.json"), JSON.stringify(sticky));
+		const exit = { processInstanceId: "runner-3", closeObservedAt: 50, exitCode: null, signal: "SIGKILL" };
+		const expected = { ...sticky, instances: [{ kind: "runner", ...exit }] };
+
+		assert.deepEqual(finalizeProcessTerminal(asyncDir, "run-3", exit), expected);
+		assert.deepEqual(readProcessTerminal(asyncDir, { runId: "run-3", runnerProcessInstanceId: "runner-3" }), expected);
+	} finally {
+		fs.rmSync(asyncDir, { recursive: true, force: true });
+	}
+});