@selesai/code 0.13.39 → 0.14.0

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

@@ -64,9 +64,8 @@ describe("profiles helpers", () => {
 					scout: {
 						model: "openai-codex/gpt-5.3-codex-spark",
 						thinking: "medium",
-						fallbackModels: ["openai-codex/gpt-5.4-mini"],
 					},
-					reviewer: { thinking: false, fallbackModels: false },
+					reviewer: { thinking: false },
 				},
 			},
 		}, null, 2));
@@ -92,12 +91,95 @@ describe("profiles helpers", () => {
 			scout: {
 				model: "openai-codex/gpt-5.3-codex-spark",
 				thinking: "medium",
-				fallbackModels: ["openai-codex/gpt-5.4-mini"],
 			},
-			reviewer: { thinking: false, fallbackModels: false },
+			reviewer: { thinking: false },
 		});
 	});
 
+	it("keeps machine placement when a model profile replaces the override map", () => {
+		const profilesDir = getSubagentProfilesDir();
+		fs.mkdirSync(profilesDir, { recursive: true });
+		fs.writeFileSync(path.join(profilesDir, "quota.json"), JSON.stringify({
+			subagents: { agentOverrides: { scout: { model: "openai-codex/gpt-5.3-codex-spark" }, "claude-code": { thinking: false } } },
+		}, null, 2));
+		const settingsPath = path.join(homeDir, ".selesai", "agent", "settings.json");
+		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+		fs.writeFileSync(settingsPath, JSON.stringify({
+			subagents: { agentOverrides: { "claude-code": { machine: "workmac", model: "old" }, "codex-exec": { machine: "workmac" }, stale: { model: "remove-me" } } },
+		}, null, 2));
+
+		applySubagentProfile("quota");
+		const written = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+		assert.deepEqual(written.subagents.agentOverrides, {
+			scout: { model: "openai-codex/gpt-5.3-codex-spark" },
+			"claude-code": { thinking: false, machine: "workmac" },
+			"codex-exec": { machine: "workmac" },
+		});
+	});
+
+	it("rejects invalid profile machine values before changing settings", () => {
+		const profilesDir = getSubagentProfilesDir();
+		fs.mkdirSync(profilesDir, { recursive: true });
+		const settingsPath = path.join(homeDir, ".selesai", "agent", "settings.json");
+		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+		const originalSettings = '{\n  "defaultModel": "openai/gpt-5",\n  "subagents": {\n    "agentOverrides": {\n      "worker": {\n        "machine": "workmac",\n        "model": "old"\n      }\n    }\n  }\n}\n';
+		fs.writeFileSync(settingsPath, originalSettings);
+		const agentDir = path.join(homeDir, ".selesai", "agent", "agents");
+		fs.mkdirSync(agentDir, { recursive: true });
+		fs.writeFileSync(path.join(agentDir, "worker.md"), `---\nname: worker\ndescription: Existing worker\n---\n\nDo work.\n`);
+
+		const invalidMachines: unknown[] = [7, {}, null, "", "   ", "m".repeat(129), "work\u0000mac"];
+		for (const [index, machine] of invalidMachines.entries()) {
+			fs.writeFileSync(path.join(profilesDir, `invalid-machine-${index}.json`), JSON.stringify({
+				subagents: { agentOverrides: { worker: { machine } } },
+			}));
+
+			assert.throws(() => applySubagentProfile(`invalid-machine-${index}`), /has invalid machine for 'worker'/u);
+			assert.equal(fs.readFileSync(settingsPath, "utf-8"), originalSettings);
+		}
+		const worker = discoverAgents(process.cwd(), "both").agents.find((agent) => agent.name === "worker");
+		assert.equal(worker?.machine, "workmac");
+	});
+
+	it("applies a normalized machine and discovers the resulting pin", () => {
+		const profilesDir = getSubagentProfilesDir();
+		fs.mkdirSync(profilesDir, { recursive: true });
+		fs.writeFileSync(path.join(profilesDir, "machine.json"), JSON.stringify({
+			subagents: { agentOverrides: { worker: { machine: " local-runner " } } },
+		}));
+		const agentDir = path.join(homeDir, ".selesai", "agent", "agents");
+		fs.mkdirSync(agentDir, { recursive: true });
+		fs.writeFileSync(path.join(agentDir, "worker.md"), `---\nname: worker\ndescription: Profile-managed worker\n---\n\nDo work.\n`);
+
+		applySubagentProfile("machine");
+		const settings = JSON.parse(fs.readFileSync(path.join(homeDir, ".selesai", "agent", "settings.json"), "utf-8"));
+		assert.equal(settings.subagents.agentOverrides.worker.machine, "local-runner");
+		const worker = discoverAgents(process.cwd(), "both").agents.find((agent) => agent.name === "worker");
+		assert.equal(worker?.machine, "local-runner");
+	});
+
+	it("lets false clear an existing machine pin when applying a profile", () => {
+		const profilesDir = getSubagentProfilesDir();
+		fs.mkdirSync(profilesDir, { recursive: true });
+		fs.writeFileSync(path.join(profilesDir, "clear-machine.json"), JSON.stringify({
+			subagents: { agentOverrides: { worker: { machine: false } } },
+		}));
+		const agentDir = path.join(homeDir, ".selesai", "agent", "agents");
+		fs.mkdirSync(agentDir, { recursive: true });
+		fs.writeFileSync(path.join(agentDir, "worker.md"), `---\nname: worker\ndescription: Profile-managed worker\n---\n\nDo work.\n`);
+		const settingsPath = path.join(homeDir, ".selesai", "agent", "settings.json");
+		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+		fs.writeFileSync(settingsPath, JSON.stringify({
+			subagents: { agentOverrides: { worker: { machine: "workmac" } } },
+		}));
+
+		applySubagentProfile("clear-machine");
+		const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+		assert.equal(settings.subagents.agentOverrides.worker.machine, false);
+		const worker = discoverAgents(process.cwd(), "both").agents.find((agent) => agent.name === "worker");
+		assert.equal(worker?.machine, undefined);
+	});
+
 	it("applies profile models and thinking to user agents without frontmatter pins", () => {
 		const profilesDir = getSubagentProfilesDir();
 		fs.mkdirSync(profilesDir, { recursive: true });
@@ -108,7 +190,6 @@ describe("profiles helpers", () => {
 					worker: {
 						model: "bluebox-azure-openai/gpt-5_6-luna",
 						thinking: "high",
-						fallbackModels: ["bluebox-azure-openai/gpt-5_6-terra"],
 					},
 				},
 			},
@@ -123,12 +204,11 @@ describe("profiles helpers", () => {
 		assert.equal(worker?.source, "user");
 		assert.equal(worker?.model, "bluebox-azure-openai/gpt-5_6-luna");
 		assert.equal(worker?.thinking, "high");
-		assert.deepEqual(worker?.fallbackModels, ["bluebox-azure-openai/gpt-5_6-terra"]);
 		assert.equal(worker?.override?.scope, "user");
 		assert.equal(agents.some((agent) => agent.source === "builtin"), false);
 	});
 
-	it("rejects invalid profile fallback models", () => {
+	it("rejects removed profile fallback models", () => {
 		const profilesDir = getSubagentProfilesDir();
 		fs.mkdirSync(profilesDir, { recursive: true });
 		fs.writeFileSync(path.join(profilesDir, "invalid.json"), JSON.stringify({
@@ -139,7 +219,7 @@ describe("profiles helpers", () => {
 			},
 		}, null, 2));
 
-		assert.throws(() => applySubagentProfile("invalid"), /invalid fallbackModels.*array of strings or false/);
+		assert.throws(() => applySubagentProfile("invalid"), /removed field fallbackModels/);
 	});
 
 	it("rejects profile and provider path traversal names", async () => {
@@ -370,4 +450,4 @@ describe("profiles helpers", () => {
 		assert.equal(result.results[0]?.inRegistry, true);
 		assert.deepEqual(probedModels, ["openai-codex/gpt-5.3-codex-spark:high"]);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/prompt-audit-optional-peers.test.ts

@@ -11,10 +11,12 @@ test("ordinary prompt audit works without optional Pi peers", async () => {
 	const isolatedRoot = await mkdtemp(join(tmpdir(), "pi-subagents-prompt-audit-"));
 	const promptAuditPath = join(isolatedRoot, "src/runs/foreground/prompt-audit.ts");
 	const streamOptionsPath = join(isolatedRoot, "src/shared/agent-stream-options.ts");
+	const opencodeSessionHeadersPath = join(isolatedRoot, "src/shared/opencode-session-headers.ts");
 
 	try {
 		await mkdir(dirname(promptAuditPath), { recursive: true });
 		await mkdir(dirname(streamOptionsPath), { recursive: true });
+		await mkdir(dirname(opencodeSessionHeadersPath), { recursive: true });
 		await writeFile(
 			promptAuditPath,
 			await readFile(join(repositoryRoot, "src/runs/foreground/prompt-audit.ts"), "utf8"),
@@ -23,6 +25,10 @@ test("ordinary prompt audit works without optional Pi peers", async () => {
 			streamOptionsPath,
 			await readFile(join(repositoryRoot, "src/shared/agent-stream-options.ts"), "utf8"),
 		);
+		await writeFile(
+			opencodeSessionHeadersPath,
+			await readFile(join(repositoryRoot, "src/shared/opencode-session-headers.ts"), "utf8"),
+		);
 
 		const promptAudit = await import(pathToFileURL(promptAuditPath).href);
 		const control = {};

package/dist/extensions/pi-subagents/test/unit/prompt-audit-provider-routing.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	createAssistantMessageEventStream,
+	fauxAssistantMessage,
+	type Model,
+	type SimpleStreamOptions,
+	type TranscriptContext,
+} from "@earendil-works/pi-ai";
+import { rewritePromptWithGuidance } from "../../src/runs/foreground/prompt-audit.ts";
+
+function model(): Model<any> {
+	return {
+		id: "complete-provider-model",
+		name: "Complete provider model",
+		api: "custom-api",
+		provider: "complete-provider",
+		baseUrl: "https://opencode.ai",
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 100_000,
+		maxTokens: 4_096,
+	};
+}
+
+test("Prompt Audit rewrite uses the session model registry stream for complete providers", async () => {
+	const current = model();
+	const calls: Array<{ model: Model<any>; context: TranscriptContext; options?: SimpleStreamOptions }> = [];
+	const ctx = {
+		model: current,
+		signal: undefined,
+		sessionManager: { getSessionId: () => "prompt-audit-session" },
+		modelRegistry: {
+			getApiKeyAndHeaders: async () => ({
+				ok: true as const,
+				apiKey: "complete-provider-key",
+				headers: { "x-provider-auth": "present" },
+				env: { COMPLETE_PROVIDER: "1" },
+			}),
+			streamSimple(nextModel: Model<any>, context: TranscriptContext, options?: SimpleStreamOptions) {
+				calls.push({ model: nextModel, context, options });
+				const stream = createAssistantMessageEventStream();
+				queueMicrotask(() => stream.push({
+					type: "done",
+					reason: "stop",
+					message: fauxAssistantMessage("rewritten task", { stopReason: "stop" }),
+				}));
+				return stream;
+			},
+		},
+	} as never;
+
+	const rewritten = await rewritePromptWithGuidance({
+		ctx,
+		authoredTask: "original task",
+		runtimeAdditions: "runtime context",
+		finalEffectivePrompt: "runtime context\noriginal task",
+		guidance: "Make it concise.",
+	});
+
+	assert.equal(rewritten, "rewritten task");
+	assert.equal(calls.length, 1);
+	assert.equal(calls[0]?.model, current);
+	assert.equal(calls[0]?.options?.apiKey, "complete-provider-key");
+	assert.equal(calls[0]?.options?.headers?.["x-opencode-session"], "prompt-audit-session");
+	assert.equal(calls[0]?.options?.headers?.["x-provider-auth"], "present");
+	assert.deepEqual(calls[0]?.options?.env, { COMPLETE_PROVIDER: "1" });
+});

package/dist/extensions/pi-subagents/test/unit/prompt-template-bridge.test.ts

@@ -237,8 +237,8 @@ describe("prompt-template delegation bridge", () => {
 		});
 		const response = await tasksResponse as { isError: boolean; errorText?: string };
 		assert.equal(response.isError, true);
-		assert.match(response.errorText ?? "", /removed.*workflowScript/i);
+		assert.match(response.errorText ?? "", /removed.*workflow script/i);
 		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/prompt-workflows.test.ts

@@ -68,6 +68,28 @@ Project body $1
 		assert.equal(workflow?.model, "openai/gpt-5-mini");
 	});
 
+	it("discovers symlinked prompt files and skips dangling links", () => {
+		const promptsDir = path.join(agentDir, "prompts");
+		writePrompt(path.join(tempDir, "dotfiles"), "linked", `---
+description: Linked prompt
+---
+Say hi
+`);
+		fs.mkdirSync(promptsDir, { recursive: true });
+		fs.symlinkSync(path.join(tempDir, "dotfiles", "linked.md"), path.join(promptsDir, "linked.md"));
+		fs.symlinkSync(path.join(tempDir, "dotfiles", "missing.md"), path.join(promptsDir, "dangling.md"));
+
+		const names = discoverPromptWorkflows(cwd).map((entry) => entry.name);
+
+		assert.ok(names.includes("linked"), names.join(", "));
+		assert.equal(names.includes("dangling"), false);
+
+		if (process.platform !== "win32") {
+			fs.symlinkSync(path.join(promptsDir, "loop.md"), path.join(promptsDir, "loop.md"));
+			assert.throws(() => discoverPromptWorkflows(cwd), { code: "ELOOP" });
+		}
+	});
+
 	it("runs a named workflow through native subagent execution", async () => {
 		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-run", `---
 description: Run native prompt
@@ -164,4 +186,4 @@ Fix from {previous}: $@
 		]);
 		assert.equal(executed.value, "fixed output");
 	});
-});
+});

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

@@ -3,8 +3,10 @@ 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 { createAssistantMessageEventStream, fauxAssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@selesai/code";
 import { createForkContextResolver } from "../../src/shared/fork-context.ts";
-import { pruneForkSessionFile, prunedForkRecoveryPath, type PrunedForkRecoveryPayload } from "../../src/shared/pruned-fork.ts";
+import { createPrunedForkSessionWriter, pruneForkSessionFile, prunedForkRecoveryPath, type PrunedForkRecoveryPayload } from "../../src/shared/pruned-fork.ts";
 
 function writeJsonl(filePath: string, entries: unknown[]): void {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -33,6 +35,73 @@ function readRecovery(sessionFile: string): PrunedForkRecoveryPayload {
 }
 
 describe("pruned fork sessions", () => {
+	it("routes summaries through the Pi model registry with provider-neutral request options", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-registry-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const firstSession = path.join(tempDir, "first.jsonl");
+			const secondSession = path.join(tempDir, "second.jsonl");
+			writeJsonl(firstSession, largeForkEntries(parentSession));
+			writeJsonl(secondSession, largeForkEntries(parentSession));
+			type RegistryStreamArgs = Parameters<ExtensionContext["modelRegistry"]["streamSimple"]>;
+			type RegistryCall = { model: RegistryStreamArgs[0]; context: RegistryStreamArgs[1]; options: RegistryStreamArgs[2] };
+			const model: RegistryStreamArgs[0] = {
+				provider: "extension-provider",
+				id: "summary-model",
+				name: "Summary model",
+				api: "pi-registry-only",
+				baseUrl: "https://summary.invalid",
+				reasoning: false,
+				input: ["text"],
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+				contextWindow: 16_000,
+				maxTokens: 9_000,
+			};
+			const controller = new AbortController();
+			const calls: RegistryCall[] = [];
+			const modelRegistry = {
+				getAvailable: () => [model],
+				find: (provider: string, id: string) => provider === model.provider && id === model.id ? model : undefined,
+				streamSimple(streamModel: RegistryStreamArgs[0], context: RegistryStreamArgs[1], options?: RegistryStreamArgs[2]) {
+					calls.push({ model: streamModel, context, options });
+					const input = context.messages[0];
+					if (input?.role !== "user" || !Array.isArray(input.content) || input.content[0]?.type !== "text") throw new Error("expected summary payload");
+					const stream = createAssistantMessageEventStream();
+					queueMicrotask(() => stream.push({
+						type: "done",
+						reason: "stop",
+						message: fauxAssistantMessage(validSummaryResponse(input.content[0].text), { stopReason: "stop" }),
+					}));
+					return stream;
+				},
+			};
+			const writer = await createPrunedForkSessionWriter({ modelRegistry }, {
+				mode: "pruned",
+				model: "extension-provider/summary-model",
+			}, controller.signal);
+
+			await Promise.all([writer(firstSession), writer(secondSession)]);
+
+			assert.equal(calls.length, 1, "forks share one registry-routed summary request");
+			const call = calls[0];
+			assert.ok(call);
+			assert.equal(call.model, model);
+			assert.ok(call.options);
+			assert.deepEqual(Object.keys(call.options).sort(), ["maxTokens", "signal"]);
+			assert.equal(call.options.maxTokens, 4_096);
+			assert.equal(call.options.signal, controller.signal);
+			assert.match(call.context.systemPrompt ?? "", /Return strict JSON only/);
+			assert.equal(call.context.messages.length, 1);
+			const message = call.context.messages[0];
+			assert.ok(message);
+			assert.equal(message.role, "user");
+			assert.equal(readRecovery(firstSession).records.length, 1);
+			assert.equal(readRecovery(secondSession).records.length, 1);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
 	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 {
@@ -95,6 +164,51 @@ describe("pruned fork sessions", () => {
 		}
 	});
 
+	it("summarizes context-edit replacement overflow", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-context-edit-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			const replacement = "replacement-overflow-".repeat(5_000);
+			writeJsonl(childSession, [
+				{ type: "session", version: 3, id: "child", cwd: "/tmp", parentSession },
+				{ type: "message", id: "user-1", parentId: null, message: { role: "user", content: "Original prompt." } },
+				{ type: "context_edit", id: "edit-1", parentId: "user-1", targetId: "user-1", replacement: { content: replacement } },
+			]);
+
+			await pruneForkSessionFile(childSession, async (payload) => validSummaryResponse(payload, "Replacement context summarized."));
+
+			const entries = fs.readFileSync(childSession, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+			assert.match(entries[2].replacement.content, /^Replacement context summarized\.\nRecovery ref:/);
+			assert.ok(!fs.readFileSync(childSession, "utf-8").includes(replacement));
+			assert.equal(readRecovery(childSession).records[0]?.sourceEntryId, "edit-1");
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves null context-edit omissions while pruning their raw target", async () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-pruned-context-omission-"));
+		try {
+			const parentSession = path.join(tempDir, "parent.jsonl");
+			const childSession = path.join(tempDir, "child.jsonl");
+			const omitted = "omitted-overflow-".repeat(5_000);
+			writeJsonl(childSession, [
+				{ type: "session", version: 3, id: "child", cwd: "/tmp", parentSession },
+				{ type: "message", id: "user-1", parentId: null, message: { role: "user", content: omitted } },
+				{ type: "context_edit", id: "edit-1", parentId: "user-1", targetId: "user-1", replacement: null },
+			]);
+
+			await pruneForkSessionFile(childSession, async (payload) => validSummaryResponse(payload, "Omitted raw context summarized."));
+
+			const entries = fs.readFileSync(childSession, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+			assert.equal(entries[2].replacement, null);
+			assert.ok(!fs.readFileSync(childSession, "utf-8").includes(omitted));
+		} 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 {
@@ -185,9 +299,9 @@ describe("pruned fork sessions", () => {
 			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.ok(!text.includes("thinking_level_change"));
 			assert.equal(JSON.parse(text.split("\n")[0]!).parentSession, parentSession);
 		} finally {
 			fs.rmSync(tempDir, { recursive: true, force: true });
@@ -211,4 +325,4 @@ describe("pruned fork sessions", () => {
 			fs.rmSync(tempDir, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -5,9 +5,12 @@ 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", globalConcurrencyLimit: 4, maxSubagentSpawnsPerRun: 8 }), { ok: true, params: { workflowScript: "return 1", globalConcurrencyLimit: 4, maxSubagentSpawnsPerRun: 8 } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return args.task", args: { task: "review" } }), { ok: true, params: { workflowScript: "return args.task", args: { task: "review" } } });
 		assert.deepEqual(normalizePublicSubagentExecution({ workflow: "review", args: { task: "Review this" } }), { ok: true, params: { workflow: "review", args: { task: "Review this" } } });
 		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", globalConcurrencyLimit: 2 }), { ok: true, params: { workflowScriptPath: "workflows/review.js", globalConcurrencyLimit: 2 } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflow: "workflows/review.js", globalConcurrencyLimit: 2 }), { ok: true, params: { workflow: "workflows/review.js", globalConcurrencyLimit: 2 } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflow: "workflows/review.js", args: { task: "review" } }), { ok: true, params: { workflow: "workflows/review.js", args: { task: "review" } } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflow: true, maxSubagentSpawnsPerRun: 8, preflight: { version: 1, lanes: [] } }), { ok: true, params: { workflow: true, maxSubagentSpawnsPerRun: 8, preflight: { version: 1, lanes: [] } } });
 		const task = "Use `quotes`\nand newlines";
 		assert.deepEqual(normalizePublicSubagentExecution({ agent: " worker ", task, context: "fresh", async: false }), {
 			ok: true,
@@ -55,20 +58,26 @@ describe("public subagent execution normalization", () => {
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list ", capabilities: true }), { ok: true, params: { action: "list", capabilities: true } });
 		assert.deepEqual(
-			normalizePublicSubagentExecution({ action: " validate ", workflowScript: "return 1" }),
-			{ ok: true, params: { action: "validate", workflowScript: "return 1" } },
+			normalizePublicSubagentExecution({ action: " validate ", workflowScript: "return args.task", args: { task: "review" } }),
+			{ ok: true, params: { action: "validate", workflowScript: "return args.task", args: { task: "review" } } },
 		);
 		assert.deepEqual(
-			normalizePublicSubagentExecution({ action: " validate ", workflowScriptPath: "workflow.js" }),
-			{ ok: true, params: { action: "validate", workflowScriptPath: "workflow.js" } },
+			normalizePublicSubagentExecution({ action: " validate ", workflow: "./workflow.js" }),
+			{ ok: true, params: { action: "validate", workflow: "./workflow.js" } },
 		);
+		const windowsPath = { workflow: "C:\\ci\\sweep.js", preflight: { version: 1, coverage: "complete", lanes: [{ key: "main", mode: "mutation" }] } };
+		assert.deepEqual(normalizePublicSubagentExecution(windowsPath), { ok: true, params: windowsPath }, "a Windows script path is a path, not a resource name");
 		assert.deepEqual(
-			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScript: "return 1" }),
-			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScript: "return 1" } },
+			normalizePublicSubagentExecution({ action: " validate ", workflowScript: "return 1", maxSubagentSpawnsPerRun: 5 }),
+			{ ok: true, params: { action: "validate", workflowScript: "return 1", maxSubagentSpawnsPerRun: 5 } },
 		);
 		assert.deepEqual(
-			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScriptPath: "/tmp/workflow.js" }),
-			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScriptPath: "/tmp/workflow.js" } },
+			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScript: "return args.task", args: { task: "review" } }),
+			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScript: "return args.task", args: { task: "review" } } },
+		);
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflow: true }),
+			{ ok: true, params: { action: "schedule.create", every: "1h", workflow: true } },
 		);
 	});
 
@@ -93,17 +102,21 @@ describe("public subagent execution normalization", () => {
 		});
 	});
 
-	it("rejects workflowScript with workflowScriptPath", () => {
-		const result = normalizePublicSubagentExecution({ workflowScript: "return 1", workflowScriptPath: "workflow.js" });
+	it("rejects the removed workflowScriptPath field and names the path form", () => {
+		const result = normalizePublicSubagentExecution({ workflowScriptPath: "workflow.js" });
 		assert.equal(result.ok, false);
-		if (!result.ok) assert.match(result.error, /mutually exclusive/);
+		if (!result.ok) assert.match(result.error, /workflowScriptPath was removed.*workflow: "\.\/path\/to\/script\.js"/);
 	});
 
 	it("rejects named workflow combinations and caller-controlled provenance fields", () => {
 		for (const params of [
 			{ workflow: "review", workflowScript: "return 1" },
-			{ workflow: "review", workflowScriptPath: "workflow.js" },
+			{ workflow: true, workflowScript: "return 1" },
 			{ workflow: "review", agent: "worker" },
+			{ workflow: true, agent: "worker" },
+			{ workflow: false },
+			{ workflow: "review", preflight: { version: 1, lanes: [] } },
+			{ action: "validate", workflow: "review" },
 			{ workflow: "review", task: "work" },
 			{ args: { task: "work" } },
 			{ workflow: "review", resource: { kind: "workflow" } },
@@ -115,6 +128,14 @@ describe("public subagent execution normalization", () => {
 		}
 	});
 
+	it("rejects bare arguments and arguments on direct child launches", () => {
+		for (const params of [{ args: {} }, { agent: "worker", task: "work", args: {} }] as const) {
+			const result = normalizePublicSubagentExecution(params);
+			assert.equal(result.ok, false);
+			if (!result.ok) assert.match(result.error, /args requires workflow/);
+		}
+	});
+
 	it("keeps raw workflow inputs untrusted and rejects invalid named-resource arguments", () => {
 		const raw = normalizePublicSubagentExecution({ workflowScript: `return await runs.host("ci", { kind: "command", command: "npm test", timeoutMs: 1000 });` });
 		assert.equal(raw.ok, true);
@@ -132,7 +153,7 @@ describe("public subagent execution normalization", () => {
 	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/);
+		if (!result.ok) assert.match(result.error, /preflight requires workflow: true or a workflow script path/);
 	});
 
 	it("rejects private run fan-out fields at the public boundary", () => {

package/dist/extensions/pi-subagents/test/unit/readonly-drain-observation.test.ts

@@ -68,7 +68,7 @@ it("observes true before wait, preserves waits/errors/deadlines and never certif
 		assert.equal(waits, mode === "false" || mode === "predicate throw" ? 0 : 1);
 		assert.equal(proof.settled(), false);
 	}
-	for (const injection of [{ hasWork: () => false }, { wait: async () => done }, { now: Date.now }]) {
+	for (const injection of [{ hasWork: () => false }, { wait: async () => done }, { now: Date.now }, { hasPendingSupervisorRequest: () => false }]) {
 		const proof = observation(); await drainOutstandingWork({ state, ...injection }, proof); assert.equal(proof.settled(), false);
 	}
 });
@@ -147,7 +147,8 @@ for (const kind of ["empty", "dead-owned", "result-queued-owned", "result-runnin
 				assert.equal(counts.index, 1, "first predicate is false, with no wait/final requery");
 				if (proof) assert.equal(proof.settled(), ["empty", "unrelated-running", "unrelated-dead", "terminal-owned", "unrelated-scale"].includes(kind));
 				const capturedCounts = { ...counts };
-				if (kind.includes("dead")) assert.equal(JSON.parse(originalRead(join(dirs[0], "status.json"), "utf8")).state, "failed", "ordinary dead-PID repair remains");
+				if (kind === "dead-owned") assert.equal(JSON.parse(originalRead(join(dirs[0], "status.json"), "utf8")).state, "failed", "owned dead-PID repair remains");
+				if (kind === "unrelated-dead") assert.equal(JSON.parse(originalRead(join(dirs[0], "status.json"), "utf8")).state, "running", "session-scoped drain leaves foreign runs untouched");
 				if (kind.startsWith("result-")) assert.equal(JSON.parse(originalRead(join(dirs[0], "status.json"), "utf8")).state, "complete", "ordinary result repair remains");
 				return { counts: capturedCounts, outcome };
 			} finally {