@selesai/code 0.13.39 → 0.14.0

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

@@ -1,4 +1,10 @@
 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 { randomUUID } from "node:crypto";
+import { nestedRunScope } from "../../src/runs/shared/nested-events.ts";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { describe, it } from "node:test";
 import { drainOutstandingWork } from "../../src/runs/background/auto-drain.ts";
 import type { Details, SubagentState } from "../../src/shared/types.ts";
@@ -20,6 +26,36 @@ function waitResult(text: string, isError = false, windowElapsed = false) {
 }
 
 describe("headless background-work auto-drain", () => {
+	it("discovers both owned storage scopes, forwards them to wait, and leaves sibling work alone", async (t) => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-drain-scopes-"));
+		const nestedRootRunId = randomUUID();
+		const nested = nestedRunScope(nestedRootRunId);
+		const ordinary = { asyncDirRoot: path.join(root, "runs"), resultsDir: path.join(root, "results") };
+		t.after(() => { for (const dir of [root, nested.asyncDirRoot]) fs.rmSync(dir, { recursive: true, force: true }); });
+		const writeStatus = (dir: string, sessionId: string, status: "running" | "complete") => {
+			fs.mkdirSync(dir, { recursive: true });
+			fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify({ runId: path.basename(dir), sessionId, mode: "single", state: status, pid: process.pid, startedAt: Date.now(), lastUpdate: Date.now(), steps: [] }));
+			updateActiveRunIndex(dir, status);
+		};
+		const owned = [path.join(ordinary.asyncDirRoot, "workflow"), path.join(nested.asyncDirRoot, "persona")];
+		for (const dir of owned) writeStatus(dir, "owner", "running");
+		const sibling = path.join(nested.asyncDirRoot, "sibling-persona");
+		writeStatus(sibling, "sibling-session", "running");
+		let waits = 0;
+		await drainOutstandingWork({
+			state: state("owner"), ...ordinary, nestedRootRunId,
+			wait: async (_params, _signal, deps) => {
+				assert.equal(deps.nestedRootRunId, nestedRootRunId);
+				assert.equal(deps.asyncDirRoot, ordinary.asyncDirRoot);
+				assert.equal(deps.resultsDir, ordinary.resultsDir);
+				writeStatus(owned[waits++]!, "owner", "complete");
+				return waitResult("done");
+			},
+		});
+		assert.equal(waits, 2, "drain must continue when only nested owned work remains");
+		assert.equal(JSON.parse(fs.readFileSync(path.join(sibling, "status.json"), "utf8")).state, "running");
+	});
+
 	it("is a no-op when the exact session has no work", async () => {
 		let waited = false;
 		await drainOutstandingWork({
@@ -80,4 +116,73 @@ describe("headless background-work auto-drain", () => {
 	it("fails without a session identity", async () => {
 		await assert.rejects(() => drainOutstandingWork({ state: state(null) }), /without an active session identity/);
 	});
-});
+
+	it("does not settle while a remembered detached foreground descendant is still in flight", async () => {
+		const current = state("owner");
+		current.foregroundRuns = new Map([["fg", {
+			runId: "fg", mode: "single", cwd: "/tmp", sessionId: "owner", updatedAt: 1,
+			children: [{ agent: "reviewer", index: 0, status: "detached", updatedAt: 1 }],
+		}]]);
+		let waits = 0;
+		await drainOutstandingWork({
+			state: current,
+			timeoutMs: 1000,
+			now: () => waits * 10,
+			wait: async () => {
+				waits++;
+				current.foregroundRuns!.get("fg")!.children[0]!.status = "completed";
+				return waitResult("done");
+			},
+		});
+		assert.equal(waits, 1);
+	});
+
+	it("yields to Pi for a pending supervisor turn and resumes draining the same work after resolution", async () => {
+		let pending = true;
+		let active = true;
+		let waits = 0;
+		const deps = {
+			state: state(),
+			hasPendingSupervisorRequest: () => pending,
+			hasWork: () => active,
+			wait: async () => {
+				waits++;
+				active = false;
+				return waitResult("done");
+			},
+		};
+
+		await drainOutstandingWork(deps);
+		assert.equal(waits, 0, "the queued supervisor triggerTurn must get control before drain blocks again");
+		assert.equal(active, true, "yielding must leave the owned workflow active");
+
+		pending = false;
+		await drainOutstandingWork(deps);
+		assert.equal(waits, 1, "the same workflow can continue and drain after the reply resolves the barrier");
+		assert.equal(active, false);
+	});
+
+	it("latches an inner supervisor yield even when the live request clears before continuation", async () => {
+		let pending = false;
+		let clock = 0;
+		let waits = 0;
+		await drainOutstandingWork({
+			state: state(),
+			timeoutMs: 50,
+			now: () => clock,
+			hasWork: () => true,
+			hasPendingSupervisorRequest: () => pending,
+			wait: async (_params, _signal, deps) => {
+				waits++;
+				assert.equal(typeof deps.hasPendingSupervisorRequest, "function");
+				clock = 100;
+				pending = false;
+				return {
+					content: [{ type: "text", text: "Wait yielded for a pending supervisor request." }],
+					details: { mode: "management", results: [], wait: { reason: "supervisor_request", timedOut: false, activeRunIds: ["run-a"], activeProviderItems: [] } },
+				};
+			},
+		});
+		assert.equal(waits, 1);
+	});
+});

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

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import { once } from "node:events";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { awaitExistingAsyncRun } from "../../src/runs/background/await-async-run.ts";
+
+let tempDir: string;
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+function childDir(runId = "child-run"): string {
+	return path.join(tempDir, runId);
+}
+
+function writeStatus(asyncDir: string, fields: Record<string, unknown>): void {
+	writeJson(path.join(asyncDir, "status.json"), {
+		runId: path.basename(asyncDir),
+		mode: "single",
+		parentWorkflowRunId: "workflow-parent",
+		sessionId: "session-a",
+		state: "running",
+		startedAt: 1,
+		steps: [{ agent: "worker", status: "running" }],
+		...fields,
+	});
+}
+
+function writeResult(asyncDir: string, output: string): void {
+	writeJson(path.join(asyncDir, "workflow-result.json"), {
+		id: path.basename(asyncDir),
+		runId: path.basename(asyncDir),
+		sessionId: "session-a",
+		toolCallId: "tool-call-a",
+		state: "complete",
+		success: true,
+		results: [{ agent: "worker", output, success: true }],
+	});
+}
+
+function deadPid(): number {
+	const exited = spawnSync(process.execPath, ["-e", ""]);
+	assert.ok(exited.pid);
+	return exited.pid;
+}
+
+describe("awaitExistingAsyncRun", () => {
+	beforeEach(() => {
+		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-await-async-run-"));
+	});
+
+	afterEach(() => {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	});
+
+	it("returns an already published result without consuming or rewriting files", async () => {
+		const asyncDir = childDir();
+		writeStatus(asyncDir, { state: "complete", steps: [{ agent: "worker", status: "complete" }] });
+		writeResult(asyncDir, "finished output");
+		const files = ["status.json", "workflow-result.json"].map((name) => path.join(asyncDir, name));
+		const before = files.map((file) => fs.readFileSync(file));
+
+		const outcome = await awaitExistingAsyncRun(asyncDir, "child-run", new AbortController().signal);
+
+		assert.equal(outcome.status, "settled");
+		assert.equal(outcome.status === "settled" && outcome.result.output, "finished output");
+		assert.equal(outcome.status === "settled" && outcome.result.success, true);
+		assert.equal(outcome.status === "settled" && outcome.result.exitCode, 0);
+		assert.deepEqual(outcome.status === "settled" && outcome.result.importedPublication, { sessionId: "session-a", toolCallId: "tool-call-a" });
+		files.forEach((file, index) => assert.deepEqual(fs.readFileSync(file), before[index], file));
+	});
+
+	it("waits for an active run to publish its result", async () => {
+		const asyncDir = childDir();
+		writeStatus(asyncDir, { pid: process.pid });
+		setTimeout(() => {
+			writeResult(asyncDir, "late output");
+			writeStatus(asyncDir, { pid: process.pid, state: "complete", steps: [{ agent: "worker", status: "complete" }] });
+		}, 50);
+
+		const outcome = await awaitExistingAsyncRun(asyncDir, "child-run", new AbortController().signal);
+
+		assert.equal(outcome.status, "settled");
+		assert.equal(outcome.status === "settled" && outcome.result.output, "late output");
+	});
+
+	it("is unavailable when the status belongs to a different run", async () => {
+		const asyncDir = childDir();
+		writeStatus(asyncDir, { runId: "other-run", state: "complete" });
+		writeResult(asyncDir, "other output");
+
+		const outcome = await awaitExistingAsyncRun(asyncDir, "child-run", new AbortController().signal);
+
+		assert.equal(outcome.status, "unavailable");
+		assert.match(outcome.status === "unavailable" ? outcome.reason : "", /belongs to run 'other-run'/);
+	});
+
+	it("is unavailable when the run directory is missing", async () => {
+		const outcome = await awaitExistingAsyncRun(childDir("missing-run"), "missing-run", new AbortController().signal);
+
+		assert.equal(outcome.status, "unavailable");
+		assert.match(outcome.status === "unavailable" ? outcome.reason : "", /No async status/);
+	});
+
+	it("is unavailable when a terminal run has no result file", async () => {
+		const asyncDir = childDir();
+		writeStatus(asyncDir, { state: "complete", steps: [{ agent: "worker", status: "complete" }] });
+
+		const outcome = await awaitExistingAsyncRun(asyncDir, "child-run", new AbortController().signal);
+
+		assert.equal(outcome.status, "unavailable");
+		assert.match(outcome.status === "unavailable" ? outcome.reason : "", /ended without a result file/);
+		assert.equal(JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")).state, "complete");
+	});
+
+	it("is unavailable when the runner died while status still says running", async () => {
+		const asyncDir = childDir();
+		writeStatus(asyncDir, { pid: deadPid() });
+
+		const outcome = await awaitExistingAsyncRun(asyncDir, "child-run", new AbortController().signal);
+
+		assert.equal(outcome.status, "unavailable");
+		assert.match(outcome.status === "unavailable" ? outcome.reason : "", /exited without publishing a result/);
+		assert.equal(JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")).state, "running");
+	});
+
+	it("ends a zombie wait only when the runner's PID namespace is verified", { skip: process.platform !== "linux", timeout: 10_000 }, async () => {
+		const script = String.raw`
+			const { spawn } = require("node:child_process");
+			const fs = require("node:fs");
+			const child = spawn(process.execPath, ["-e", 'process.title = "pi) zombie"; process.exit(0);'], { stdio: "ignore" });
+			process.stdout.write(String(child.pid) + "\n");
+			fs.readSync(0, Buffer.alloc(1), 0, 1, null);
+		`;
+		const parent = spawn(process.execPath, ["--eval", script], { stdio: ["pipe", "pipe", "pipe"] });
+		const closed = once(parent, "close");
+		parent.stdin.on("error", () => {});
+		try {
+			const [output] = await once(parent.stdout, "data", { signal: AbortSignal.timeout(5_000) });
+			const pid = Number(String(output).trim());
+			assert.ok(Number.isSafeInteger(pid) && pid > 0);
+			const deadline = Date.now() + 5_000;
+			let stat = "";
+			while (Date.now() < deadline) {
+				stat = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+				if (stat[stat.lastIndexOf(") ") + 2] === "Z") break;
+				await new Promise((resolve) => setTimeout(resolve, 10));
+			}
+			assert.match(stat, /\(pi\) zombie\) Z /);
+			assert.equal(process.kill(pid, 0), true);
+			const scope = fs.readlinkSync("/proc/self/ns/pid", "utf-8").trim();
+			for (const scenario of [
+				{ name: "matching", recorded: scope, exited: true },
+				{ name: "missing-recorded", recorded: undefined, exited: false },
+				{ name: "different", recorded: "pid:[other]", exited: false },
+			]) {
+				const runId = `zombie-${scenario.name}`;
+				const asyncDir = childDir(runId);
+				writeStatus(asyncDir, { pid, ...(scenario.recorded !== undefined ? { pidNamespaceScope: scenario.recorded } : {}) });
+				const statusPath = path.join(asyncDir, "status.json");
+				const before = fs.readFileSync(statusPath);
+				const publication = scenario.exited ? undefined : setTimeout(() => writeResult(asyncDir, "late output"), 50);
+				try {
+					const outcome = await awaitExistingAsyncRun(asyncDir, runId, AbortSignal.timeout(1500))
+						.catch((error) => ({ status: "aborted" as const, reason: String(error) }));
+					assert.equal(outcome.status, scenario.exited ? "unavailable" : "settled", scenario.name);
+					if (outcome.status === "unavailable") assert.match(outcome.reason, /exited without publishing a result/);
+					if (outcome.status === "settled") assert.equal(outcome.result.output, "late output");
+					assert.deepEqual(fs.readFileSync(statusPath), before, "the exit probe must remain read-only");
+				} finally {
+					clearTimeout(publication);
+				}
+			}
+		} finally {
+			parent.stdin.end("reap");
+			await closed;
+		}
+	});
+
+	it("rejects with the abort reason while waiting", async () => {
+		const asyncDir = childDir();
+		writeStatus(asyncDir, { pid: process.pid });
+		const controller = new AbortController();
+		const startedAt = Date.now();
+		setTimeout(() => controller.abort(new Error("workflow replaced")), 20);
+
+		await assert.rejects(awaitExistingAsyncRun(asyncDir, "child-run", controller.signal), /workflow replaced/);
+		assert.ok(Date.now() - startedAt < 2_000);
+	});
+
+	it("rejects immediately when already aborted", async () => {
+		const controller = new AbortController();
+		controller.abort(new Error("already stopped"));
+
+		await assert.rejects(awaitExistingAsyncRun(childDir(), "child-run", controller.signal), /already stopped/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/binary-async-spawn.test.ts

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { executeAsyncChain, executeAsyncSingle } from "../../src/runs/background/async-execution.ts";
+import { makeAgent } from "../support/helpers.ts";
+
+// Spawn-boundary tests, not substitutes for the real official Linux loader gate.
+for (const [entry, missingBootstrap] of [
+	["/$bunfs/root/pi-native", false],
+	["/$bunfs/root/pi-native", true],
+	["B:/~BUN/root/pi-native.exe", false],
+	["B:\\~BUN\\root\\pi-native.exe", false],
+	["B:/~BUN/root/pi-native.exe", true],
+] as const) {
+	test(`compiled background launch ${entry} ${missingBootstrap ? "rejects a missing bootstrap" : "uses Pi's loader without npm aliases"}`, (t) => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "binary-spawn-"));
+		const argv1 = process.argv[1];
+		const bun = Object.getOwnPropertyDescriptor(process.versions, "bun");
+		const env = { ...process.env };
+		Object.defineProperty(process.versions, "bun", { value: "1.3.14", configurable: true });
+		process.argv[1] = entry;
+		process.env.SELESAI_SUBAGENT_SELESAI_BINARY = path.join(root, "pi-native");
+		process.env.PI_PACKAGE_DIR = path.join(root, "release-assets");
+		process.env.SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT = "/stale/npm-root";
+		process.env.JITI_ALIAS = '{"stale":"alias"}';
+		process.env.SELESAI_SUBAGENT_PARENT_SESSION = "ambient-other-root";
+		const spawn = t.mock.method(childProcess, "spawn", () => { throw new Error("captured binary spawn"); });
+		if (missingBootstrap) {
+			const exists = fs.existsSync;
+			t.mock.method(fs, "existsSync", (file) => String(file).endsWith("binary-bootstrap.ts") ? false : exists(file));
+		}
+		syncBuiltinESMExports();
+		try {
+			const result = executeAsyncSingle(`binary-${missingBootstrap}`, {
+				agent: "worker", task: "Inspect files", agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: root, currentSessionId: "binary-spawn" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(root, "sessions"), maxSubagentDepth: 1, acceptance: false,
+			});
+			assert.equal(result.isError, true);
+			if (missingBootstrap) {
+				assert.match(result.content[0]!.text, /Background runner bootstrap not found/);
+				assert.equal(spawn.mock.callCount(), 0);
+			} else {
+				assert.match(result.content[0]!.text, /captured binary spawn/);
+				assert.equal(spawn.mock.callCount(), 1, "no alternate runtime retry");
+				const [command, args, options] = spawn.mock.calls[0]!.arguments;
+				assert.equal(command, process.env.SELESAI_SUBAGENT_SELESAI_BINARY);
+				assert.deepEqual(args.slice(0, -1), ["--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session", "--mode", "rpc", "--extension"]);
+				assert.ok(args.at(-1).endsWith("binary-bootstrap.ts"));
+				assert.equal(options.env.JITI_ALIAS, undefined);
+				assert.equal(options.env.SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT, undefined);
+				assert.equal(options.env.PI_PACKAGE_DIR, process.env.PI_PACKAGE_DIR);
+				assert.equal(options.env.SELESAI_SUBAGENT_PARENT_SESSION, "binary-spawn");
+				assert.ok(path.isAbsolute(options.env.SELESAI_SUBAGENT_RUNNER_CONFIG));
+				assert.equal(options.cwd, root);
+				assert.equal(options.stdio[0], "ignore");
+
+				const withoutParent = executeAsyncSingle("binary-no-parent", {
+					agent: "worker", task: "Inspect files", agentConfig: makeAgent("worker"),
+					ctx: { pi: { events: { emit() {} } }, cwd: root },
+					artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+					shareEnabled: false, sessionRoot: path.join(root, "sessions"), maxSubagentDepth: 1, acceptance: false,
+				});
+				assert.match(withoutParent.content[0]!.text, /captured binary spawn/);
+				assert.equal(spawn.mock.callCount(), 2);
+				assert.equal(spawn.mock.calls[1]!.arguments[2].env.SELESAI_SUBAGENT_PARENT_SESSION, undefined);
+
+				const attached = executeAsyncChain("binary-attached", {
+					chain: [{ agent: "worker", task: "Continue" }],
+					attachRoot: { runId: "source", asyncDir: root, resultPath: path.join(root, "source.json"), index: 0, agent: "worker" },
+					agents: [makeAgent("worker")],
+					ctx: { pi: { events: { emit() {} } }, cwd: root, currentSessionId: "status-session", parentSessionId: "attach-parent" },
+					artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+					shareEnabled: false, sessionRoot: path.join(root, "sessions"), maxSubagentDepth: 1,
+				});
+				assert.match(attached.content[0]!.text, /captured binary spawn/);
+				assert.equal(spawn.mock.callCount(), 3);
+				const attachedOptions = spawn.mock.calls[2]!.arguments[2];
+				assert.equal(attachedOptions.env.SELESAI_SUBAGENT_PARENT_SESSION, "attach-parent");
+				const attachedConfig = JSON.parse(fs.readFileSync(attachedOptions.env.SELESAI_SUBAGENT_RUNNER_CONFIG, "utf-8"));
+				assert.deepEqual(attachedConfig.steps.map((step: { parentSessionId?: string }) => step.parentSessionId), ["attach-parent", "attach-parent"]);
+
+				let parentRead = 0;
+				const inconsistent = executeAsyncChain("binary-inconsistent", {
+					chain: [{ agent: "worker", task: "Continue" }],
+					attachRoot: { runId: "source", asyncDir: root, resultPath: path.join(root, "source.json"), index: 0, agent: "worker" },
+					agents: [makeAgent("worker")],
+					ctx: {
+						pi: { events: { emit() {} } }, cwd: root, currentSessionId: "status-session",
+						get parentSessionId() { return ++parentRead === 1 ? "launch-parent-a" : "launch-parent-b"; },
+					},
+					artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+					shareEnabled: false, sessionRoot: path.join(root, "sessions"), maxSubagentDepth: 1,
+				});
+				assert.equal(inconsistent.isError, true);
+				assert.match(inconsistent.content[0]!.text, /inconsistent parent session identities/);
+				assert.equal(spawn.mock.callCount(), 3, "inconsistent real or synthetic parents must fail before spawn");
+			}
+		} finally {
+			t.mock.restoreAll();
+			syncBuiltinESMExports();
+			process.argv[1] = argv1;
+			if (bun) Object.defineProperty(process.versions, "bun", bun);
+			else delete process.versions.bun;
+			for (const key of Object.keys(process.env)) if (!(key in env)) delete process.env[key];
+			Object.assign(process.env, env);
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+}

package/dist/extensions/pi-subagents/test/unit/binary-pi-spawn.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { resolveBunPiExecutable } from "../../src/runs/shared/pi-spawn.ts";
+
+for (const [argv1, execPath] of [
+	["/$bunfs/root/pi-native", "/opt/standalone/pi-native"],
+	["B:/~BUN/root/pi-native.exe", "C:\\Program Files\\pi\\pi-native.exe"],
+	["B:\\~BUN\\root\\pi-native.exe", "C:\\Program Files\\pi\\pi-native.exe"],
+]) describe(`compiled background host detection: ${argv1}`, () => {
+	const host = { execPath, argv1, bunVersion: "1.4.2", env: {} };
+
+	it("uses the actual image even when renamed", () => {
+		assert.equal(resolveBunPiExecutable(host), host.execPath);
+	});
+
+	it("honors a nonempty override, otherwise retaining the actual image", () => {
+		assert.equal(resolveBunPiExecutable({ ...host, env: { SELESAI_SUBAGENT_SELESAI_BINARY: " /custom/pi " } }), "/custom/pi");
+		assert.equal(resolveBunPiExecutable({ ...host, env: { SELESAI_SUBAGENT_SELESAI_BINARY: " " } }), host.execPath);
+	});
+
+	it("does not treat an ordinary Bun script or Node as a compiled host", () => {
+		for (const entry of ["", "/work/script.ts", "B:/work/script.ts", "/$bunfs-other/pi", "B:/~BUN-other/pi.exe", "C:/~BUN/root/pi.exe", "/work/B:/~BUN/pi.exe"]) {
+			assert.equal(resolveBunPiExecutable({ ...host, argv1: entry }), undefined, entry);
+		}
+		assert.equal(resolveBunPiExecutable({ ...host, bunVersion: "" }), undefined);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/calendar-schedule.test.ts

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { describe, it } from "node:test";
+import { latestCalendarOccurrence, nextCalendarOccurrence, normalizeCalendarRule, restoreCalendarTrigger } from "../../src/runs/background/calendar-schedule.ts";
+
+describe("calendar occurrence calculation", () => {
+	it("loads the polyfill only for calendar evaluation and reuses its synchronous module", () => {
+		const moduleUrl = new URL("../../src/runs/background/calendar-schedule.ts", import.meta.url).href;
+		const loader = `export async function resolve(specifier, context, next) {
+			if (specifier === '@js-temporal/polyfill') throw new Error('Calendar polyfill must not be imported eagerly');
+			return next(specifier, context);
+		}`;
+		const source = `
+			import assert from 'node:assert/strict';
+			import { createRequire } from 'node:module';
+			const calendar = await import(${JSON.stringify(moduleUrl)});
+			const require = createRequire(${JSON.stringify(moduleUrl)});
+			const polyfillPath = require.resolve('@js-temporal/polyfill');
+			assert.equal(require.cache[polyfillPath], undefined);
+			const rule = calendar.normalizeCalendarRule({ every: 'day', at: '09:00', timezone: 'UTC' });
+			assert.equal(require.cache[polyfillPath], undefined);
+			const occurrence = calendar.nextCalendarOccurrence(rule, Date.parse('2026-10-02T00:00:00Z'));
+			assert.equal(occurrence.nextRunAt, '2026-10-02T09:00:00.000Z');
+			const loaded = require.cache[polyfillPath];
+			assert.ok(loaded?.loaded);
+			assert.deepEqual(calendar.restoreCalendarTrigger({ kind: 'calendar', ...rule, ...occurrence }), { kind: 'calendar', ...rule, ...occurrence });
+			assert.equal(require.cache[polyfillPath], loaded);
+		`;
+		const child = spawnSync(process.execPath, ["--experimental-strip-types", "--experimental-loader", `data:text/javascript,${encodeURIComponent(loader)}`, "--input-type=module", "--eval", source], { encoding: "utf-8", timeout: 30_000 });
+		assert.equal(child.status, 0, child.error?.message || child.stderr);
+	});
+
+	for (const [name, timezone, at, after, expected] of [
+		["Taipei clock", "Asia/Taipei", "09:00", "2026-10-02T00:00:00Z", "2026-10-02T01:00:00Z"],
+		["strictly after", "Asia/Taipei", "09:00", "2026-10-02T01:00:00Z", "2026-10-03T01:00:00Z"],
+		["spring gap", "America/New_York", "02:30", "2026-03-08T06:00:00Z", "2026-03-09T06:30:00Z"],
+		["first fold instant", "America/New_York", "01:30", "2026-11-01T04:00:00Z", "2026-11-01T05:30:00Z"],
+		["no second fold fire", "America/New_York", "01:30", "2026-11-01T05:30:00Z", "2026-11-02T06:30:00Z"],
+		["half-hour gap", "Australia/Lord_Howe", "02:15", "2026-10-03T14:00:00Z", "2026-10-04T15:15:00Z"],
+		["half-hour fold", "Australia/Lord_Howe", "01:45", "2026-04-04T13:00:00Z", "2026-04-04T14:45:00Z"],
+		["skipped date", "Pacific/Apia", "09:00", "2011-12-29T20:00:00Z", "2011-12-30T19:00:00Z"],
+		["month boundary", "UTC", "09:00", "2026-01-31T09:00:00Z", "2026-02-01T09:00:00Z"],
+		["leap day", "UTC", "09:00", "2028-02-28T09:00:00Z", "2028-02-29T09:00:00Z"],
+	]) it(name!, () => {
+		const rule = normalizeCalendarRule({ every: "day", timezone, at });
+		assert.equal(nextCalendarOccurrence(rule, Date.parse(after!)).nextRunAt, new Date(expected!).toISOString());
+	});
+
+	it("normalizes weekly days and catches up after years without replaying every date", () => {
+		const rule = normalizeCalendarRule({ every: "week", timezone: "Asia/Taipei", at: "09:00", on: ["fri", "mon", "mon"] });
+		assert.deepEqual(rule.on, ["mon", "fri"]);
+		assert.equal(nextCalendarOccurrence(rule, Date.parse("2026-10-02T01:00:00Z")).nextRunAt, "2026-10-05T01:00:00.000Z");
+		assert.equal(latestCalendarOccurrence(rule, Date.parse("2030-01-01T00:00:00Z"), "2000-01-03")?.nextLocalDate, "2029-12-31");
+	});
+	it("uses the pending date to prevent repeating a served fold", () => {
+		const rule = normalizeCalendarRule({ every: "day", timezone: "America/New_York", at: "01:30" });
+		assert.equal(latestCalendarOccurrence(rule, Date.parse("2026-11-01T06:45:00Z"), "2026-11-02"), undefined);
+	});
+	it("restores the date independently of an obsolete UTC cache and skips a new gap", () => {
+		const restored = restoreCalendarTrigger({ kind: "calendar", every: "day", timezone: "America/New_York", at: "02:30", nextLocalDate: "2026-03-08", nextRunAt: "2026-03-08T07:30:00Z" });
+		assert.equal(restored.nextLocalDate, "2026-03-09");
+		assert.equal(restored.nextRunAt, "2026-03-09T06:30:00.000Z");
+	});
+	it("rejects missing zones, fixed offsets, invalid clocks, weekdays and dates", () => {
+		for (const override of [{ timezone: undefined }, { timezone: "+08:00" }, { timezone: "Invalid/Zone" }, { at: "9:00" }, { at: "24:00" }, { every: "day", on: ["mon"] }, { every: "week", on: [] }, { every: "week", on: "mon" }, { every: "week", on: ["MON"] }]) {
+			assert.throws(() => normalizeCalendarRule({ every: "day", at: "09:00", timezone: "UTC", ...override }));
+		}
+		assert.throws(() => restoreCalendarTrigger({ kind: "calendar", every: "day", at: "09:00", timezone: "UTC", nextLocalDate: "2030-02-30", nextRunAt: "2030-03-01T09:00:00Z" }));
+	});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling-agent-allowlist.test.ts

@@ -12,6 +12,7 @@ import {
 } from "../../src/api/capability-ceiling.ts";
 import { runSync } from "../../src/runs/foreground/execution.ts";
 import { buildInProcessChildLaunch } from "../../src/runs/shared/child-launch.ts";
+import { buildRunnerChildLaunch } from "../../src/runs/background/runner-child-launch.ts";
 
 function agent(name: string): AgentConfig {
 	return {
@@ -100,4 +101,41 @@ describe("capability ceiling agent allowlist", () => {
 		assert.deepEqual(capabilityAudit?.agentRestrictionSources, ["plan-mode"]);
 		assert.deepEqual(config.capabilityCeiling?.allowedAgents, ["reviewer"]);
 	});
+
+	it("applies the selected agent's descendant ceiling only after its parent-authorized launch", () => {
+		const base = {
+			host: "parent" as const,
+			cwd: process.cwd(),
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritGlobalContext: false,
+			inheritSkills: false,
+			childAgentName: "coordinator",
+			childIndex: 0,
+			capabilityCeiling: { version: 1 as const, allowedAgents: ["coordinator", "scout"], denyExtensions: false, sources: ["parent"] },
+		};
+		const launch = buildInProcessChildLaunch({ ...base, descendantAllowedAgents: ["scout", "worker"] });
+		assert.equal(launch.capabilityAudit?.agentAllowed, true);
+		assert.deepEqual(launch.config.capabilityCeiling?.allowedAgents, ["scout"]);
+		assert.deepEqual(launch.capabilityAudit?.ceiling, launch.config.capabilityCeiling);
+		assert.deepEqual(launch.config.capabilityCeiling?.sources, ["agent:coordinator", "parent"]);
+		assert.deepEqual(buildInProcessChildLaunch({ ...base, descendantAllowedAgents: [] }).config.capabilityCeiling?.allowedAgents, []);
+		const configuredOnly = buildInProcessChildLaunch({ ...base, capabilityCeiling: undefined, descendantAllowedAgents: [] });
+		assert.deepEqual(configuredOnly.capabilityAudit?.ceiling, configuredOnly.config.capabilityCeiling);
+		assert.deepEqual(configuredOnly.capabilityAudit?.ceiling.allowedAgents, []);
+	});
+
+	it("propagates the detached runner step snapshot through the common launch seam", () => {
+		const launch = buildRunnerChildLaunch({
+			agent: "coordinator",
+			task: "Coordinate",
+			inheritProjectContext: false,
+			inheritGlobalContext: false,
+			inheritSkills: false,
+			allowedAgents: ["scout", "worker"],
+			capabilityCeiling: { version: 1, allowedAgents: ["coordinator", "scout"], denyExtensions: false, sources: ["parent"] },
+		}, { cwd: process.cwd(), id: "allowed-agents-runner", flatIndex: 0 }, { sessionEnabled: false, watchdogStatus() {} });
+		assert.deepEqual(launch.config.capabilityCeiling?.allowedAgents, ["scout"]);
+		assert.deepEqual(launch.capabilityAudit?.ceiling, launch.config.capabilityCeiling);
+	});
 });

package/dist/extensions/pi-subagents/test/unit/chain-root-attachment.test.ts

@@ -43,21 +43,26 @@ describe("async chain root attachment", () => {
 			steps: [{ agent: "worker", status: "complete", sessionFile }],
 		});
 		writeJson(importedRoot.resultPath, {
+			sessionId: "publication-session",
+			toolCallId: "publication-tool-call",
 			state: "complete",
 			success: true,
 		results: [{ agent: "worker", output: "root output", success: true, sessionFile, usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0.001, turns: 1 } }],
 		});
 
 		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1 });
+		fs.writeFileSync(path.join(importedRoot.asyncDir, "status.json"), "{malformed", "utf-8");
 
 		assert.deepEqual({
 			agent: result.agent,
+			importedPublication: result.importedPublication,
 			output: result.output,
 			exitCode: result.exitCode,
 			sessionFile: result.sessionFile,
 			usage: result.usage,
 		}, {
 			agent: "worker",
+			importedPublication: { sessionId: "publication-session", toolCallId: "publication-tool-call" },
 			output: "root output",
 			exitCode: 0,
 			sessionFile,
@@ -171,6 +176,7 @@ describe("async chain root attachment", () => {
 		assert.equal(result.exitCode, 1);
 		assert.equal(result.error, "root failed");
 		assert.equal(result.output, "root failed");
+		assert.deepEqual(result.importedPublication, {});
 	});
 
 	it("imports a partial root without collapsing it to failed", async () => {
@@ -188,7 +194,7 @@ describe("async chain root attachment", () => {
 			state: "partial",
 			success: false,
 			summary: "Required file-only output was not produced: report.md",
-			results: [{ agent: "worker", output: "Required file-only output was not produced: report.md", error: "Required file-only output was not produced: report.md", success: false, effects: { fileMutation: { status: "observed", expected: true, attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } } }],
+			results: [{ agent: "worker", output: "Required file-only output was not produced: report.md", error: "Required file-only output was not produced: report.md", success: false, effects: { fileMutation: { status: "observed", attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } } }],
 		});
 
 		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1 });
@@ -201,7 +207,7 @@ describe("async chain root attachment", () => {
 
 	it("fails a partial root that never produced a result file", async () => {
 		const importedRoot = root();
-		const effects = { fileMutation: { status: "observed", expected: true, attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } };
+		const effects = { fileMutation: { status: "observed", attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } };
 		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
 			runId: importedRoot.runId,
 			mode: "single",
@@ -247,6 +253,7 @@ describe("async chain root attachment", () => {
 		assert.equal(result.agent, "worker");
 		assert.equal(result.exitCode, 1);
 		assert.match(result.error ?? "", /ended without a result file/);
+		assert.equal(result.importedPublication, undefined);
 	});
 
 	it("stops waiting when the parent timeout aborts an attached root", async () => {
@@ -274,5 +281,6 @@ describe("async chain root attachment", () => {
 		assert.equal(result.timedOut, true);
 		assert.equal(result.error, "parent timed out");
 		assert.equal(result.output, "parent timed out");
+		assert.equal(result.importedPublication, undefined);
 	});
 });