@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/smoke/standalone-matrix.mjs

@@ -0,0 +1,65 @@
+// Derived from xz-dev's PR #2049 (910807bf). Fresh isolated stages, one pinned input snapshot.
+// node test/smoke/standalone-matrix.mjs /absolute/official-pi /fresh/artifacts
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+if (process.platform !== "linux" || process.arch !== "x64") {
+	console.log(`SKIP standalone matrix: requires Linux x64/bubblewrap; ${process.platform}/${process.arch} not validated.`);
+	process.exit(0);
+}
+
+const source = fileURLToPath(new URL("../../", import.meta.url));
+const release = JSON.parse(fs.readFileSync(new URL("standalone-release.json", import.meta.url), "utf8"));
+const binary = process.argv[2];
+const root = process.argv[3];
+assert.equal(process.platform, release.platform);
+assert.equal(process.arch, release.arch);
+assert.ok(binary && path.isAbsolute(binary) && fs.existsSync(binary), "an existing absolute official binary path is required on Linux x64");
+assert.ok(root && path.isAbsolute(root) && !fs.existsSync(root), "provide a fresh absolute artifact directory");
+function sha(file) { return createHash("sha256").update(fs.readFileSync(file)).digest("hex"); }
+assert.equal(sha(binary), release.binarySha256, "binary does not match the pinned official release");
+fs.mkdirSync(root, { recursive: true });
+const inputs = ["index.ts", "package.json", "package-lock.json", "scripts/build-package.mjs", "tsconfig.build.json", "tsconfig.json",
+	...fs.readdirSync(source).filter((file) => file.endsWith(".mjs")),
+	...fs.readdirSync(path.join(source, "src"), { recursive: true }).map((file) => `src/${file}`),
+	...fs.readdirSync(path.join(source, "test/smoke")).filter((file) => file.startsWith("standalone-")).map((file) => `test/smoke/${file}`),
+].filter((file) => fs.statSync(path.join(source, file)).isFile()).sort();
+const frozen = Object.fromEntries(inputs.map((file) => [file, sha(path.join(source, file))]));
+fs.writeFileSync(path.join(root, "inputs.json"), JSON.stringify(frozen, null, 2));
+const assertFrozen = () => assert.deepEqual(Object.fromEntries(inputs.map((file) => [file, sha(path.join(source, file))])), frozen, "execution inputs changed during the gate");
+// Every mode must exercise the same candidate, so build and pack exactly once.
+const candidateDir = path.join(root, "candidate");
+fs.mkdirSync(candidateDir);
+const built = spawnSync(process.execPath, ["scripts/build-package.mjs"], { cwd: source, encoding: "utf8", timeout: 180000, maxBuffer: 10 * 1024 * 1024 });
+assert.ifError(built.error);
+assert.equal(built.status, 0, `${built.stdout}${built.stderr}`);
+const packed = spawnSync("npm", ["pack", "--ignore-scripts", "--json", "--pack-destination", candidateDir, path.join(source, "dist-pkg")], { cwd: source, encoding: "utf8", timeout: 90000, maxBuffer: 10 * 1024 * 1024 });
+assert.ifError(packed.error);
+assert.equal(packed.status, 0, packed.stderr);
+const candidate = path.join(candidateDir, JSON.parse(packed.stdout)[0].filename);
+const packageSha = sha(candidate);
+const modes = ["single", "workflow", "shared-run", "parallel-stop", "targeted-controls", "steer", "interrupt", "stop", "child-stop", "child-timeout", "run-timeout", "tool-timeout", "missing-bootstrap", "persistence-failure", "authorization-failure", "sdk-init-failure", "bootstrap-errors", "revival"];
+const receipt = { release, complete: false, cases: [] };
+// Modes run one at a time: they are CPU-bound, and four concurrent modes missed the parent's 45s deadline.
+for (const mode of modes) {
+	assertFrozen();
+	const startedAt = Date.now();
+	const result = spawnSync(process.execPath, [path.join(source, "test/smoke/standalone-background.mjs"), binary, path.join(root, mode), mode, candidate], { cwd: source, encoding: "utf8", timeout: 180000, maxBuffer: 10 * 1024 * 1024 });
+	fs.writeFileSync(path.join(root, `${mode}.log`), `${result.stdout ?? ""}${result.stderr ?? ""}`);
+	receipt.cases.push({ mode, startedAt: new Date(startedAt).toISOString(), durationMs: Date.now() - startedAt, exitCode: result.status, error: result.error?.message });
+	fs.writeFileSync(path.join(root, "matrix.json"), JSON.stringify(receipt, null, 2));
+	assert.ifError(result.error);
+	assert.equal(result.status, 0, `${mode} failed; inspect ${path.join(root, `${mode}.log`)}`);
+	const identity = JSON.parse(fs.readFileSync(path.join(root, mode, "identity.json"), "utf8"));
+	assert.equal(sha(path.join(root, mode, identity.packed)), packageSha, "matrix modes used different packaged candidates");
+	console.log(`PASS ${mode} (${Math.round((Date.now() - startedAt) / 1000)}s)`);
+}
+assertFrozen();
+receipt.complete = true;
+receipt.packageSha256 = packageSha;
+fs.writeFileSync(path.join(root, "matrix.json"), JSON.stringify(receipt, null, 2));
+console.log(`PASS official ${release.version}: ${modes.length} modes; ${root}`);

package/dist/extensions/pi-subagents/test/smoke/standalone-observer.ts

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+import type { ExtensionAPI } from "@selesai/code";
+
+export default function observeBootstrap(pi: ExtensionAPI) {
+	const record = (event: string) => fs.appendFileSync("/stage/bootstrap-observer.jsonl", JSON.stringify({ case: process.env.PI_STANDALONE_CASE, event, pid: process.pid }) + "\n");
+	record("observer-ready");
+	pi.on("session_start", () => { record("session-start"); });
+}

package/dist/extensions/pi-subagents/test/smoke/standalone-parent.ts

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import type { ExtensionAPI } from "@selesai/code";
+import { parseFrontmatter, parseFrontmatterList } from "../../src/agents/frontmatter.js";
+import registerSubagents from "../../index.js";
+import { requestAsyncInterrupt, requestAsyncSteer, requestAsyncStop } from "../../src/runs/background/control-channel.js";
+import { verifyRevival } from "./standalone-revival.ts";
+import { verifySharedRun } from "./standalone-shared.ts";
+
+function waitForFile(file: string, predicate: (text: string) => boolean): Promise<void> {
+	return new Promise((resolve) => {
+		const check = () => {
+			if (fs.existsSync(file) && predicate(fs.readFileSync(file, "utf8"))) { fs.unwatchFile(file, check); resolve(); }
+		};
+		fs.watchFile(file, { interval: 25 }, check);
+		check();
+	});
+}
+
+// Capture only public tool/notification boundaries, never the runner/session factory.
+export default function registerSmoke(pi: ExtensionAPI) {
+	let tool: Parameters<ExtensionAPI["registerTool"]>[0] | undefined;
+	let notifications = 0;
+	let notify: (message: unknown) => void = () => {};
+	const notification = new Promise<unknown>((resolve) => { notify = resolve; });
+	const host = new Proxy(pi, {
+		get(target, key) {
+			if (key === "registerTool") return (definition: Parameters<ExtensionAPI["registerTool"]>[0]) => {
+				target.registerTool(definition);
+				if (definition.name === "subagent") tool = definition;
+			};
+			if (key === "sendMessage") return (...args: Parameters<ExtensionAPI["sendMessage"]>) => {
+				target.sendMessage(args[0], { ...args[1], triggerTurn: false });
+				if (args[0].customType === "subagent-notify") { notifications++; notify(args[0]); }
+			};
+			// An idle parent is woken with a user prompt; drop it so the parent never takes a turn.
+			if (key === "sendUserMessage") return () => {};
+			return Reflect.get(target, key);
+		},
+	});
+	registerSubagents(host);
+	pi.on("session_start", async (_event, ctx) => {
+		const timeout = setTimeout(() => { console.error("Standalone smoke timed out waiting for parent completion"); process.exit(1); }, 45_000);
+		try {
+			assert.ok(tool, "the real extension must register its public subagent tool");
+			const mode = process.env.PI_STANDALONE_SMOKE_MODE ?? "single";
+			assert.ok(["single", "workflow", "targeted-controls", "steer", "interrupt", "stop", "child-stop", "child-timeout", "run-timeout", "tool-timeout", "sdk-init-failure", "persistence-failure", "authorization-failure", "missing-bootstrap", "revival", "shared-run", "parallel-stop"].includes(mode), `unimplemented parent smoke mode: ${mode}`);
+			const expectedDeclaredTools = mode === "tool-timeout" ? ["bash"] : [];
+			// The default bridge adds upward coordination to nonempty menus, not explicit empty ones.
+			const expectedRuntimeTools = mode === "tool-timeout" ? ["bash", "contact_supervisor"] : [];
+			const profile = parseFrontmatter(fs.readFileSync("/stage/work/.selesai/agents/binary-smoke.md", "utf8"));
+			assert.deepEqual(parseFrontmatterList(profile.frontmatter.tools), expectedDeclaredTools);
+			const workflow = ["workflow", "targeted-controls", "child-timeout"].includes(mode);
+			const expectedState = mode === "interrupt" ? "paused" : mode === "stop" ? "stopped" : mode.endsWith("-timeout") || mode === "child-stop" || mode === "sdk-init-failure" ? "failed" : "complete";
+			const workflowScript = mode === "workflow"
+				? `const first = await runs.run("first", { agent: "binary-smoke", task: "Return FIRST." }); const siblings = await runs.all([{ key: "left", agent: "binary-smoke", task: "Return LEFT." }, { key: "right", agent: "binary-smoke", task: "Return RIGHT." }]); return { first, siblings };`
+				: mode === "targeted-controls"
+					? `const left = runs.run("left", { agent: "binary-smoke", task: "Return LEFT." }); const right = runs.run("right", { agent: "binary-smoke", task: "Return RIGHT." }); let interrupted; try { interrupted = await right; } catch (error) { interrupted = String(error); } return { left: await left, right: interrupted };`
+					: mode === "child-timeout"
+						? `return await runs.run("child-deadline", { agent: "binary-smoke", task: "Wait for cancellation.", timeoutMs: 8000 });`
+						: undefined;
+			if (workflowScript !== undefined) fs.writeFileSync("/stage/work/smoke-workflow.js", workflowScript);
+			const request = workflowScript !== undefined ? { workflow: "/stage/work/smoke-workflow.js" } : { agent: "binary-smoke", task: "Return the scripted response." };
+			fs.writeFileSync("/stage/parent-initialized", String(process.pid));
+			if (mode === "shared-run" || mode === "parallel-stop") {
+				await verifySharedRun(host, ctx, mode, waitForFile, notification);
+				assert.equal(notifications, 1);
+				console.log(`PASS standalone native async ${mode}: two SDK sessions, one host, observed shutdown`);
+				process.exit(0);
+			}
+			const startupFailure = mode === "persistence-failure" || mode === "authorization-failure";
+			if (startupFailure) assert.equal(JSON.parse(fs.readFileSync("/stage/startup-hook-ready.json", "utf8")).pid, process.pid);
+			const launching = tool.execute("standalone-smoke", {
+				...request, context: "fresh", async: true,
+				model: "standalone-smoke/local", acceptance: false, timeoutMs: mode === "run-timeout" ? 8000 : 20000, output: false,
+				...(mode === "tool-timeout" ? { toolTimeoutMs: 1000 } : {}),
+			}, new AbortController().signal, undefined, ctx);
+			if (mode === "missing-bootstrap") {
+				assert.ok(fs.existsSync("/stage/withheld-binary-bootstrap.js"));
+				await assert.rejects(launching, /Background runner bootstrap not found/);
+				console.log("PASS standalone native async missing-bootstrap: missing asset rejected at the public launch boundary");
+				process.exit(0);
+			}
+			if (startupFailure) {
+				await assert.rejects(launching, (error: unknown) => {
+					assert.ok(error instanceof Error);
+					assert.match(error.message, new RegExp(`fixture ${mode} after real spawn`));
+					fs.writeFileSync("/stage/launch-error.json", JSON.stringify({ message: error.message }));
+					return true;
+				});
+				assert.ok(fs.existsSync("/stage/failure-injected.json"));
+				const injected = JSON.parse(fs.readFileSync("/stage/failure-injected.json", "utf8"));
+				assert.equal(injected.mode, mode);
+				const terminalPath = `${injected.asyncDir}/process-terminal.json`;
+				await waitForFile(terminalPath, (text) => JSON.parse(text).instances?.some((instance: { kind: string; closeObservedAt?: number }) => instance.kind === "runner" && typeof instance.closeObservedAt === "number"));
+				assert.throws(() => process.kill(injected.pid, 0), { code: "ESRCH" });
+				const status = JSON.parse(fs.readFileSync(`${injected.asyncDir}/status.json`, "utf8"));
+				assert.equal(status.state, "failed");
+				assert.equal(fs.existsSync(`${injected.asyncDir}/runner-startup-proceed.json`), false);
+				const events = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line));
+				assert.ok(events.every((event) => event.pid === process.pid), "positive-control task must never enter a child session");
+				fs.writeFileSync("/stage/startup-failure.json", JSON.stringify({ ...injected, mode, terminal: JSON.parse(fs.readFileSync(terminalPath, "utf8")) }, null, 2));
+				console.log(`PASS standalone native async ${mode}: post-spawn fault observed, no proceed, no child work, runner close observed`);
+				process.exit(0);
+			}
+			const launch = await launching;
+			fs.writeFileSync("/stage/launch.json", JSON.stringify(launch, null, 2));
+			assert.notEqual(launch.isError, true, JSON.stringify(launch));
+			const details = launch.details as { asyncDir: string; asyncId: string };
+			if (["steer", "interrupt", "stop", "child-stop"].includes(mode)) {
+				await waitForFile("/stage/lifecycle.jsonl", (text) => text.includes('"event":"request"'));
+				if (mode === "interrupt") requestAsyncInterrupt(details.asyncDir);
+				if (mode === "stop") requestAsyncStop(details.asyncDir);
+				if (mode === "child-stop") requestAsyncStop(details.asyncDir, { targetIndex: 0, childId: "step:0" });
+				if (mode === "steer") {
+					requestAsyncSteer(details.asyncDir, { id: "binary-steer", targetIndex: 0, message: "UNIQUE_STEERING_MARKER" });
+					await waitForFile(`${details.asyncDir}/events.jsonl`, (text) => text.includes('"type":"subagent.steer.queued"'));
+					fs.writeFileSync("/stage/release", "go");
+				}
+			}
+			if (mode === "targeted-controls") {
+				await waitForFile("/stage/lifecycle.jsonl", (text) => text.split("\n").filter((line) => line.includes('"event":"request"')).length === 2);
+				const active = JSON.parse(fs.readFileSync(`${details.asyncDir}/status.json`, "utf8"));
+				const [left, right] = active.steps.map((step: { runId: string }) => path.join(path.dirname(details.asyncDir), step.runId));
+				requestAsyncSteer(left, { id: "binary-steer", targetIndex: 0, message: "UNIQUE_STEERING_MARKER" });
+				await waitForFile(`${left}/events.jsonl`, (text) => text.includes('"type":"subagent.steer.queued"'));
+				requestAsyncInterrupt(right);
+				await waitForFile(`${right}/status.json`, (text) => JSON.parse(text).state === "paused");
+				assert.equal(JSON.parse(fs.readFileSync(`${left}/status.json`, "utf8")).state, "running", "interrupting right must leave left running");
+				fs.writeFileSync("/stage/release", "go");
+			}
+			if (mode === "tool-timeout") await waitForFile("/stage/tool.pid", (text) => /^\d+\s*$/.test(text));
+			const completed = await notification;
+			fs.writeFileSync("/stage/notification.json", JSON.stringify(completed, null, 2));
+			if (expectedState === "complete") assert.match(JSON.stringify(completed), /standalone child response verified/);
+			const parentStatus = JSON.parse(fs.readFileSync(`${details.asyncDir}/status.json`, "utf8"));
+			const runIds: string[] = workflow ? parentStatus.steps.map((step: { runId: string }) => step.runId) : [details.asyncId];
+			assert.equal(new Set(runIds).size, mode === "workflow" ? 3 : mode === "targeted-controls" ? 2 : 1);
+			for (const runId of runIds) {
+				const runDir = path.join(path.dirname(details.asyncDir), runId);
+				const terminalPath = `${runDir}/process-terminal.json`;
+				const atNotification = JSON.parse(fs.readFileSync(terminalPath, "utf8"));
+				fs.appendFileSync("/stage/notification-terminal.jsonl", JSON.stringify({ runId, state: atNotification.state }) + "\n");
+				// Notification can precede disposal: read shutdown evidence only after observed close.
+				if (atNotification.state !== "observed") await waitForFile(terminalPath, (text) => JSON.parse(text).state === "observed");
+				const terminal = JSON.parse(fs.readFileSync(terminalPath, "utf8"));
+				assert.equal(terminal.state, "observed");
+				assert.equal(terminal.runId, runId);
+				assert.ok(terminal.instances.some((instance: { kind: string; exitCode: number }) => instance.kind === "runner" && instance.exitCode === 0));
+				const lifecycle = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line));
+				const status = JSON.parse(fs.readFileSync(`${runDir}/status.json`, "utf8"));
+				const runState = mode === "targeted-controls" && runIds.indexOf(runId) === 1 ? "paused" : expectedState;
+				const steered = mode === "steer" || (mode === "targeted-controls" && runIds.indexOf(runId) === 0);
+				assert.equal(status.state, runState, JSON.stringify(status));
+				if (mode === "stop" || mode === "child-stop") assert.equal(status.steps[0].status, "stopped");
+				assert.equal(status.sessionId, ctx.sessionManager.getSessionId());
+				assert.equal(status.completionOwnerId, parentStatus.completionOwnerId);
+				assert.equal(status.steps[0].model, "standalone-smoke/local");
+				const descriptor = JSON.parse(fs.readFileSync(`${runDir}/recovery-descriptor.json`, "utf8"));
+				assert.deepEqual(descriptor.tools, expectedDeclaredTools);
+				const observed = fs.readFileSync("/stage/bootstrap-observer.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid === status.pid);
+				assert.deepEqual(observed.map((event) => event.event), mode === "sdk-init-failure" ? ["observer-ready"] : ["observer-ready", "session-start"]);
+				if (mode === "sdk-init-failure") {
+					assert.equal(JSON.parse(fs.readFileSync("/stage/provider-failure.json", "utf8")).pid, status.pid);
+					assert.match(status.error, /Model "standalone-smoke\/local" not found/);
+				} else {
+					const starts = lifecycle.filter((entry) => entry.event === "start" && entry.pid === status.pid);
+					assert.equal(starts.length, 1, "outer bootstrap must not start an extra provider session");
+					assert.deepEqual(starts[0].tools, expectedRuntimeTools);
+					assert.equal(starts[0].provider, "standalone-smoke");
+					assert.equal(starts[0].model, "local");
+					if (runState === "complete") {
+						assert.ok(fs.existsSync(status.steps[0].sessionFile));
+						const output = fs.readFileSync(status.steps[0].transcriptPath, "utf8");
+						assert.match(output, /standalone child response verified/);
+						if (mode === "workflow") assert.ok(output.includes(["FIRST", "LEFT", "RIGHT"][runIds.indexOf(runId)]));
+					}
+					if (mode.endsWith("-timeout")) {
+						assert.equal(status.steps[0].timedOut, true);
+						assert.match(status.steps[0].error, mode === "tool-timeout" ? /Tool 'bash' exceeded its timeout of 1000ms/ : /timed out after 8000ms/);
+					}
+					if (steered) {
+						const followup = lifecycle.find((entry) => entry.event === "followup" && entry.pid === status.pid);
+						assert.ok(followup && JSON.stringify(followup.messages).includes("UNIQUE_STEERING_MARKER"));
+					}
+					const child = lifecycle.find((entry) => entry.event === "shutdown" && entry.pid === status.pid && entry.calls === (steered ? 2 : 1));
+					assert.ok(child, "each real run must prompt and shut down its child session");
+				}
+				assert.throws(() => process.kill(status.pid, 0), { code: "ESRCH" });
+			}
+			if (mode === "tool-timeout") {
+				const toolPid = Number(fs.readFileSync("/stage/tool.pid", "utf8"));
+				assert.throws(() => process.kill(toolPid, 0), { code: "ESRCH" });
+			}
+			assert.equal(notifications, 1, "one logical parent completion, not an extra bootstrap completion");
+			if (mode === "revival") {
+				const deliveries: Record<string, number> = {};
+				await verifyRevival(tool, ctx, details, waitForFile, (text) => new Promise<void>((resolve) => {
+					deliveries[text] = 0;
+					notify = (message) => {
+						if (JSON.stringify(message).includes(text)) {
+							deliveries[text]++;
+							fs.appendFileSync("/stage/revival-notifications.jsonl", JSON.stringify(message) + "\n");
+							resolve();
+						}
+					};
+				}));
+				assert.deepEqual(Object.values(deliveries), [1, 1]);
+			}
+			console.log(`PASS standalone native async ${mode}: ${runIds.length} run(s), checked SDK lifecycle, observed exits, parent notification`);
+			process.exit(0);
+		} catch (error) {
+			console.error(error);
+			process.exit(1);
+		} finally {
+			clearTimeout(timeout);
+		}
+	});
+}

package/dist/extensions/pi-subagents/test/smoke/standalone-provider.ts

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { fauxProvider, fauxAssistantMessage, fauxToolCall } from "@earendil-works/pi-ai";
+import { SessionManager, type ExtensionAPI } from "@selesai/code";
+
+function waitForRelease(signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve) => {
+		const finish = () => { watcher.close(); signal?.removeEventListener("abort", finish); resolve(); };
+		const watcher = fs.watch("/stage", (_event, file) => { if (file === "release") finish(); });
+		signal?.addEventListener("abort", finish, { once: true });
+		if (signal?.aborted || fs.existsSync("/stage/release")) finish();
+	});
+}
+
+export default function registerSmokeProvider(pi: ExtensionAPI) {
+	const mode = process.env.PI_STANDALONE_SMOKE_MODE;
+	if (mode === "sdk-init-failure" && fs.existsSync("/stage/parent-initialized")) {
+		fs.writeFileSync("/stage/provider-failure.json", JSON.stringify({ pid: process.pid, reason: "fixture provider initialization failure" }));
+		throw new Error("fixture provider initialization failure");
+	}
+	const faux = fauxProvider({ provider: "standalone-smoke", models: [{ id: "local" }], tokensPerSecond: 100000 });
+	faux.setResponses([
+		async (context, options) => {
+			const messages = JSON.stringify(context.messages);
+			const revival = mode === "revival" && /REVIVAL_[AB]/.test(messages);
+			const failingRevival = mode === "revival" && messages.includes("REVIVAL_FAIL");
+			const waiting = !failingRevival && (revival || ["shared-run", "parallel-stop", "targeted-controls", "steer", "interrupt", "stop", "child-stop", "child-timeout", "run-timeout"].includes(mode ?? "")) ? waitForRelease(options?.signal) : undefined;
+			fs.appendFileSync("/stage/lifecycle.jsonl", JSON.stringify({ event: "request", case: process.env.PI_STANDALONE_CASE, pid: process.pid, messages: context.messages }) + "\n");
+			await waiting;
+			if (failingRevival) return fauxAssistantMessage("", { stopReason: "error", errorMessage: "fixture revival failure" });
+			if (revival) return fauxAssistantMessage(`standalone child response verified ${messages.includes("REVIVAL_A") ? "REVIVAL_A" : "REVIVAL_B"}`);
+			if (mode === "tool-timeout") return fauxAssistantMessage(fauxToolCall("bash", { command: 'printf "%s\\n" "$$" > /stage/tool.pid; exec sleep 60' }), { stopReason: "toolUse" });
+			const label = ["FIRST", "LEFT", "RIGHT"].find((name) => JSON.stringify(context.messages).includes(name)) ?? "SINGLE";
+			return fauxAssistantMessage(`standalone child response verified ${label}`);
+		},
+		async (context, options) => {
+			const shared = mode === "shared-run" || mode === "parallel-stop";
+			const waiting = shared ? waitForRelease(options?.signal) : undefined;
+			fs.appendFileSync("/stage/lifecycle.jsonl", JSON.stringify({ event: shared ? "request" : "followup", case: process.env.PI_STANDALONE_CASE, pid: process.pid, messages: context.messages }) + "\n");
+			await waiting;
+			if (shared) {
+				const label = ["LEFT", "RIGHT"].find((name) => JSON.stringify(context.messages).includes(name));
+				return fauxAssistantMessage(`standalone child response verified ${label}`);
+			}
+			return fauxAssistantMessage("standalone child response verified after steering");
+		},
+	]);
+	pi.registerProvider(faux.provider);
+	pi.on("session_start", (_event, ctx) => {
+		assert.ok(ctx.sessionManager instanceof SessionManager, "extension and real session must share the embedded SDK identity");
+		fs.appendFileSync("/stage/lifecycle.jsonl", JSON.stringify({ event: "start", sessionId: ctx.sessionManager.getSessionId(), sdkIdentity: ctx.sessionManager instanceof SessionManager, case: process.env.PI_STANDALONE_CASE, pid: process.pid, executable: process.execPath, tools: pi.getActiveTools(), model: ctx.model?.id, provider: ctx.model?.provider }) + "\n");
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		// Exercise notification-before-disposal ordering without adding another matrix mode.
+		if (mode === "interrupt") await new Promise((resolve) => setTimeout(resolve, 250));
+		fs.appendFileSync("/stage/lifecycle.jsonl", JSON.stringify({ event: "shutdown", sessionId: ctx.sessionManager.getSessionId(), sessionFile: ctx.sessionManager.getSessionFile(), case: process.env.PI_STANDALONE_CASE, pid: process.pid, calls: faux.state.callCount }) + "\n");
+	});
+}

package/dist/extensions/pi-subagents/test/smoke/standalone-release.json

@@ -0,0 +1,8 @@
+{
+  "version": "0.86.1",
+  "platform": "linux",
+  "arch": "x64",
+  "url": "https://github.com/earendil-works/pi/releases/download/v0.86.1/pi-linux-x64.tar.gz",
+  "archiveSha256": "2494f5587a8774a10296d00a7e504e7ad05596ca93e057cb89372c8b1a7f46a9",
+  "binarySha256": "9b939197c9ca98182981fc448ac6d441076d3c37360cf8dc649193e664fcf6f7"
+}

package/dist/extensions/pi-subagents/test/smoke/standalone-revival.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import { inspectSessionLease } from "../../src/runs/shared/session-lease.js";
+
+type Run = { asyncId: string; asyncDir: string };
+
+export async function verifyRevival(
+	tool: Parameters<ExtensionAPI["registerTool"]>[0],
+	ctx: ExtensionContext,
+	source: Run,
+	waitForFile: (file: string, predicate: (text: string) => boolean) => Promise<void>,
+	nextCompletion: (text: string) => Promise<void>,
+): Promise<void> {
+	assert.equal(JSON.parse(fs.readFileSync("/stage/startup-hook-ready.json", "utf8")).mode, "revival");
+	const sourceStatus = JSON.parse(fs.readFileSync(`${source.asyncDir}/status.json`, "utf8"));
+	const sessionFile: string = sourceStatus.steps[0].sessionFile;
+	assert.ok(fs.existsSync(sessionFile));
+	const initialLease = inspectSessionLease(sessionFile);
+	assert.equal(initialLease.state, "free");
+	const { canonicalSessionFile, canonicalSessionId } = initialLease;
+	const root = path.dirname(source.asyncDir);
+	const before = new Set(fs.readdirSync(root));
+	const completed = nextCompletion("standalone child response verified REVIVAL_");
+	// Establish a real owner first, then challenge it while its provider call holds the lease.
+	const winnerLaunch = await tool.execute(
+		"REVIVAL_A", { action: "resume", id: source.asyncId, message: "REVIVAL_A", acceptance: false, timeoutMs: 20000 },
+		new AbortController().signal, undefined, ctx,
+	);
+	const winner = winnerLaunch.details as Run;
+	const winnerStatus = JSON.parse(fs.readFileSync(`${winner.asyncDir}/status.json`, "utf8"));
+	assert.notEqual(winnerStatus.pid, process.pid);
+	assert.doesNotThrow(() => process.kill(winnerStatus.pid, 0));
+	const lease = inspectSessionLease(sessionFile);
+	assert.ok(lease.state === "owned");
+	assert.equal(lease.canonicalSessionFile, canonicalSessionFile);
+	assert.equal(lease.canonicalSessionId, canonicalSessionId);
+	assert.equal(lease.owner.canonicalSessionFile, canonicalSessionFile);
+	assert.equal(lease.owner.runId, winner.asyncId);
+	assert.equal(lease.owner.sourceRunId, source.asyncId);
+	assert.equal(lease.owner.parentSessionId, ctx.sessionManager.getSessionId());
+	assert.equal(lease.owner.pid, winnerStatus.pid);
+	await waitForFile("/stage/lifecycle.jsonl", (text) => text.trim().split("\n").map((line) => JSON.parse(line)).some((event) => event.event === "request" && event.pid === lease.owner.pid));
+	const request = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).find((event) => event.event === "request" && event.pid === lease.owner.pid);
+	assert.ok(JSON.stringify(request.messages).includes("standalone child response verified SINGLE"), "revival must load the actual previous SDK conversation");
+	const refusal = await tool.execute(
+		"REVIVAL_B", { action: "resume", id: source.asyncId, message: "REVIVAL_B", acceptance: false, timeoutMs: 20000 },
+		new AbortController().signal, undefined, ctx,
+	).then(() => assert.fail("a second revival must not acquire the owned session"), String);
+	assert.ok(refusal.includes(`'${canonicalSessionFile}' is already owned by run '${winner.asyncId}'`), "a second revival must refuse the exact owned session and name its owner");
+	fs.writeFileSync("/stage/revival-competition.json", JSON.stringify({ winner, refusal, owner: { runId: lease.owner.runId, sourceRunId: lease.owner.sourceRunId, pid: lease.owner.pid } }, null, 2));
+	const contenders = fs.readdirSync(root).filter((name) => !before.has(name));
+	assert.equal(contenders.length, 2, "both requests must reach independent configured runners");
+	const losingId = contenders.find((id) => id !== winner.asyncId)!;
+	await waitForFile(`${root}/${losingId}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+	const losingTerminal = JSON.parse(fs.readFileSync(`${root}/${losingId}/process-terminal.json`, "utf8"));
+	assert.equal(losingTerminal.state, "observed");
+	const losingStatus = JSON.parse(fs.readFileSync(`${root}/${losingId}/status.json`, "utf8"));
+	assert.equal(losingStatus.state, "failed");
+	assert.notEqual(losingStatus.pid, winnerStatus.pid);
+	assert.notEqual(losingStatus.processTerminal.runnerProcessInstanceId, winnerStatus.processTerminal.runnerProcessInstanceId);
+	assert.throws(() => process.kill(losingStatus.pid, 0), { code: "ESRCH" });
+	assert.ok(!fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).some((event) => event.pid === losingStatus.pid), "loser must not enter the provider/session");
+	const retainedLease = inspectSessionLease(sessionFile);
+	assert.ok(retainedLease.state === "owned", "loser cleanup must not release the winner's lease");
+	assert.equal(retainedLease.canonicalSessionId, canonicalSessionId);
+	assert.deepEqual(
+		{ token: retainedLease.owner.token, runId: retainedLease.owner.runId, sourceRunId: retainedLease.owner.sourceRunId, parentSessionId: retainedLease.owner.parentSessionId, pid: retainedLease.owner.pid },
+		{ token: lease.owner.token, runId: lease.owner.runId, sourceRunId: lease.owner.sourceRunId, parentSessionId: lease.owner.parentSessionId, pid: lease.owner.pid },
+		"loser cleanup must not replace or release the winner's lease",
+	);
+	fs.writeFileSync("/stage/release", "go");
+	await completed;
+	await finish(winner, "complete", lease.owner.token);
+
+	const failedCompletion = nextCompletion("fixture revival failure");
+	const failedLaunch = await tool.execute("revival-failure", { action: "resume", id: winner.asyncId, message: "REVIVAL_FAIL", acceptance: false, timeoutMs: 20000 }, new AbortController().signal, undefined, ctx);
+	const failed = failedLaunch.details as Run;
+	await failedCompletion;
+	await waitForFile(`${failed.asyncDir}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+	const failedCandidate = JSON.parse(fs.readFileSync(`${failed.asyncDir}/process-terminal-candidate.json`, "utf8"));
+	assert.equal(typeof failedCandidate.revivalLeaseToken, "string");
+	await finish(failed, "failed", failedCandidate.revivalLeaseToken);
+	assert.match(JSON.parse(fs.readFileSync(`${failed.asyncDir}/status.json`, "utf8")).error, /fixture revival failure/);
+	fs.writeFileSync("/stage/revival-result.json", JSON.stringify({ source, winner, loser: losingId, failed, sessionFile }, null, 2));
+
+	async function finish(run: Run, state: string, token: string): Promise<void> {
+		await waitForFile(`${run.asyncDir}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+		const status = JSON.parse(fs.readFileSync(`${run.asyncDir}/status.json`, "utf8"));
+		const terminal = JSON.parse(fs.readFileSync(`${run.asyncDir}/process-terminal.json`, "utf8"));
+		const candidate = JSON.parse(fs.readFileSync(`${run.asyncDir}/process-terminal-candidate.json`, "utf8"));
+		assert.equal(status.state, state);
+		assert.equal(status.sessionId, ctx.sessionManager.getSessionId());
+		assert.equal(status.steps[0].sessionFile, sessionFile);
+		assert.equal(terminal.state, "observed");
+		assert.equal(terminal.canonicalSession.leaseDisposition, "released");
+		assert.equal(terminal.canonicalSession.canonicalSessionLeaseReleased, true);
+		assert.equal(candidate.revivalLeaseToken, token);
+		assert.equal(candidate.revivalLeaseReleaseAcknowledged, true);
+		assert.equal(inspectSessionLease(sessionFile).state, "free");
+		assert.throws(() => process.kill(status.pid, 0), { code: "ESRCH" });
+		const handshake = fs.readFileSync("/stage/handshake.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.runId === run.asyncId);
+		assert.deepEqual(handshake.map((event) => [event.action, event.stateBefore]), [["ack", "ready"], ["confirm", "acknowledged"], ["proceed", "confirmed"]]);
+		assert.ok(handshake.every((event) => event.tokenMatches && !event.childStartedBeforeCommit));
+		const lifecycle = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid === status.pid);
+		assert.deepEqual(lifecycle.map((event) => event.event), ["start", "request", "shutdown"]);
+	}
+}

package/dist/extensions/pi-subagents/test/smoke/standalone-shared.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import { discoverAgents } from "../../src/agents/agents.js";
+import { executeAsyncChain } from "../../src/runs/background/async-execution.js";
+import { requestAsyncStop } from "../../src/runs/background/control-channel.js";
+import { resolveControlConfig } from "../../src/runs/shared/subagent-control.js";
+import { DEFAULT_ARTIFACT_CONFIG } from "../../src/shared/types.js";
+
+export async function verifySharedRun(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	mode: string,
+	waitForFile: (file: string, predicate: (text: string) => boolean) => Promise<void>,
+	completed: Promise<unknown>,
+): Promise<void> {
+	// Public workflows create independent runs. Use the existing private execution
+	// seam to exercise two real SDK sessions inside ONE configured runner.
+	const launch = executeAsyncChain(randomUUID(), {
+		chain: [{ parallel: ["LEFT", "RIGHT"].map((task) => ({ agent: "binary-smoke", task, output: false, acceptance: false })) }],
+		agents: discoverAgents(ctx.cwd, "project").agents,
+		ctx: { pi, cwd: ctx.cwd, currentSessionId: ctx.sessionManager.getSessionId(), parentSessionId: ctx.sessionManager.getSessionId(), currentModel: ctx.model },
+		artifactConfig: DEFAULT_ARTIFACT_CONFIG,
+		artifactsDir: "/stage/shared-artifacts",
+		shareEnabled: false,
+		sessionRoot: "/stage/shared-sessions",
+		maxSubagentDepth: 2,
+		globalConcurrencyLimit: 2,
+		controlConfig: resolveControlConfig(undefined, { enabled: true }),
+		timeoutMs: 20000,
+	});
+	assert.notEqual(launch.isError, true, JSON.stringify(launch));
+	fs.writeFileSync("/stage/launch.json", JSON.stringify(launch, null, 2));
+	const { asyncId, asyncDir } = launch.details;
+	assert.ok(asyncId && asyncDir);
+	await waitForFile("/stage/lifecycle.jsonl", (text) => text.trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.event === "request").length === 2);
+	const active = JSON.parse(fs.readFileSync(`${asyncDir}/status.json`, "utf8"));
+	assert.equal(active.steps.length, 2);
+	assert.equal(active.state, "running");
+	// Held requests witness execution even if status projection lags them.
+	const held = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid === active.pid);
+	assert.equal(held.filter((event) => event.event === "request").length, 2);
+	assert.equal(held.filter((event) => event.event === "shutdown").length, 0);
+	fs.writeFileSync("/stage/shared-active-witness.json", JSON.stringify({ pid: active.pid, heldRequests: 2, shutdowns: 0, projectedSteps: active.steps.map((step: { status: string }) => step.status) }));
+	if (mode === "parallel-stop") fs.writeFileSync("/stage/parallel-control.json", JSON.stringify(requestAsyncStop(asyncDir)));
+	else fs.writeFileSync("/stage/release", "go");
+	await completed;
+	await waitForFile(`${asyncDir}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+	const status = JSON.parse(fs.readFileSync(`${asyncDir}/status.json`, "utf8"));
+	const terminal = JSON.parse(fs.readFileSync(`${asyncDir}/process-terminal.json`, "utf8"));
+	assert.equal(status.state, mode === "parallel-stop" ? "stopped" : "complete");
+	assert.equal(status.sessionId, ctx.sessionManager.getSessionId());
+	assert.equal(status.runId, asyncId);
+	assert.equal(terminal.state, "observed");
+	assert.equal(terminal.instances.length, 1, "one host process, no per-session CLI writers");
+	assert.equal(terminal.instances[0].exitCode, 0);
+	assert.throws(() => process.kill(status.pid, 0), { code: "ESRCH" });
+	const lifecycle = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid !== process.pid);
+	assert.ok(lifecycle.every((event) => event.pid === status.pid));
+	const starts = lifecycle.filter((event) => event.event === "start");
+	const shutdowns = lifecycle.filter((event) => event.event === "shutdown");
+	assert.equal(starts.length, 2);
+	assert.equal(shutdowns.length, 2);
+	assert.equal(new Set(starts.map((event) => event.sessionId)).size, 2);
+	assert.deepEqual(shutdowns.map((event) => event.sessionId).sort(), starts.map((event) => event.sessionId).sort());
+	assert.ok(starts.every((event) => event.sdkIdentity && event.provider === "standalone-smoke" && event.model === "local"));
+	if (mode === "shared-run") {
+		const transcripts = status.steps.map((step: { transcriptPath: string }) => fs.readFileSync(step.transcriptPath, "utf8"));
+		assert.ok(transcripts[0].includes("standalone child response verified LEFT"));
+		assert.ok(transcripts[1].includes("standalone child response verified RIGHT"));
+		const sessions = shutdowns.map((event) => fs.readFileSync(event.sessionFile, "utf8"));
+		assert.equal(new Set(shutdowns.map((event) => event.sessionFile)).size, 2);
+		for (const label of ["LEFT", "RIGHT"]) assert.equal(sessions.filter((text) => text.includes(`standalone child response verified ${label}`)).length, 1);
+	} else {
+		assert.ok(status.steps.every((step: { status: string }) => step.status === "stopped"));
+	}
+	fs.writeFileSync("/stage/shared-result.json", JSON.stringify({ asyncId, asyncDir, mode, sessions: starts.map((event) => event.sessionId), terminal }, null, 2));
+}