@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/run-status.test.ts

@@ -9,6 +9,7 @@ import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 import { claimRunFanoutBatch, createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../../src/runs/shared/run-fanout-budget.ts";
 import { TEMP_ROOT_DIR, type SubagentState } from "../../src/shared/types.ts";
+import { getArtifactPaths, getArtifactsDir } from "../../src/shared/artifacts.ts";
 
 function errno(code: string): NodeJS.ErrnoException {
 	const error = new Error(code) as NodeJS.ErrnoException;
@@ -22,6 +23,93 @@ function textContent(result: ReturnType<typeof inspectSubagentStatus>): string {
 }
 
 describe("async run status inspection", () => {
+	it("inspects live foreground artifacts on demand with child selection, ownership and bounded tails", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-live-foreground-transcript-"));
+		try {
+			const artifactRoot = getArtifactsDir(null, root, "project");
+			fs.mkdirSync(artifactRoot, { recursive: true });
+			const control = {
+				runId: "live-foreground", sessionId: "current", mode: "parallel" as const, cwd: root, startedAt: 1, updatedAt: 1,
+				activeChildren: new Map([2, 5].map((index) => [index, { index, agent: "worker", startedAt: 1, updatedAt: 1 }])),
+			};
+			const state = {
+				baseCwd: root, currentSessionId: "current", artifactDirPreference: "project", asyncJobs: new Map(),
+				foregroundControls: new Map([[control.runId, control]]), lastForegroundControlId: control.runId,
+			} as unknown as SubagentState;
+			const deps = { state, asyncDirRoot: path.join(root, "runs"), resultsDir: path.join(root, "results") };
+			const file = getArtifactPaths(artifactRoot, control.runId, "worker", 5).transcriptPath;
+			const record = (text: string) => `${JSON.stringify({ recordType: "message", role: "assistant", text })}\n`;
+			fs.writeFileSync(file, record("first\nsecond\nthird"));
+			const inspect = (params = {}) => inspectSubagentStatus({ view: "transcript", ...params }, deps);
+			assert.match(textContent(inspect()), /requires index.*Active child indexes: 2, 5/);
+			const selected = inspect({ id: "live-fore", index: 5, lines: 2 });
+			assert.equal(selected.isError, undefined);
+			assert.match(textContent(selected), /Child: 5 \(worker\)/);
+			assert.match(textContent(selected), /tail truncated/);
+			assert.match(textContent(selected), /second\nthird$/);
+			assert.doesNotMatch(textContent(selected), /first/);
+			fs.appendFileSync(file, record("fresh activity"));
+			assert.match(textContent(inspect({ index: 5 })), /fresh activity/);
+			fs.appendFileSync(file, [
+				{ recordType: "tool_start", toolName: "bash", toolCallId: "tool-1", argsPreview: "pwd" },
+				{ recordType: "message", role: "toolResult", toolCallId: "tool-1", text: "tool output" },
+				{ recordType: "message", role: "user", text: "supervisor guidance" },
+			].map((event) => JSON.stringify(event) + "\n").join(""));
+			assert.match(textContent(inspect({ index: 5 })), /Tool: bash \(complete\)\npwd\ntool output\nSupervisor: supervisor guidance/);
+			assert.match(textContent(inspect({ index: 2 })), /Transcript unavailable/);
+			assert.doesNotMatch(textContent(inspect({ index: 2 })), /fresh activity/);
+			for (const index of [-1, 1.5, 99]) assert.equal(inspect({ index }).isError, true);
+			control.sessionId = "other";
+			assert.match(textContent(inspect({ id: control.runId, index: 5 })), /not owned by the current session/);
+			assert.doesNotMatch(textContent(inspect({ id: control.runId, index: 5 })), /fresh activity/);
+			state.currentSessionId = null;
+			assert.equal(inspect({ id: control.runId, index: 5 }).isError, true);
+			state.currentSessionId = control.sessionId = "current";
+			fs.writeFileSync(file, record("界".repeat(30_000)));
+			const bytes = textContent(inspect({ index: 5, lines: 500 }));
+			assert.match(bytes, /tail truncated/);
+			assert.ok(Buffer.byteLength(bytes.split("(tail truncated):\n")[1]!) <= 32 * 1024);
+			assert.doesNotMatch(bytes, /\uFFFD/);
+			fs.writeFileSync(file, Array.from({ length: 600 }, (_, index) => record(`record-${index}`)).join(""));
+			const records = textContent(inspect({ index: 5, lines: 100_000 }));
+			assert.match(records, /tail truncated/);
+			assert.equal(records.split("(tail truncated):\n")[1]!.split("\n").length, 240);
+			assert.doesNotMatch(records, /record-0\b/);
+			assert.match(records, /record-599/);
+			fs.writeFileSync(file, record("界\n".repeat(600)));
+			const lines = textContent(inspect({ index: 5, lines: 100_000 }));
+			assert.equal(lines.split("(tail truncated):\n")[1]!.split("\n").length, 500);
+			fs.writeFileSync(file, record("x".repeat(2 * 1024 * 1024)) + record("latest\u001b\u202e") + '{"partial":');
+			const tail = textContent(inspect({ index: 5 }));
+			assert.match(tail, /tail truncated/);
+			assert.match(tail, /latest/);
+			assert.doesNotMatch(tail, /[\u001b\u202e]/u);
+			fs.unlinkSync(file);
+			const outside = path.join(root, "outside.jsonl");
+			fs.writeFileSync(outside, record("OUTSIDE_SECRET"));
+			fs.symlinkSync(outside, file);
+			const refused = textContent(inspect({ index: 5 }));
+			assert.match(refused, /refused a symlink/);
+			assert.match(refused, /Transcript unavailable/);
+			assert.doesNotMatch(refused, /OUTSIDE_SECRET/);
+			control.activeChildren.clear();
+			assert.match(textContent(inspect()), /no active foreground child/);
+		} finally { fs.rmSync(root, { recursive: true, force: true }); }
+	});
+
+	it("projects only published receipt references from result-only status", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-receipt-status-"));
+		try {
+			const resultPath = path.join(root, "receipt-run.json");
+			for (const workflowReceipt of [{ path: "/opaque/published.json", receipt: {} }, undefined, { path: 42 }, []]) {
+				fs.writeFileSync(resultPath, JSON.stringify({ runId: "receipt-run", mode: "workflow", success: true, workflowReceipt }));
+				const result = inspectSubagentStatus({ id: "receipt-run" }, { asyncDirRoot: path.join(root, "absent"), resultsDir: root });
+				const expected = workflowReceipt && "path" in workflowReceipt && typeof workflowReceipt.path === "string" ? workflowReceipt.path : undefined;
+				assert.equal(result.details?.workflowReceiptPath, expected);
+				assert.equal(textContent(result).includes("Workflow receipt:"), expected !== undefined);
+			}
+		} finally { fs.rmSync(root, { recursive: true, force: true }); }
+	});
 	afterEach(() => {
 		delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_JOB_PROVIDER_REGISTRY_KEY)];
 	});
@@ -1542,4 +1630,4 @@ describe("async run status inspection", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/runtime-acknowledged-extensions.test.ts

@@ -1,9 +1,7 @@
 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 { MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES, isRuntimeAcknowledgedExtensionId, projectRuntimeAcknowledgedExtensions, readRuntimeAcknowledgedExtensions, sanitizeRuntimeAcknowledgedExtensions } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
+import { isRuntimeAcknowledgedExtensionId, projectRuntimeAcknowledgedExtensions, sanitizeRuntimeAcknowledgedExtensions } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
 
 describe("runtime acknowledged extension projection", () => {
 	it("validates opaque ids without path-like content", () => {
@@ -37,16 +35,4 @@ describe("runtime acknowledged extension projection", () => {
 		assert.equal(sanitizeRuntimeAcknowledgedExtensions({ version: 1, source: "launch-resolved", ids: ["ok"] }), undefined);
 		assert.equal(sanitizeRuntimeAcknowledgedExtensions({ version: 1, source: "child-runtime", ids: ["bad/path"] }), undefined);
 	});
-
-	it("rejects oversized capture files without reading them", (t) => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "runtime-ack-"));
-		t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
-		const filePath = path.join(dir, "ack.json");
-
-		fs.writeFileSync(filePath, "x".repeat(MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES + 1));
-		assert.equal(readRuntimeAcknowledgedExtensions(filePath), undefined);
-
-		fs.writeFileSync(filePath, JSON.stringify({ version: 1, source: "child-runtime", ids: ["ok"], omitted: 0 }));
-		assert.deepEqual(readRuntimeAcknowledgedExtensions(filePath), { version: 1, source: "child-runtime", ids: ["ok"], omitted: 0 });
-	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/scheduled-runs.test.ts

@@ -341,6 +341,10 @@ describe("project schedule management", () => {
 			{ action: "schedule.create", id: "calendar", every: "day", at: "09:00", timezone: "UTC", workflowScript: "return runs.run('main', { agent: 'worker' })" },
 			{ action: "schedule.create", id: "two-targets", every: "1h", agent: "worker", workflowScript: "return 1" },
 			{ action: "schedule.create", id: "fork", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", context: "fork" },
+			{ action: "schedule.create", id: "invalid-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "unsafe..ref" },
+			{ action: "schedule.create", id: "revision-alias-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "@" },
+			{ action: "schedule.create", id: "object-id-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "a".repeat(40) },
+			{ action: "schedule.create", id: "sha256-object-id-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "a".repeat(64) },
 			{ action: "schedule.create", id: "mission-id", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", missionId: "mission-1" },
 			{ action: "schedule.create", id: "mission-off", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", mission: false },
 		] as const) {
@@ -349,6 +353,26 @@ describe("project schedule management", () => {
 		}
 	});
 
+	it("persists and forwards a scheduled workflow baseRef", async () => {
+		const h = harness();
+		const created = await h.manager.handleToolCall({
+			action: "schedule.create",
+			id: "base-ref",
+			every: "1h",
+			baseRef: "@/foo",
+			workflowScript: "return runs.run('main', { agent: 'worker' })",
+		}, h.ctx);
+		assert.equal(created.isError, undefined);
+		assert.equal(listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores"))[0]?.target.baseRef, "@/foo");
+
+		const running = h.manager.handleToolCall({ action: "schedule.run", id: "base-ref" }, h.ctx);
+		await flush();
+		assert.equal(h.launches[0]?.params.baseRef, "@/foo");
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "workflow", results: [], asyncId: "base-ref-async" } });
+		const result = await running;
+		assert.equal(result.isError, undefined);
+	});
+
 	it("pauses, resumes, lists, and deletes an inactive schedule", async () => {
 		const h = harness();
 		await h.manager.handleToolCall({ action: "schedule.create", id: "maintenance", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
@@ -471,7 +495,7 @@ describe("project schedule management", () => {
 		assert.equal(fs.existsSync(path.join(outside, "schedules")), false);
 	});
 
-	it("allows a default project schedule root through a shared Git worktree .selesai symlink", async () => {
+	it("allows a default project schedule root through a shared Git worktree .pi symlink", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-worktree-link-"));
 		roots.push(root);
 		const repository = path.join(root, "repository");
@@ -499,7 +523,7 @@ describe("project schedule management", () => {
 		assert.equal(fs.existsSync(path.join(worktree, ".pi-subagents", "schedules", "shared", "schedule.json")), true);
 	});
 
-	it("rejects a Git worktree .selesai symlink outside the shared config root", () => {
+	it("rejects a Git worktree .pi symlink outside the shared config root", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-worktree-escape-"));
 		roots.push(root);
 		const repository = path.join(root, "repository");
@@ -901,4 +925,4 @@ describe("recurring schedule execution", () => {
 		assert.match(text(history), /failed_run.*async async-fail/);
 		assert.match(text(history), /failed_launch/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/scheduled-supervisor-demand.test.ts

@@ -0,0 +1,215 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { randomUUID } from "node:crypto";
+import { syncBuiltinESMExports } from "node:module";
+import { it } from "node:test";
+import { createScheduledRunManager } from "../../src/runs/background/scheduled-runs.ts";
+import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
+import { createNativeSupervisorChannel, ensureSupervisorChannelDir, resolveSupervisorChannelDir } from "../../src/intercom/native-supervisor-channel.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+function fixture() {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "scheduled-supervisor-"));
+	const initialOwner = randomUUID();
+	const context = (owner = initialOwner, file: string | null = path.join(root, "parent.jsonl")) => ({
+		cwd: root, hasUI: false,
+		sessionManager: { getSessionId: () => owner, getSessionFile: () => file, getEntries: () => [] },
+	});
+	const state: SubagentState = {
+		baseCwd: root, currentSessionId: context().sessionManager.getSessionFile(), supervisorOwnerSessionId: initialOwner,
+		asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null, cleanupTimers: new Map(), lastUiContext: null,
+		poller: null, completionSeen: new Map(), watcher: null, watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear() {} },
+	};
+	const intervals = new Map<object, () => void>();
+	const sent: string[] = [], cleanupDirs: string[] = [];
+	let starts = 0, activations = 0, terminal = () => {};
+	let done = Promise.resolve();
+	const pi = {
+		getAllTools: () => [], registerTool() {}, getSessionName: () => "parent",
+		events: { emit() {}, on() { return () => {}; } },
+		sendMessage(message: { details?: { id?: string } }) { if (message.details?.id) sent.push(message.details.id); },
+	};
+	const channel = createNativeSupervisorChannel(pi as never, state, {
+		getCurrentOwnerStates: () => executor.getCurrentSupervisorOwnerStates(),
+		platform: "darwin", watch: (() => { throw new Error("Darwin must not watch"); }) as never,
+		timers: {
+			setInterval: ((handler: () => void, delay: number) => {
+				assert.equal(delay, 250); starts++;
+				const token = { unref() {} }; intervals.set(token, handler); return token;
+			}) as typeof setInterval,
+			clearInterval: ((token: object) => { intervals.delete(token); }) as typeof clearInterval,
+			setImmediate, clearImmediate,
+		},
+	});
+	const config = { maxSubagentDepth: 2, control: {}, intercomBridge: {} } as never;
+	const executor = createSubagentExecutor({
+		pi: pi as never, state, config, asyncByDefault: false, tempArtifactsDir: root,
+		getSubagentSessionRoot: () => root, expandTilde: value => value, discoverAgents: () => ({ agents: [] }),
+		activateSupervisorTransport() { activations++; channel.activateTransport(); },
+		refreshResultDelivery() { terminal(); },
+	});
+	const manager = createScheduledRunManager({ config, storeRoot: path.join(root, "schedules"),
+		launch: (params, ctx, signal) => executor.executeScheduled(randomUUID(), params, signal, ctx),
+	});
+	channel.start();
+	return {
+		initialOwner, context, state, channel, executor, intervals, sent,
+		starts: () => starts, activations: () => activations,
+		tick() { for (const handler of [...intervals.values()]) handler(); },
+		async launch(ctx = context()) {
+			const id = randomUUID();
+			const created = await manager.handleToolCall({ action: "schedule.create", id, at: "+1h", workflowScript: "return [];" }, ctx as never);
+			assert.equal(created.isError, undefined, JSON.stringify(created));
+			done = new Promise<void>(resolve => { terminal = resolve; });
+			const launched = await manager.handleToolCall({ action: "schedule.run", id }, ctx as never);
+			if (launched.isError) { terminal(); return { launched }; }
+			const run = launched.details!.schedules!.runs![0]!;
+			assert.equal(run.state, "running");
+			cleanupDirs.push(run.asyncDir!);
+			assert.equal(manager.observedCompletionRunIds().has(run.asyncId!), true);
+			assert.equal(JSON.parse(fs.readFileSync(path.join(run.asyncDir!, "status.json"), "utf8")).state, "running");
+			return { launched, run };
+		},
+		ask(runId: string, owner = initialOwner) {
+			const dir = resolveSupervisorChannelDir(runId, "worker", 0);
+			cleanupDirs.push(dir); ensureSupervisorChannelDir(dir);
+			const id = randomUUID(), file = path.join(dir, "requests", `${id}.json`);
+			fs.writeFileSync(file, JSON.stringify({ type: "subagent.supervisor.request", id, createdAt: Date.now(), reason: "need_decision", message: "Delayed decision", expectsReply: true, orchestratorSessionId: owner, runId, agent: "worker", childIndex: 0 }));
+			return { id, file, dir };
+		},
+		async finish() { await done; },
+		async dispose() {
+			manager.stop(); channel.dispose(); await done;
+			for (const dir of [...cleanupDirs, root]) fs.rmSync(dir, { recursive: true, force: true });
+		},
+	};
+}
+
+it("actual scheduled workflows discover delayed Darwin asks, clear terminal asks and rearm without idle demand", async () => {
+	const f = fixture();
+	try {
+		assert.equal(f.intervals.size, 0);
+		for (let cycle = 0; cycle < 2; cycle++) {
+			const { run } = await f.launch();
+			assert.ok(run);
+			assert.equal(f.state.asyncJobs.size, 0, "scheduled registration stays isolated");
+			assert.equal(f.state.foregroundControls.size, 0);
+			const ask = f.ask(run.asyncId!);
+			const foreign = f.ask(run.asyncId!, randomUUID());
+			const target = { runId: run.asyncId!, agent: "worker", childIndex: 0 };
+			// First cycle proves discovery without any lookup; second also checks passive receipts.
+			if (cycle === 1) {
+				assert.deepEqual(f.channel.findPendingAsks(target), [ask.id]);
+				assert.equal(f.channel.pending.size, 0, "live lookup does not register or notify");
+				assert.equal(f.sent.includes(ask.id), false);
+			}
+			f.tick();
+			assert.ok(f.sent.includes(ask.id), "actual scheduled workflow must discover delayed same-owner ask without an explicit scan");
+			assert.equal(f.channel.pending.has(foreign.id), false);
+			assert.equal(f.sent.includes(foreign.id), false);
+			assert.deepEqual(fs.readdirSync(path.join(ask.dir, "replies")), []);
+			assert.equal(f.intervals.size, 1);
+			assert.equal(f.starts(), cycle + 1);
+			await f.finish();
+			assert.deepEqual(f.channel.findPendingAsks(target), [], "terminal scheduled asks are not live receipts");
+			assert.equal(fs.existsSync(ask.file), true, "terminal lookup does not clean request files");
+			f.tick();
+			assert.equal(f.channel.pending.size, 0, "existing lifecycle predicate sees retained terminal job");
+			assert.equal(fs.existsSync(ask.file), false);
+			assert.equal(fs.existsSync(foreign.file), true, "foreign requests are not cleaned or answered");
+			assert.equal(f.intervals.size, 0);
+		}
+		assert.equal(f.activations(), 2);
+	} finally { await f.dispose(); }
+});
+
+it("scheduled owner visibility preserves runtime UUID, same-file isolation and fileless transitions without aborting jobs", async () => {
+	const f = fixture();
+	try {
+		const { run: first } = await f.launch(f.context(f.initialOwner, null));
+		assert.ok(first);
+		const fileless = [...f.executor.getCurrentSupervisorOwnerStates()][0]!;
+		assert.equal(fileless.currentSessionId, f.initialOwner);
+		const controller = fileless.workflowControllers!.get(first.asyncId!)!;
+		const otherOwner = randomUUID();
+		for (const inactive of [null, otherOwner]) {
+			f.state.supervisorOwnerSessionId = inactive;
+			assert.deepEqual([...f.executor.getCurrentSupervisorOwnerStates()], []);
+			f.tick();
+			assert.equal(f.intervals.size, 0, "inactive owner work cannot keep active channel polling");
+			assert.equal(controller.signal.aborted, false);
+		}
+		const hiddenAsk = f.ask(first.asyncId!);
+		f.channel.activateTransport();
+		assert.equal(f.channel.pending.size, 0);
+		assert.equal(f.intervals.size, 0);
+		f.state.supervisorOwnerSessionId = f.initialOwner;
+		f.channel.activateTransport();
+		assert.equal(f.channel.pending.has(hiddenAsk.id), true);
+		assert.equal(controller.signal.aborted, false);
+		await f.finish(); f.tick();
+		assert.equal(f.intervals.size, 0);
+
+		const { run: saved } = await f.launch();
+		assert.ok(saved);
+		const ownStates = [...f.executor.getCurrentSupervisorOwnerStates()];
+		assert.equal(ownStates.length, 2, "saving a file retains distinct entries under the same runtime UUID");
+		const savedState = ownStates.find(state => state !== fileless)!;
+		assert.equal(savedState.currentSessionId, f.context().sessionManager.getSessionFile());
+		assert.ok(savedState.asyncJobs.has(saved.asyncId!));
+		await f.finish(); f.tick();
+
+		// The main owner remains unchanged during the other runtime's real scheduled launch.
+		const { run: other } = await f.launch(f.context(otherOwner));
+		assert.ok(other);
+		assert.equal(f.intervals.size, 0, "foreign scheduled registration does not supply current-owner demand");
+		assert.deepEqual([...f.executor.getCurrentSupervisorOwnerStates()], ownStates);
+		const otherAsk = f.ask(other.asyncId!, otherOwner);
+		f.channel.activateTransport();
+		assert.equal(f.channel.pending.has(otherAsk.id), false);
+		f.state.supervisorOwnerSessionId = otherOwner;
+		const otherStates = [...f.executor.getCurrentSupervisorOwnerStates()];
+		assert.equal(otherStates.length, 1);
+		assert.notEqual(otherStates[0], savedState, "same file with new UUID never reuses or retags executor state");
+		assert.ok(otherStates[0]!.asyncJobs.has(other.asyncId!));
+		assert.equal(savedState.asyncJobs.has(other.asyncId!), false);
+		f.channel.activateTransport();
+		assert.equal(f.channel.pending.has(otherAsk.id), true);
+		await f.finish(); f.tick();
+		assert.equal(f.channel.pending.size, 0);
+		assert.equal(f.intervals.size, 0);
+	} finally { await f.dispose(); }
+});
+
+it("failed scheduled workflow persistence rolls back retained demand before activation", async (t) => {
+	const f = fixture();
+	const rename = fs.renameSync;
+	const failedDirs: string[] = [];
+	try {
+		t.mock.method(fs, "renameSync", (source: fs.PathLike, destination: fs.PathLike) => {
+			if (String(destination).endsWith(`${path.sep}status.json`)) {
+				failedDirs.push(path.dirname(String(destination)));
+				throw Object.assign(new Error("scheduled status persistence failure"), { code: "EACCES" });
+			}
+			return rename(source, destination);
+		});
+		syncBuiltinESMExports();
+		const { launched } = await f.launch();
+		assert.equal(launched.isError, true);
+		assert.match(JSON.stringify(launched), /Failed to create async workflow storage/);
+		assert.equal(f.activations(), 0);
+		const retained = [...f.executor.getCurrentSupervisorOwnerStates()];
+		assert.equal(retained.length, 1);
+		assert.equal(retained[0]!.asyncJobs.size, 0);
+		assert.equal(retained[0]!.workflowControllers!.size, 0);
+		f.channel.activateTransport();
+		assert.equal(f.intervals.size, 0);
+	} finally {
+		t.mock.restoreAll(); syncBuiltinESMExports();
+		await f.dispose();
+		for (const dir of failedDirs) fs.rmSync(dir, { recursive: true, force: true });
+	}
+});

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

@@ -216,15 +216,9 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		const workflowScript = SubagentParams?.properties?.workflowScript;
 		assert.equal(workflowScript?.type, "string");
 		assert.equal(workflowScript?.minLength, 1);
-		assert.match(String(workflowScript?.description ?? ""), /runs\.run/);
-		assert.match(String(workflowScript?.description ?? ""), /runs\.lanes\(\[\{key,stages:/);
-		assert.match(String(workflowScript?.description ?? ""), /first stages run together.*later stages sequence per lane/i);
-		assert.match(String(workflowScript?.description ?? ""), /Each workflow key identifies one result lane.*new stable workflow key.*retained resume pass/i);
-		assert.match(String(workflowScript?.description ?? ""), /await runs\.all\(\[\{key, agent, task\}, \.\.\.\]\)/);
-		assert.match(String(workflowScript?.description ?? ""), /do not read \.output from unawaited runs\.run launches/i);
-		assert.match(String(workflowScript?.description ?? ""), /advanced rolling fanout/);
-		assert.match(String(workflowScript?.description ?? ""), /sequential and parallel phases dynamically/i);
-		assert.match(String(workflowScript?.description ?? ""), /worktree:true/i);
+		assert.match(String(workflowScript?.description ?? ""), /Inline JavaScript statement body/);
+		assert.match(String(workflowScript?.description ?? ""), /top-level await/);
+		assert.match(String(workflowScript?.description ?? ""), /Globals: runs, emit, console/);
 		assert.match(String(workflowScript?.description ?? ""), /no filesystem, shell, Pi tools, or host globals/i);
 		const workflowScriptPath = SubagentParams?.properties?.workflowScriptPath;
 		assert.equal(workflowScriptPath?.type, "string");
@@ -541,6 +535,10 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 				if (!current.value || typeof current.value !== "object") continue;
 
 				const node = current.value as JsonSchemaNode;
+				// oxlint-disable-next-line anti-slop/no-runtime-typeof -- Inspecting JSON Schema enum representation is the portability contract under test.
+				if (Array.isArray(node.enum) && node.enum.some((value) => typeof value !== "string")) {
+					rejectedPaths.push(`${current.path}.enum`);
+				}
 				if (Array.isArray(node.type)) {
 					rejectedPaths.push(`${current.path}.type`);
 				}
@@ -612,6 +610,13 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.ok(SubagentParams, "SubagentParams schema should exist");
 		assert.ok(CompileSchema, "TypeBox compiler should exist");
 		const validator = CompileSchema(SubagentParams);
+		// Transport accepts both booleans; semantic boundaries still reject unsupported true.
+		for (const field of ["acceptance", "mission", "thinking"]) {
+			assert.deepEqual(anyOfBranches(SubagentParams.properties[field]).find((branch) => branch.type === "boolean"), { type: "boolean" });
+			assert.equal(validator.Check({ [field]: false }), true);
+			assert.equal(validator.Check({ [field]: true }), true);
+			assert.equal(validator.Check({ [field]: 123 }), false);
+		}
 		const validValues = [
 			{ skill: "review" },
 			{ workflowScript: "return await runs.run(\"one\", {agent: \"reviewer\", task: \"check\"})" },
@@ -632,7 +637,6 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 			{ output: 123 },
 			{ timeoutMs: 0 },
 			{ maxRuntimeMs: -1 },
-			{ agent: "worker", task: "Fix", acceptance: true },
 			{ config: [] },
 			{ config: null },
 			{ agent: "worker", task: "Fix", toolBudget: { hard: 0 } },
@@ -654,4 +658,4 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 			assert.equal(validator.Check(value), false, `${JSON.stringify(value)} should not validate`);
 		}
 	});
-});
+});