@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/orca-progress-tabs.test.ts

@@ -193,11 +193,19 @@ test("malformed optional observer metadata cannot break child execution", { skip
 		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
 	} as never);
 	assert.ok(tab);
-	tab.finish("completed");
-	await waitForFile(capture);
+	await tab.finish("completed");
+	// Capture precedes the watchdog's final manifest/queue writes; wait for its close.
+	await tab.creationSettled;
 	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
 	assert.equal(args[args.indexOf("--title") + 1], "subagents · subagent · 1");
-	removeProgressFiles("run-0-");
+	const manifestDir = path.join(dir, ".pi-subagents", "views", "orca");
+	const [manifestName] = fs.readdirSync(manifestDir);
+	const manifest = JSON.parse(fs.readFileSync(path.join(manifestDir, manifestName!), "utf-8"));
+	assert.equal(manifest.state, "open");
+	const viewer = args[args.indexOf("--command") + 1]!;
+	assert.match(await captureCommand(viewer, dir), /completed/);
+	assert.equal(fs.existsSync(manifest.logPath), false);
+	assert.equal(fs.existsSync(manifest.logPath.replace(/\.log$/, ".done")), false);
 });
 
 test("disabled Orca progress tabs do not invoke Orca", async () => {
@@ -272,7 +280,7 @@ test("enabled tabs use a worktree sequence and successful Pi sessions get cleanu
 	assert.match(text, /done output/);
 	const quotedSessionFile = `'${fs.realpathSync(sessionFile).replace(/'/g, `'"'"'`)}'`;
 	assert.ok(text.includes(`completed. To remove the Pi session for this run, run rm -- ${quotedSessionFile}`));
-	assert.doesNotMatch(text, /find ~\/\.selesai[\\/]agent\/sessions/);
+	assert.doesNotMatch(text, /find ~\/\.selesai\/agent\/sessions/);
 
 	const nestedCwd = path.join(dir, "packages", "app");
 	fs.mkdirSync(nestedCwd, { recursive: true });
@@ -542,4 +550,4 @@ test("mirror output truncates at a finite byte bound", { skip: process.platform
 	const text = fs.readFileSync(log, "utf-8");
 	assert.match(text, /progress mirror truncated at 1048576 bytes/);
 	assert.doesNotMatch(text, /must be dropped/);
-});
+});

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

@@ -37,6 +37,17 @@ test("the root entrypoint exposes the runtime error flag to TypeScript consumers
 		fs.writeFileSync(path.join(consumerRoot, "consumer.ts"), `
 import "pi-subagents";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { registerWorkflowResource, type RegisterWorkflowResourceInput, type WorkflowResourceDefinition, type WorkflowResourceRegistration } from "pi-subagents/workflow-resources";
+
+const definition: WorkflowResourceDefinition = {
+	name: "consumer.check", version: 1,
+	resolve: (args) => typeof args.task === "string"
+		? { script: "return 1;", hostCommands: [{ key: "check", command: "node --version" }] }
+		: { error: "task required" },
+};
+const input: RegisterWorkflowResourceInput = { sessionId: "consumer", definition };
+const registration: WorkflowResourceRegistration = registerWorkflowResource(input);
+registration.dispose();
 
 const result: AgentToolResult<undefined> = {
 	content: [],
@@ -60,6 +71,7 @@ void result.isError;
 				baseUrl: consumerRoot,
 				paths: {
 					"pi-subagents": [path.join(projectRoot, "index.ts")],
+					"pi-subagents/workflow-resources": [path.join(projectRoot, "src/api/workflow-resources.ts")],
 				"@earendil-works/pi-agent-core": [path.join(projectRoot, "node_modules", "@earendil-works", "pi-agent-core", "dist", "index.d.ts")],
 				},
 			},
@@ -108,11 +120,12 @@ test("published extension APIs use supported package entrypoints", async () => {
 		"./external-job-provider": "./src/api/external-job-provider.ts",
 		"./external-runs": "./src/api/external-runs.ts",
 		"./capability-ceiling": "./src/api/capability-ceiling.ts",
+		"./workflow-resources": "./src/api/workflow-resources.ts",
 		"./delegation": "./src/api/delegation.ts",
 		"./preflight": "./src/api/preflight.ts",
 		"./control-channel": "./src/api/control-channel.ts",
 		"./intercom-bridge": "./src/api/intercom-bridge.ts",
-		"./pi-args": "./src/api/pi-args.ts",
+		"./child-tool-plan": "./src/api/child-tool-plan.ts",
 		"./shared-types": "./src/api/shared-types.ts",
 		"./project-panes": "./src/api/project-panes.ts",
 	});
@@ -134,6 +147,9 @@ test("published extension APIs use supported package entrypoints", async () => {
 	assert.equal(typeof externalRuns.snapshotExternalRuns, "function");
 	assert.equal(typeof externalRuns.unregisterExternalRun, "function");
 	const capability = await import("pi-subagents/capability-ceiling");
+	const workflowResources = await import("pi-subagents/workflow-resources");
+	assert.deepEqual(Object.keys(workflowResources), ["registerWorkflowResource"]);
+	assert.equal(typeof workflowResources.registerWorkflowResource, "function");
 	assert.equal(capability.SUBAGENT_CAPABILITY_CEILING_VERSION, 1);
 	assert.equal(capability.SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY, "pi-subagents.capability-ceiling.v1");
 	const delegation = await import("pi-subagents/delegation");
@@ -145,9 +161,9 @@ test("published extension APIs use supported package entrypoints", async () => {
 	assert.equal(typeof controlChannel.requestAsyncStop, "function");
 	const intercomBridge = await import("pi-subagents/intercom-bridge");
 	assert.equal(typeof intercomBridge.resolveIntercomSessionTarget, "function");
-	const piArgs = await import("pi-subagents/pi-args");
-	assert.equal(typeof piArgs.resolvePiLaunchToolPlan, "function");
-	assert.equal("buildPiArgs" in piArgs, false);
+	const childToolPlan = await import("pi-subagents/child-tool-plan");
+	assert.equal(typeof childToolPlan.resolvePiLaunchToolPlan, "function");
+	assert.deepEqual(Object.keys(childToolPlan).sort(), ["resolvePiLaunchToolPlan"]);
 	const sharedTypes = await import("pi-subagents/shared-types");
 	assert.equal(typeof sharedTypes.wrapForkTask, "function");
 	assert.equal(typeof sharedTypes.DEFAULT_FORK_PREAMBLE, "string");
@@ -238,4 +254,4 @@ test("Pi package resolution stays export-map safe", () => {
 		assert.equal(piPackageJsonSubpathPattern.test(source), false, `${file} should not resolve unexported package.json subpaths`);
 		assert.equal(cjsPiPackageResolutionPattern.test(source), false, `${file} should not use CommonJS resolution for ESM-only Pi packages`);
 	}
-});
+});

package/dist/extensions/pi-subagents/test/unit/parallel-handoff.test.ts

@@ -11,7 +11,6 @@ import {
 	recordParallelHandoffSupersession,
 	resolveParallelHandoffChild,
 	writeParallelHandoffGroup,
-	writePendingParallelHandoff,
 } from "../../src/runs/shared/parallel-handoff.ts";
 import type { ParallelHandoffManifest } from "../../src/shared/types.ts";
 import type { WorktreeCleanupReport, WorktreeDiff, WorktreeSetup } from "../../src/runs/shared/worktree.ts";
@@ -56,7 +55,8 @@ describe("parallel handoff", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-parallel-handoff-pending-"));
 		try {
 			const manifestPath = path.join(dir, "handoff.json");
-			const reference = writePendingParallelHandoff({
+			const reference = writeParallelHandoffGroup({
+				diffs: [], results: [],
 				manifestPath,
 				runId: "run-pending",
 				mode: "parallel",
@@ -416,7 +416,8 @@ describe("parallel handoff", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-parallel-handoff-merge-unknown-"));
 		try {
 			const manifestPath = path.join(dir, "handoff.json");
-			writePendingParallelHandoff({
+			writeParallelHandoffGroup({
+				diffs: [], results: [],
 				manifestPath,
 				runId: "lane-unknown",
 				mode: "single",
@@ -560,4 +561,4 @@ describe("parallel handoff", () => {
 			fs.rmSync(dir, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -1,8 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
-	decodePermissionRules,
-	encodePermissionRules,
 	permissionArgsPreview,
 	permissionDecision,
 	resolvePermissionRules,
@@ -31,9 +29,7 @@ describe("native child permissions", () => {
 		assert.throws(() => validatePermissionConfig({ rules: { write: "sometimes" } }), /allow, ask, or deny/);
 	});
 
-	it("round-trips only explicit non-allow rules and redacts bounded previews", () => {
-		const encoded = encodePermissionRules({ write: "ask" });
-		assert.deepEqual(decodePermissionRules(encoded), { write: "ask" });
+	it("redacts bounded argument previews", () => {
 		const preview = permissionArgsPreview({ token: "secret-value", content: `Bearer abcdefghijklmnop ${"x".repeat(3000)}` });
 		assert.doesNotMatch(preview, /secret-value|abcdefghijklmnop/);
 		assert.ok(Buffer.byteLength(preview) <= 2048);
@@ -43,4 +39,4 @@ describe("native child permissions", () => {
 		assert.doesNotMatch(multibytePreview, /�/);
 		assert.match(multibytePreview, /…$/);
 	});
-});
+});

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

@@ -158,7 +158,7 @@ Inspect env.
 		assert.equal(fs.existsSync(path.join(agentDir, "agents", `${createdName}.md`)), true);
 	});
 
-	it("ignores nested .selesai and sync-backups agent definitions", () => {
+	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, `---
@@ -292,6 +292,32 @@ Package skill content.
 		assert.throws(() => updateConfig((config) => config), /config\.defaultSubagentContext must be "fresh" or "fork"/);
 	});
 
+	it("loads exact model response aliases and preserves them during config updates", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		const modelResponseAliases = {
+			"databricks-bedrock/ias-claude-opus-5": ["claude-opus-5", "exact/Response:high"],
+			"gateway/owner/model": [],
+		};
+		writeFile(configPath, JSON.stringify({ modelResponseAliases }));
+		assert.deepEqual(loadConfig().modelResponseAliases, modelResponseAliases);
+		updateConfig((config) => ({ ...config, asyncByDefault: false }));
+		assert.deepEqual(loadConfig(), { modelResponseAliases, asyncByDefault: false });
+		writeFile(configPath, JSON.stringify({ modelResponseAliases: {} }));
+		assert.deepEqual(loadConfig().modelResponseAliases, {});
+	});
+
+	it("fails config load for malformed model response aliases with useful diagnostics", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		for (const modelResponseAliases of [null, [], "alias", { "": [] }, { model: [] }, { "/model": [] }, { "provider/ ": [] }, { " /model": [] }]) {
+			writeFile(configPath, JSON.stringify({ modelResponseAliases }));
+			assert.throws(() => loadConfig(), /config\.modelResponseAliases.*(?:JSON object|provider\/model ID)/);
+		}
+		for (const aliases of [null, "response", [""], [" "], [1], ["valid", false]]) {
+			writeFile(configPath, JSON.stringify({ modelResponseAliases: { "provider/model": aliases } }));
+			assert.throws(() => loadConfig(), /config\.modelResponseAliases\["provider\/model"\].*array of non-empty response ID strings/);
+		}
+	});
+
 	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");
@@ -458,4 +484,4 @@ Package skill content.
 		assert.equal(bridge.extensionDir, "native:pi-subagents-supervisor-channel");
 		assert.match(bridge.instruction, /Native bridge for main/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/pi-web-session-liveness.test.ts

@@ -0,0 +1,209 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import {
+	hasLiveSubagentWork,
+	PI_WEB_SESSION_LIVENESS_REGISTRY_KEY,
+	registerPiWebSessionLiveness,
+	retainLiveForegroundNestedRoute,
+} from "../../src/integrations/pi-web-session-liveness.ts";
+import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
+import { removeForegroundControlIfIdle } from "../../src/runs/foreground/subagent-executor.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+function clearRegistry(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(PI_WEB_SESSION_LIVENESS_REGISTRY_KEY)];
+}
+
+const routeRoots: string[] = [];
+
+afterEach(() => {
+	clearRegistry();
+	for (const root of routeRoots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function nestedRoute(rootRunId: string) {
+	const route = createNestedRoute(rootRunId);
+	routeRoots.push(path.dirname(route.eventSink));
+	return route;
+}
+
+function writeNestedState(route: ReturnType<typeof nestedRoute>, state: "running" | "complete", ts: number): void {
+	writeNestedEvent(route, {
+		type: state === "running" ? "subagent.nested.updated" : "subagent.nested.completed",
+		ts,
+		parentRunId: route.rootRunId,
+		parentStepIndex: 0,
+		child: {
+			id: "nested-child",
+			parentRunId: route.rootRunId,
+			parentStepIndex: 0,
+			depth: 1,
+			path: [{ runId: route.rootRunId, stepIndex: 0 }],
+			state,
+			agent: "worker",
+			lastUpdate: ts,
+		},
+	});
+}
+
+function makeState(): Parameters<typeof hasLiveSubagentWork>[0] {
+	return {
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+	};
+}
+
+describe("pi-web session liveness integration", () => {
+	it("reports only queued or running async jobs as live", () => {
+		const state = makeState();
+		state.asyncJobs.set("retained", { status: "complete" } as never);
+		assert.equal(hasLiveSubagentWork(state), false);
+
+		state.asyncJobs.set("queued", { status: "queued" } as never);
+		assert.equal(hasLiveSubagentWork(state), true);
+		state.asyncJobs.delete("queued");
+
+		state.asyncJobs.set("running", { status: "running" } as never);
+		assert.equal(hasLiveSubagentWork(state), true);
+	});
+
+	it("keeps a terminal parent live while a nested descendant is active", () => {
+		const state = makeState();
+		const nestedChild = { state: "running" };
+		state.asyncJobs.set("parent", {
+			status: "complete",
+			nestedChildren: [{ state: "complete", children: [nestedChild] }],
+		} as never);
+		assert.equal(hasLiveSubagentWork(state), true);
+
+		nestedChild.state = "complete";
+		assert.equal(hasLiveSubagentWork(state), false);
+	});
+
+	it("reports foreground scheduling or active children as live", () => {
+		const state = makeState();
+		state.foregroundControls.set("settled", { schedulingOwners: 0, activeChildren: new Map() } as never);
+		assert.equal(hasLiveSubagentWork(state), false);
+
+		state.foregroundControls.set("scheduling", { schedulingOwners: 1, activeChildren: new Map() } as never);
+		assert.equal(hasLiveSubagentWork(state), true);
+		state.foregroundControls.delete("scheduling");
+
+		state.foregroundControls.set("child", { schedulingOwners: 0, activeChildren: new Map([[0, {}]]) } as never);
+		assert.equal(hasLiveSubagentWork(state), true);
+	});
+
+	it("retains a foreground nested route until its async descendant finishes", () => {
+		const state = makeState();
+		const route = nestedRoute("foreground-root");
+		writeNestedState(route, "running", 100);
+
+		assert.equal(retainLiveForegroundNestedRoute(state, route), true);
+		assert.equal(state.retainedForegroundNestedRoutes?.has(route.rootRunId), true);
+		assert.equal(hasLiveSubagentWork(state), true);
+
+		writeNestedState(route, "complete", 200);
+		assert.equal(hasLiveSubagentWork(state), true, "the synchronous probe reads only its cached projection");
+	});
+
+	it("does not retain foreground nested routes without a host registration", () => {
+		const state = makeState() as SubagentState;
+		const route = nestedRoute("unregistered-foreground-root");
+		writeNestedState(route, "running", 100);
+		state.foregroundControls.set(route.rootRunId, {
+			runId: route.rootRunId,
+			mode: "single",
+			startedAt: 1,
+			updatedAt: 1,
+			schedulingOwners: 0,
+			activeChildren: new Map(),
+			nestedRoute: route,
+		});
+
+		const liveness = registerPiWebSessionLiveness({ sessionId: "session-a", isActive: () => true });
+		assert.equal(liveness.registered, false);
+		assert.equal(removeForegroundControlIfIdle(state, route.rootRunId), true);
+		assert.equal(state.retainedForegroundNestedRoutes, undefined);
+	});
+
+	it("transfers a live nested route before removing its settled foreground control", () => {
+		const state = makeState() as SubagentState;
+		const route = nestedRoute("settled-foreground-root");
+		writeNestedState(route, "running", 100);
+		state.foregroundControls.set(route.rootRunId, {
+			runId: route.rootRunId,
+			mode: "single",
+			startedAt: 1,
+			updatedAt: 1,
+			schedulingOwners: 0,
+			activeChildren: new Map(),
+			nestedRoute: route,
+		});
+		let tracked: string | undefined;
+
+		assert.equal(removeForegroundControlIfIdle(state, route.rootRunId, (rootRunId) => { tracked = rootRunId; }), true);
+		assert.equal(state.foregroundControls.has(route.rootRunId), false);
+		assert.equal(state.retainedForegroundNestedRoutes?.has(route.rootRunId), true);
+		assert.equal(tracked, route.rootRunId);
+	});
+
+	it("does not retain foreground routes without live descendants", () => {
+		const state = makeState();
+		const route = nestedRoute("terminal-foreground-root");
+		writeNestedState(route, "complete", 100);
+
+		assert.equal(retainLiveForegroundNestedRoute(state, route), false);
+		assert.equal(state.retainedForegroundNestedRoutes, undefined);
+	});
+
+	it("is a no-op outside pi-web or with an incompatible protocol", () => {
+		const releaseWithoutHost = registerPiWebSessionLiveness({
+			sessionId: "session-a",
+			isActive: () => true,
+		});
+		assert.equal(releaseWithoutHost.registered, false);
+		releaseWithoutHost.release();
+		let registered = false;
+		(globalThis as Record<PropertyKey, unknown>)[Symbol.for(PI_WEB_SESSION_LIVENESS_REGISTRY_KEY)] = {
+			version: 2,
+			register() {
+				registered = true;
+				return () => {};
+			},
+		};
+		const incompatible = registerPiWebSessionLiveness({ sessionId: "session-a", isActive: () => true });
+		assert.equal(incompatible.registered, false);
+		assert.equal(registered, false);
+	});
+
+	it("registers exact session aliases and returns the host release function", () => {
+		let provider: { name: string; sessionId: string; sessionFile?: string; isActive(): boolean } | undefined;
+		let released = 0;
+		(globalThis as Record<PropertyKey, unknown>)[Symbol.for(PI_WEB_SESSION_LIVENESS_REGISTRY_KEY)] = {
+			version: 1,
+			register(value: typeof provider) {
+				provider = value;
+				return () => { released += 1; };
+			},
+		};
+
+		let active = true;
+		const release = registerPiWebSessionLiveness({
+			sessionId: "session-a",
+			sessionFile: "/tmp/session-a.jsonl",
+			isActive: () => active,
+		});
+		assert.equal(release.registered, true);
+		assert.equal(provider?.name, "pi-subagents");
+		assert.equal(provider?.sessionId, "session-a");
+		assert.equal(provider?.sessionFile, "/tmp/session-a.jsonl");
+		assert.equal(provider?.isActive(), true);
+		active = false;
+		assert.equal(provider?.isActive(), false);
+
+		release.release();
+		assert.equal(released, 1);
+	});
+});

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

@@ -157,6 +157,43 @@ Project prompt.
 		}
 	});
 
+	it("projects concurrent children under distinct run-id roots for an explicit sessionDir", async () => {
+		const cwd = path.join(tempDir, "repo-session-dir-keying");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---\nname: worker\ndescription: Project worker\n---\nWorker.\n`);
+		const sessionDir = path.join(tempDir, "caller-sessions");
+		const runIds = ["run-123", "run-456"];
+
+		const projected = await Promise.all(runIds.map((runId) => resolveSubagentLaunchContract({
+			agent: "worker",
+			cwd,
+			task: "Inspect the repo",
+			runId,
+			sessionDir,
+		})));
+		assert.ok(projected.every((result) => result.ok));
+		for (const [index, result] of projected.entries()) {
+			if (!result.ok) continue;
+			const runId = runIds[index]!;
+			assert.equal(result.contract.roots.sessionFile, path.join(sessionDir, runId, "run-0", "session.jsonl"));
+			assert.equal(result.contract.roots.sessionDir, path.join(sessionDir, runId, "run-0"));
+			assert.equal(result.contract.roots.sessionRoot, path.join(sessionDir, runId));
+		}
+		assert.notEqual(projected[0]!.contract?.roots.sessionFile, projected[1]!.contract?.roots.sessionFile);
+
+		const withoutRunId = await resolveSubagentLaunchContract({
+			agent: "worker",
+			cwd,
+			task: "Inspect the repo",
+			sessionDir,
+		});
+		assert.equal(withoutRunId.ok, true);
+		if (withoutRunId.ok) {
+			assert.equal(withoutRunId.contract.roots.sessionFile, path.join(sessionDir, "preflight", "run-0", "session.jsonl"));
+			assert.equal(withoutRunId.contract.roots.sessionDir, path.join(sessionDir, "preflight", "run-0"));
+		}
+	});
+
 	it("binds canonical extension metadata into public preflight provenance", async () => {
 		const cwd = path.join(tempDir, "bindings-repo");
 		fs.mkdirSync(cwd, { recursive: true });
@@ -975,4 +1012,4 @@ Project prompt.
 		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/prompt-audit-optional-peers.test.ts

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const repositoryRoot = fileURLToPath(new URL("../..", import.meta.url));
+
+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");
+
+	try {
+		await mkdir(dirname(promptAuditPath), { recursive: true });
+		await mkdir(dirname(streamOptionsPath), { recursive: true });
+		await writeFile(
+			promptAuditPath,
+			await readFile(join(repositoryRoot, "src/runs/foreground/prompt-audit.ts"), "utf8"),
+		);
+		await writeFile(
+			streamOptionsPath,
+			await readFile(join(repositoryRoot, "src/shared/agent-stream-options.ts"), "utf8"),
+		);
+
+		const promptAudit = await import(pathToFileURL(promptAuditPath).href);
+		const control = {};
+		promptAudit.registerLivePromptAudit(control, 0, "authored", "before authored after");
+		assert.deepEqual(promptAudit.getLivePromptAudit(control, 0), {
+			authoredTask: "authored",
+			runtimeAdditions: "before\n\nafter",
+			finalEffectivePrompt: "before authored after",
+		});
+
+		promptAudit.updateLiveEffectivePrompt(control, 0, "next authored tail");
+		assert.equal(promptAudit.getLivePromptAudit(control, 0)?.runtimeAdditions, "next\n\ntail");
+		promptAudit.removeLivePromptAudit(control, 0);
+		assert.equal(promptAudit.getLivePromptAudit(control, 0), undefined);
+	} finally {
+		await rm(isolatedRoot, { recursive: true, force: true });
+	}
+});

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

@@ -26,11 +26,12 @@ describe("public subagent execution normalization", () => {
 				output: true,
 			},
 		});
-		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", async: true }), {
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", async: true, baseRef: "@/foo" }), {
 			ok: true,
 			params: {
 				agent: "worker",
 				async: true,
+				baseRef: "@/foo",
 				output: true,
 			},
 		});
@@ -69,6 +70,27 @@ describe("public subagent execution normalization", () => {
 		);
 	});
 
+	it("rejects unsafe base refs at the public boundary", () => {
+		for (const baseRef of ["refs/heads/unsafe..ref", "branch name", "HEAD^{tree}", "@", "a".repeat(40), "a".repeat(64), 42]) {
+			const result = normalizePublicSubagentExecution({ agent: "worker", baseRef });
+			assert.equal(result.ok, false, String(baseRef));
+			if (!result.ok) assert.match(result.error, /baseRef.*HEAD.*named ref.*40\/64-character commit IDs.*revision expressions.*unsupported/);
+		}
+	});
+
+	it("rejects base refs on management actions that do not consume them", () => {
+		const result = normalizePublicSubagentExecution({ action: "list", baseRef: "refs/heads/release" });
+		assert.equal(result.ok, false);
+		if (!result.ok) assert.match(result.error, /baseRef is only supported/);
+	});
+
+	it("accepts base refs on resume because resume consumes them", () => {
+		assert.deepEqual(normalizePublicSubagentExecution({ action: " resume ", id: "run-1", message: "Continue", baseRef: "refs/heads/release" }), {
+			ok: true,
+			params: { action: "resume", id: "run-1", message: "Continue", baseRef: "refs/heads/release" },
+		});
+	});
+
 	it("rejects workflowScript with workflowScriptPath", () => {
 		const result = normalizePublicSubagentExecution({ workflowScript: "return 1", workflowScriptPath: "workflow.js" });
 		assert.equal(result.ok, false);
@@ -179,4 +201,4 @@ describe("public subagent execution normalization", () => {
 			assert.equal(normalizePublicSubagentExecution(params).ok, false, JSON.stringify(params));
 		}
 	});
-});
+});