@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-subagents/test/unit/pi-coding-agent-dir.test.ts

@@ -7,8 +7,9 @@ import { afterEach, beforeEach, describe, it } from "node:test";
 import { discoverAgentsAll } from "../../src/agents/agents.ts";
 import { handleCreate } from "../../src/agents/agent-management.ts";
 import { clearSkillCache, discoverAvailableSkills, resolveSkillPath } from "../../src/agents/skills.ts";
-import { loadConfig, updateConfig } from "../../src/extension/config.ts";
+import { applyModelExclusionsConfig, loadConfig, resolveModelExclusionTTL, updateConfig } from "../../src/extension/config.ts";
 import { diagnoseIntercomBridge, resolveIntercomBridge } from "../../src/intercom/intercom-bridge.ts";
+import { DEFAULT_MODEL_EXCLUSION_TTL_MS, MAX_MODEL_EXCLUSION_TTL_MS, clearExclusions, flushPersist, recordModelFailure, reloadFromDisk } from "../../src/runs/shared/model-exclusions.ts";
 import { loadRunsForAgent, recordRun } from "../../src/runs/shared/run-history.ts";
 import { cleanupAllArtifactDirs, getArtifactsDir, getProjectArtifactsDir } from "../../src/shared/artifacts.ts";
 import { TEMP_ARTIFACTS_DIR } from "../../src/shared/types.ts";
@@ -101,6 +102,15 @@ describe("SELESAI_CODING_AGENT_DIR runtime paths", () => {
 		assert.equal(config.artifactConfig?.cleanupDays, Number.MAX_SAFE_INTEGER);
 	});
 
+	it("requires a pruning model when pruned fork mode is enabled", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ forkContext: { mode: "pruned" } }));
+		assert.throws(() => loadConfig(), /forkContext\.model is required/);
+
+		writeFile(configPath, JSON.stringify({ forkContext: { mode: "pruned", model: "openai-codex/gpt-5.6-luna:max" } }));
+		assert.deepEqual(loadConfig().forkContext, { mode: "pruned", model: "openai-codex/gpt-5.6-luna:max" });
+	});
+
 	it("discovers user agents, chains, and settings under the configured agent dir", () => {
 		const settingsPath = path.join(agentDir, "settings.json");
 		writeFile(path.join(agentDir, "agents", "env-agent.md"), `---
@@ -148,6 +158,41 @@ Inspect env.
 		assert.equal(fs.existsSync(path.join(agentDir, "agents", `${createdName}.md`)), true);
 	});
 
+	it("ignores nested .pi and sync-backups agent definitions", () => {
+		const userAgentsDir = path.join(agentDir, "agents");
+		const rootAgentPath = path.join(userAgentsDir, "root-agent.md");
+		writeFile(rootAgentPath, `---
+name: root-agent
+description: Root agent
+---
+
+Use the configured root agent.
+`);
+		const nestedBackupAgentPath = path.join(userAgentsDir, ".selesai", "agent", "sync-backups", "20260712-163714", "agents", "stale.md");
+		writeFile(nestedBackupAgentPath, `---
+name: stale
+model: nonexistent/model
+description: Stale backup agent
+---
+
+This definition must not be executable.
+`);
+		const directBackupAgentPath = path.join(userAgentsDir, "sync-backups", "20260712-163714", "agents", "also-stale.md");
+		writeFile(directBackupAgentPath, `---
+name: also-stale
+description: Another stale backup agent
+---
+
+This definition must not be executable either.
+`);
+
+		const discovered = discoverAgentsAll(cwd);
+		assert.ok(discovered.user.find((agent) => agent.name === "root-agent" && agent.filePath === rootAgentPath));
+		assert.equal(discovered.user.some((agent) => agent.name === "stale"), false);
+		assert.equal(discovered.user.some((agent) => agent.name === "also-stale"), false);
+		assert.equal(discovered.user.some((agent) => agent.filePath === nestedBackupAgentPath || agent.filePath === directBackupAgentPath), false);
+	});
+
 	it("resolves user skills, settings skills, and package skills from the configured agent dir", () => {
 		writeFile(path.join(agentDir, "skills", "env-skill", "SKILL.md"), `---
 description: Env skill
@@ -212,6 +257,21 @@ Package skill content.
 		assert.equal(fs.existsSync(artifactPath), false);
 	});
 
+	it("records explicit run outcomes without guessing legacy outcomes", () => {
+		const historyPath = path.join(agentDir, "run-history.jsonl");
+		writeFile(historyPath, `${JSON.stringify({ agent: "outcome-agent", task: "[redacted]", ts: 1, status: "error", duration: 1, exit: 143 })}\n`);
+		recordRun("outcome-agent", "failed", 1, 2);
+		recordRun("outcome-agent", "timed out", 1, 3, { timedOut: true });
+		recordRun("outcome-agent", "interrupted", 1, 4, { interrupted: true });
+		recordRun("outcome-agent", "stopped", 1, 5, { stopped: true });
+		recordRun("outcome-agent", "completed", 0, 6);
+		recordRun("outcome-agent", "signalled", 143, 7, { processSignal: "SIGTERM" });
+
+		const history = loadRunsForAgent("outcome-agent");
+		assert.deepEqual(history.map((entry) => entry.outcome), ["stopped", "completed", "stopped", "interrupted", "timed_out", "failed", undefined]);
+		assert.equal(history.at(-1)?.exit, 143);
+	});
+
 	it("resolves configured artifact directory preferences", () => {
 		const sessionFile = path.join(agentDir, "sessions", "session-1", "session.jsonl");
 
@@ -232,6 +292,40 @@ Package skill content.
 		assert.throws(() => updateConfig((config) => config), /config\.defaultSubagentContext must be "fresh" or "fork"/);
 	});
 
+	it("loads and applies model exclusion TTL config", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		const exclusionPath = path.join(tempDir, "model-exclusions.json");
+		const previousExclusionPath = process.env.PI_MODEL_EXCLUSIONS_PATH;
+		process.env.PI_MODEL_EXCLUSIONS_PATH = exclusionPath;
+		try {
+			writeFile(configPath, JSON.stringify({ modelExclusions: { defaultTtlMs: 300_000 } }));
+			const config = loadConfig();
+			assert.equal(config.modelExclusions?.defaultTtlMs, 300_000);
+			assert.equal(resolveModelExclusionTTL(config), 300_000);
+			assert.equal(resolveModelExclusionTTL({}), DEFAULT_MODEL_EXCLUSION_TTL_MS);
+
+			applyModelExclusionsConfig(config);
+			reloadFromDisk();
+			recordModelFailure({ modelId: "gpt-5", provider: "openai", reason: "test" });
+			const entry = (JSON.parse(fs.readFileSync(exclusionPath, "utf-8")).exclusions as Array<{ recordedAt: number; expiresAt: number }>)[0];
+			assert.ok(entry);
+			assert.equal(entry.expiresAt - entry.recordedAt, 300_000);
+
+			for (const invalidTtl of [0, -1, MAX_MODEL_EXCLUSION_TTL_MS + 1, "300000", true, null]) {
+				writeFile(configPath, JSON.stringify({ modelExclusions: { defaultTtlMs: invalidTtl } }));
+				assert.throws(() => updateConfig((current) => current), /config\.modelExclusions\.defaultTtlMs must be a finite positive number/);
+			}
+		} finally {
+			clearExclusions();
+			flushPersist();
+			reloadFromDisk();
+			applyModelExclusionsConfig({});
+			if (previousExclusionPath === undefined) delete process.env.PI_MODEL_EXCLUSIONS_PATH;
+			else process.env.PI_MODEL_EXCLUSIONS_PATH = previousExclusionPath;
+			fs.rmSync(exclusionPath, { force: true });
+		}
+	});
+
 	it("rejects invalid artifactDir config values", () => {
 		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
 		writeFile(configPath, JSON.stringify({ artifactDir: "workspace" }));
@@ -239,6 +333,20 @@ Package skill content.
 		assert.throws(() => updateConfig((config) => config), /config\.artifactDir must be "project", "session", or "temp"/);
 	});
 
+	it("loads and validates abandoned async capacity cleanup policy", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ capacity: { abandonedSlotReleaseAfterMs: 600_000 } }));
+		assert.equal(loadConfig().capacity?.abandonedSlotReleaseAfterMs, 600_000);
+
+		writeFile(configPath, JSON.stringify({ capacity: { abandonedSlotReleaseAfterMs: false } }));
+		assert.equal(loadConfig().capacity?.abandonedSlotReleaseAfterMs, false);
+
+		for (const invalid of [299_999, 86_400_001, 0, "600000", null]) {
+			writeFile(configPath, JSON.stringify({ capacity: { abandonedSlotReleaseAfterMs: invalid } }));
+			assert.throws(() => updateConfig((config) => config), /config\.capacity\.abandonedSlotReleaseAfterMs must be false or an integer/);
+		}
+	});
+
 	it("loads and validates Fleet keybinding config", () => {
 		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
 		writeFile(configPath, JSON.stringify({ fleetKeybindings: { pageUp: ["u"], pageDown: ["d"] } }));

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

@@ -170,6 +170,51 @@ Project prompt.
 		if (!invalid.ok) assert.equal(invalid.code, "invalid_extension_bindings");
 	});
 
+	it("uses the parent provider for provider-scoped agent overrides", async () => {
+		const cwd = path.join(tempDir, "provider-overrides");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeJson(path.join(cwd, ".selesai", "settings.json"), {
+			subagents: {
+				agentOverridesByProvider: {
+					"github-copilot": { worker: { model: "github-copilot/gpt-5-mini" } },
+					openrouter: { worker: { model: "openrouter/openai/gpt-5-mini" } },
+				},
+			},
+		});
+		const availableModels = [
+			{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini" },
+			{ provider: "openrouter", id: "openai/gpt-5-mini", fullId: "openrouter/openai/gpt-5-mini" },
+		];
+
+		const copilot = await resolveSubagentLaunchContract({
+			agent: "worker", cwd, parentModel: { provider: "github-copilot", id: "parent" }, availableModels,
+		});
+		const openrouter = await resolveSubagentLaunchContract({
+			agent: "worker", cwd, preferredProvider: "openrouter", parentModel: { provider: "github-copilot", id: "parent" }, availableModels,
+		});
+		assert.equal(copilot.ok, true);
+		assert.equal(openrouter.ok, true);
+		if (copilot.ok) assert.equal(copilot.contract.model, "github-copilot/gpt-5-mini:high");
+		if (openrouter.ok) assert.equal(openrouter.contract.model, "openrouter/openai/gpt-5-mini:high");
+	});
+
+	it("warns when workspace package work has package-only authority", async () => {
+		const cwd = path.join(tempDir, "workspace-scope-repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---\nname: worker\ndescription: Project worker\n---\nWorker.\n`);
+
+		const result = await resolveSubagentLaunchContract({
+			agent: "worker",
+			cwd,
+			task: "Create a new workspace package, but only edit files under packages/widget and do not change root workspace metadata.",
+		});
+
+		assert.equal(result.ok, true);
+		if (result.ok) {
+			assert.equal(result.contract.diagnostics.some((diagnostic) => diagnostic.code === "workspace_scope_authority" && diagnostic.severity === "warning"), true);
+		}
+	});
+
 	it("binds fast mode runtime extension into public preflight provenance", async () => {
 		const cwd = path.join(tempDir, "fast-repo");
 		fs.mkdirSync(cwd, { recursive: true });
@@ -446,7 +491,13 @@ Project prompt.
 `);
 
 		const missingAgent = await resolveSubagentLaunchContract({ agent: "missing", cwd });
-		assert.deepEqual(missingAgent, { ok: false, code: "missing_agent", message: "Unknown agent: missing", diagnostics: [] });
+		assert.equal(missingAgent.ok, false);
+		assert.equal(missingAgent.code, "missing_agent");
+		assert.deepEqual(missingAgent.diagnostics, []);
+		assert.match(missingAgent.message, /^Unknown agent: missing\nEffective cwd: /);
+		assert.match(missingAgent.message, /Consulted agent-definition directories:/);
+		assert.match(missingAgent.message, /project: .*\.selesai[\\/]agents \(1 candidate\)/);
+		assert.match(missingAgent.message, /Discovered agents:\n[\s\S]*worker \(project\)/);
 		writeAgent(path.join(cwd, ".selesai", "agents", "broken.md"), `---
 name: broken
 description: Broken worker
@@ -780,4 +831,23 @@ Project prompt.
 		assert.equal(result.code, "denied_required_tool");
 		assert.match(result.message, /excludes required tool 'read'/);
 	});
+
+	it("reports unresolved runtime-style MCP selectors during preflight", async () => {
+		const cwd = path.join(tempDir, "repo-unresolved-runtime-mcp");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
+tools:
+  - read
+  - mcp:rt__wiki/read_wiki_structure
+---
+Project prompt.
+`);
+
+		const result = await resolveSubagentLaunchContract({ agent: "worker", cwd, task: "Inspect" });
+		assert.equal(result.ok, false);
+		assert.equal(result.code, "denied_required_tool");
+		assert.match(result.message, /Unresolved MCP direct-tool selectors: rt__wiki\/read_wiki_structure\./);
+	});
 });

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

@@ -16,12 +16,12 @@ import {
 	refreshProviderModelCatalog,
 	readProviderModelCatalog,
 } from "../../src/profiles/profiles.ts";
-import { SELESAI_SUBAGENT_PI_BINARY_ENV } from "../../src/runs/shared/pi-spawn.ts";
+import { SELESAI_SUBAGENT_SELESAI_BINARY_ENV } from "../../src/runs/shared/pi-spawn.ts";
 
 let homeDir = "";
 const previousHome = process.env.HOME;
 const previousUserProfile = process.env.USERPROFILE;
-const previousPiBinary = process.env[SELESAI_SUBAGENT_PI_BINARY_ENV];
+const previousPiBinary = process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV];
 
 function makeCtx(cwd: string, models: Array<Record<string, unknown>>) {
 	return {
@@ -44,8 +44,8 @@ describe("profiles helpers", () => {
 		else process.env.HOME = previousHome;
 		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
 		else process.env.USERPROFILE = previousUserProfile;
-		if (previousPiBinary === undefined) delete process.env[SELESAI_SUBAGENT_PI_BINARY_ENV];
-		else process.env[SELESAI_SUBAGENT_PI_BINARY_ENV] = previousPiBinary;
+		if (previousPiBinary === undefined) delete process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV];
+		else process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV] = previousPiBinary;
 		fs.rmSync(homeDir, { recursive: true, force: true });
 	});
 
@@ -152,7 +152,7 @@ describe("profiles helpers", () => {
 
 	it("refreshes a provider model catalog using the resolved Pi executable and writes a cache file", async () => {
 		const piBinary = path.join(homeDir, "pi-wrapper.exe");
-		process.env[SELESAI_SUBAGENT_PI_BINARY_ENV] = piBinary;
+		process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV] = piBinary;
 		const execCalls: string[] = [];
 		const execCwds: unknown[] = [];
 		const pi = {
@@ -324,7 +324,7 @@ describe("profiles helpers", () => {
 		}, null, 2));
 		const pi = {
 			exec: async (_command: string, args: string[]) => {
-				const model = args[2];
+				const model = args.includes("--model") ? args[args.indexOf("--model") + 1] : args[2];
 				if (model === "openai-codex/gpt-5.9") {
 					return { stdout: "", stderr: "model unavailable", code: 1, killed: false };
 				}
@@ -358,7 +358,7 @@ describe("profiles helpers", () => {
 		const probedModels: unknown[] = [];
 		const pi = {
 			exec: async (_command: string, args: string[]) => {
-				probedModels.push(args[2]);
+				probedModels.push(args.includes("--model") ? args[args.indexOf("--model") + 1] : args[2]);
 				assert.equal(args.includes("--no-tools"), true);
 				assert.equal(args.includes("--tools"), false);
 				return { stdout: "OK\n", stderr: "", code: 0, killed: false };

package/dist/extensions/pi-subagents/test/unit/pruned-fork.test.ts

@@ -0,0 +1,214 @@
+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 { createForkContextResolver } from "../../src/shared/fork-context.ts";
+import { pruneForkSessionFile, prunedForkRecoveryPath, type PrunedForkRecoveryPayload } from "../../src/shared/pruned-fork.ts";
+
+function writeJsonl(filePath: string, entries: unknown[]): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+}
+
+function largeForkEntries(parentSession: string): unknown[] {
+	return [
+		{ type: "session", version: 1, id: "child", timestamp: "2026-08-24T00:00:00.000Z", cwd: "/tmp", parentSession },
+		{ type: "message", id: "user-1", parentId: null, timestamp: "2026-08-24T00:00:01.000Z", message: { role: "user", content: "Keep this recent user decision exact." } },
+		{ type: "message", id: "assistant-call", parentId: "user-1", timestamp: "2026-08-24T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude", content: [
+			{ type: "thinking", thinking: "private", thinkingSignature: "signed" },
+			{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "large.txt" } },
+		] } },
+		{ type: "message", id: "tool-result", parentId: "assistant-call", timestamp: "2026-08-24T00:00:03.000Z", message: { role: "toolResult", toolCallId: "tool-1", toolName: "read", content: [{ type: "text", text: "raw-parent-output-".repeat(6_000) }], isError: false } },
+	];
+}
+
+function validSummaryResponse(payload: string, text = "The large read established the current implementation state."): string {
+	const request = JSON.parse(payload) as { items: Array<{ itemId: string }> };
+	return JSON.stringify({ summaries: request.items.map((item) => ({ itemId: item.itemId, summary: text })) });
+}
+
+function readRecovery(sessionFile: string): PrunedForkRecoveryPayload {
+	return JSON.parse(fs.readFileSync(prunedForkRecoveryPath(sessionFile), "utf-8")) as PrunedForkRecoveryPayload;
+}
+
+describe("pruned fork sessions", () => {
+	it("spills transcript overflow to private recovery with stable visible refs", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-fork-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			writeJsonl(parentSession, [{ type: "session", version: 1, id: "parent", cwd: "/tmp" }]);
+			writeJsonl(childSession, largeForkEntries(parentSession));
+			fs.chmodSync(childSession, 0o600);
+			const fullSize = fs.statSync(childSession).size;
+
+			assert.equal(await pruneForkSessionFile(childSession, async (payload) => validSummaryResponse(payload)), true);
+			const prunedText = fs.readFileSync(childSession, "utf-8");
+			const entries = prunedText.trim().split("\n").map((line) => JSON.parse(line));
+			const recovery = readRecovery(childSession);
+			const record = recovery.records[0]!;
+			assert.equal(entries[0].parentSession, parentSession);
+			assert.equal(recovery.parentSession, parentSession);
+			assert.equal(recovery.sourceHeadEntryId, "tool-result");
+			assert.equal(record.sourceEntryId, "tool-result");
+			assert.equal(record.kind, "tool-result");
+			assert.equal(record.toolCallId, "tool-1");
+			assert.equal(record.toolName, "read");
+			assert.equal(record.isError, false);
+			assert.equal(record.utf8Bytes, Buffer.byteLength(record.body, "utf8"));
+			assert.equal(record.utf16CodeUnits, record.body.length);
+			assert.match(record.bodyDigest, /^sha256:[a-f0-9]{64}$/);
+			assert.ok(prunedText.includes(`\\\"batchId\\\":\\\"${recovery.batchId}\\\"`));
+			assert.ok(prunedText.includes(`\\\"itemId\\\":\\\"${record.itemId}\\\"`));
+			assert.ok(prunedText.includes("Keep this recent user decision exact."));
+			assert.ok(!prunedText.includes("raw-parent-output-raw-parent-output"));
+			assert.ok(fs.statSync(childSession).size < fullSize / 4);
+			if (process.platform !== "win32") {
+				assert.equal(fs.statSync(childSession).mode & 0o777, 0o600);
+				assert.equal(fs.statSync(prunedForkRecoveryPath(childSession)).mode & 0o777, 0o600);
+			}
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("summarizes non-tool assistant overflow before user text", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-assistant-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			const assistantBody = "old-assistant-overflow-".repeat(4_000);
+			writeJsonl(childSession, [
+				{ type: "session", version: 1, id: "child", cwd: "/tmp", parentSession },
+				{ type: "message", id: "assistant-old", parentId: null, message: { role: "assistant", content: [{ type: "text", text: assistantBody }] } },
+				{ type: "message", id: "user-recent", parentId: "assistant-old", message: { role: "user", content: "Recent exact decision." } },
+			]);
+			await pruneForkSessionFile(childSession, async (payload) => validSummaryResponse(payload, "Older assistant context summarized."));
+			const text = fs.readFileSync(childSession, "utf-8");
+			assert.ok(text.includes("Older assistant context summarized."));
+			assert.ok(text.includes("Recent exact decision."));
+			assert.ok(!text.includes(assistantBody));
+			assert.equal(readRecovery(childSession).records[0]?.kind, "assistant-text");
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("fails closed for invalid JSON and missing item summaries", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-invalid-summary-"));
+		try {
+			const childSession = path.join(tempDir, "child.jsonl");
+			writeJsonl(childSession, largeForkEntries(path.join(tempDir, "parent.jsonl")));
+			const before = fs.readFileSync(childSession, "utf-8");
+			await assert.rejects(() => pruneForkSessionFile(childSession, async () => "not-json"), /invalid JSON/);
+			await assert.rejects(() => pruneForkSessionFile(childSession, async () => '{"summaries":[]}'), /exactly one summary/);
+			assert.equal(fs.readFileSync(childSession, "utf-8"), before);
+			assert.equal(fs.existsSync(prunedForkRecoveryPath(childSession)), false);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects a newline-escaped duplicate of a spilled raw body", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-raw-leak-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			const duplicateBody = "duplicate-overflow-body\n".repeat(1_800);
+			writeJsonl(childSession, [
+				{ type: "session", version: 1, id: "child", cwd: "/tmp", parentSession },
+				{ type: "message", id: "assistant-1", parentId: null, message: { role: "assistant", content: [{ type: "text", text: duplicateBody }] } },
+				{ type: "message", id: "assistant-2", parentId: "assistant-1", message: { role: "assistant", content: [{ type: "text", text: duplicateBody }] } },
+			]);
+			await assert.rejects(() => pruneForkSessionFile(childSession, async (payload) => validSummaryResponse(payload)), /raw overflow leak/);
+			assert.equal(fs.existsSync(prunedForkRecoveryPath(childSession)), false);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects a duplicate spilled tool-call argument after parsing", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-tool-call-leak-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			const duplicateValue = "duplicate-tool-call\n".repeat(2_160);
+			writeJsonl(childSession, [
+				{ type: "session", version: 1, id: "child", cwd: "/tmp", parentSession },
+				{ type: "message", id: "assistant-1", parentId: null, message: { role: "assistant", content: [{ type: "toolCall", id: "call-1", name: "write", arguments: { value: duplicateValue, path: "same.txt" } }] } },
+				{ type: "message", id: "assistant-2", parentId: "assistant-1", message: { role: "assistant", content: [{ type: "toolCall", id: "call-2", name: "write", arguments: { path: "same.txt", value: duplicateValue } }] } },
+			]);
+			await assert.rejects(() => pruneForkSessionFile(childSession, async (payload) => validSummaryResponse(payload)), /raw overflow leak/);
+			assert.equal(fs.existsSync(prunedForkRecoveryPath(childSession)), false);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("fails closed on recovery validation and an unspillable budget overflow", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-budget-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const invalidRecoverySession = path.join(tempDir, "invalid-recovery.jsonl");
+			writeJsonl(invalidRecoverySession, largeForkEntries(parentSession));
+			await assert.rejects(
+				() => pruneForkSessionFile(invalidRecoverySession, async (payload) => validSummaryResponse(payload), { validateRecovery: () => false }),
+				/recovery payload failed validation/,
+			);
+			assert.equal(fs.existsSync(prunedForkRecoveryPath(invalidRecoverySession)), false);
+
+			const opaqueSession = path.join(tempDir, "opaque.jsonl");
+			writeJsonl(opaqueSession, [
+				{ type: "session", version: 1, id: "child", cwd: "/tmp", parentSession },
+				{ type: "custom", id: "opaque-head", parentId: null, customType: "opaque", data: { raw: "x".repeat(80_000) } },
+			]);
+			await assert.rejects(() => pruneForkSessionFile(opaqueSession, async () => ""), /no spillable overflow items/);
+			assert.equal(fs.existsSync(prunedForkRecoveryPath(opaqueSession)), false);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("blocks fork use until overflow pruning succeeds and keeps thinking sanitization", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-resolver-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			writeJsonl(parentSession, [{ type: "session", version: 1, id: "parent", cwd: "/tmp" }]);
+			writeJsonl(childSession, largeForkEntries(parentSession));
+			const resolver = createForkContextResolver({ getSessionFile: () => parentSession, getLeafId: () => "tool-result" }, "fork", {
+				openSession: () => ({ createBranchedSession: () => childSession }),
+				pruneSession: (file) => pruneForkSessionFile(file, async (payload) => validSummaryResponse(payload)),
+			});
+
+			assert.throws(() => resolver.sessionFileForIndex(0), /before pruning completed/);
+			await resolver.prepareSessionForIndex(0);
+			assert.equal(resolver.sessionFileForIndex(0), childSession);
+			assert.equal(resolver.thinkingOverrideForIndex(0), "off");
+			const text = fs.readFileSync(childSession, "utf-8");
+			assert.ok(!text.includes("thinkingSignature"));
+			assert.equal(JSON.parse(text.split("\n")[0]!).parentSession, parentSession);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not expose a full fork after pruning fails", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-failure-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			writeJsonl(parentSession, [{ type: "session", version: 1, id: "parent", cwd: "/tmp" }]);
+			writeJsonl(childSession, largeForkEntries(parentSession));
+			const resolver = createForkContextResolver({ getSessionFile: () => parentSession, getLeafId: () => "tool-result" }, "fork", {
+				openSession: () => ({ createBranchedSession: () => childSession }),
+				pruneSession: async () => { throw new Error("model failed"); },
+			});
+			await assert.rejects(() => resolver.prepareSessionForIndex(0), /model failed/);
+			assert.throws(() => resolver.sessionFileForIndex(0), /before pruning completed/);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -5,6 +5,8 @@ import { normalizePublicSubagentExecution } from "../../src/extension/public-exe
 describe("public subagent execution normalization", () => {
 	it("accepts structured single-child, workflow, management, and schedules", () => {
 		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1" }), { ok: true, params: { workflowScript: "return 1" } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1", preflight: { version: 1, lanes: [] } }), { ok: true, params: { workflowScript: "return 1", preflight: { version: 1, lanes: [] } } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflowScriptPath: "workflows/review.js" }), { ok: true, params: { workflowScriptPath: "workflows/review.js" } });
 		const task = "Use `quotes`\nand newlines";
 		assert.deepEqual(normalizePublicSubagentExecution({ agent: " worker ", task, context: "fresh", async: false }), {
 			ok: true,
@@ -23,14 +25,7 @@ describe("public subagent execution normalization", () => {
 				output: true,
 			},
 		});
-		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker" }, { asyncByDefault: false }), {
-			ok: true,
-			params: {
-				agent: "worker",
-				output: true,
-			},
-		});
-		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", async: true }, { asyncByDefault: false }), {
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", async: true }), {
 			ok: true,
 			params: {
 				agent: "worker",
@@ -54,10 +49,34 @@ describe("public subagent execution normalization", () => {
 			},
 		});
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: " validate ", workflowScript: "return 1" }),
+			{ ok: true, params: { action: "validate", workflowScript: "return 1" } },
+		);
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: " validate ", workflowScriptPath: "workflow.js" }),
+			{ ok: true, params: { action: "validate", workflowScriptPath: "workflow.js" } },
+		);
 		assert.deepEqual(
 			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScript: "return 1" }),
 			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScript: "return 1" } },
 		);
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScriptPath: "/tmp/workflow.js" }),
+			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScriptPath: "/tmp/workflow.js" } },
+		);
+	});
+
+	it("rejects workflowScript with workflowScriptPath", () => {
+		const result = normalizePublicSubagentExecution({ workflowScript: "return 1", workflowScriptPath: "workflow.js" });
+		assert.equal(result.ok, false);
+		if (!result.ok) assert.match(result.error, /mutually exclusive/);
+	});
+
+	it("rejects preflight without a workflow input", () => {
+		const result = normalizePublicSubagentExecution({ agent: "worker", preflight: { version: 1, lanes: [] } });
+		assert.equal(result.ok, false);
+		if (!result.ok) assert.match(result.error, /preflight requires workflowScript or workflowScriptPath/);
 	});
 
 	it("rejects private run fan-out fields at the public boundary", () => {
@@ -77,6 +96,7 @@ describe("public subagent execution normalization", () => {
 			{ agent: "worker", workflowKey: "child" },
 			{ agent: "worker", workflowChildAsyncId: "child" },
 			{ agent: "worker", workflowAwaitAsync: true },
+			{ agent: "worker", workflowAwaitDetached: true },
 			{ agent: "worker", workflowParentDeadlineAt: Date.now() + 1_000 },
 			{ agent: "worker", suppressRoutineResultIntercom: true },
 		] as const) {
@@ -111,6 +131,7 @@ describe("public subagent execution normalization", () => {
 			{ resume: "retained-run", workflowScript: "return 1" },
 			{},
 			{ workflowScript: " " },
+			{ workflowScriptPath: " " },
 			{ action: "status", workflowScript: "return 1" },
 			{ action: "schedule.create", every: "1h", agent: "worker", workflowScript: "return 1" },
 			{ workflowScript: "return 1", isolation: "invalid" },