@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/integration/workflow-worktree-admission.test.ts

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { createEventBus, makeAgent, makeMinimalCtx } from "../support/helpers.ts";
+import { installAsyncExecutionHooks, available, createSubagentExecutor, mockPi, tempDir, createRepo, readAsyncPayload, ASYNC_DIR } from "../support/async-execution-fixture.ts";
+
+function makeAdmissionExecutor(config: Record<string, unknown> = {}) {
+	return createSubagentExecutor!({
+		pi: { events: createEventBus(), getSessionName: () => undefined, sendMessage() {} },
+		state: { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null },
+		config,
+		asyncByDefault: false,
+		tempArtifactsDir: tempDir,
+		getSubagentSessionRoot: () => tempDir,
+		expandTilde: (p: string) => p,
+		discoverAgents: () => ({ agents: [makeAgent("worker")] }),
+	});
+}
+
+function callCount(): number {
+	return fs.readdirSync(mockPi.dir).filter((name) => name.startsWith("call-") && name.endsWith(".json")).length;
+}
+
+describe("public workflow worktree admission", { skip: !available }, () => {
+	installAsyncExecutionHooks();
+	it("rejects a direct async worktree launch before returning a receipt", async () => {
+		const repo = createRepo("pi-direct-admission-dirty-");
+		fs.writeFileSync(path.join(repo, "untracked.txt"), "dirty");
+		const asyncDirExistedBefore = fs.existsSync(ASYNC_DIR);
+		const asyncEntriesBefore = new Set(asyncDirExistedBefore ? fs.readdirSync(ASYNC_DIR) : []);
+		try {
+			const executor = makeAdmissionExecutor();
+			const result = await executor.executePublic("direct-admission-dirty", {
+				agent: "worker", task: "Inspect", async: true, worktree: true, cwd: repo, output: false,
+			}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+
+			assert.equal(result.isError, true);
+			assert.match(result.content.map((item) => item.text).join("\n"), /worktree isolation requires a clean git working tree\. Commit or stash changes first\./);
+			assert.equal(result.details?.asyncId, undefined);
+			assert.equal(callCount(), 0);
+			assert.equal(fs.existsSync(ASYNC_DIR), asyncDirExistedBefore);
+			assert.deepEqual(new Set(asyncDirExistedBefore ? fs.readdirSync(ASYNC_DIR) : []), asyncEntriesBefore);
+		} finally {
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+	for (const async of [false, true]) {
+		for (const source of ["nonrepo", "dirty"] as const) {
+			it(`rejects a mixed ${source} group before child dispatch or budget claims (async=${async})`, async () => {
+				const repo = createRepo("pi-admission-valid-");
+				const invalid = source === "dirty" ? createRepo("pi-admission-dirty-") : tempDir;
+				if (source === "dirty") fs.writeFileSync(path.join(invalid, "untracked.txt"), "dirty");
+				try {
+					const executor = makeAdmissionExecutor(source === "dirty" ? { worktree: true } : {});
+					const output = path.join(tempDir, "child-output.md");
+					const script = `const results = await runs.all([${JSON.stringify(repo)}, ${JSON.stringify(invalid)}].map((cwd, i) => ({ key: 'child-' + i, agent: 'worker', task: 'Inspect', cwd, output: i === 0 ? ${JSON.stringify(output)} : false }))); if (results.some(r => !r.ok)) throw new Error(results.map(r => r.error).join('; ')); return results;`;
+					const result = await executor.executePublic(`admission-${source}-${async}`, { workflowScript: script, async, ...(source === "nonrepo" ? { isolation: "worktree" } : {}), maxSubagentSpawnsPerRun: 2, output: false }, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+					let budget: unknown;
+					if (async) {
+						assert.ok(result.details?.asyncId);
+						const payload = await readAsyncPayload(result.details.asyncId);
+						assert.equal(payload.success, false);
+						assert.match(payload.error ?? "", /Worktree admission failed.*child-1/);
+						const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, result.details.asyncId, "status.json"), "utf8"));
+						budget = status.runFanoutBudget;
+						assert.ok(status.steps.every((step: { runId?: string }) => !step.runId));
+					} else {
+						assert.equal(result.isError, true);
+						assert.match(result.content.map((item) => item.text).join("\n"), /Worktree admission failed.*child-1/);
+						budget = (result.details as { runFanoutBudget?: unknown }).runFanoutBudget;
+					}
+					assert.deepEqual(budget, { used: 0, limit: 2, remaining: 2 });
+					assert.equal(callCount(), 0);
+					assert.equal(fs.existsSync(output), false);
+				} finally {
+					fs.rmSync(repo, { recursive: true, force: true });
+					if (invalid !== tempDir) fs.rmSync(invalid, { recursive: true, force: true });
+				}
+			});
+		}
+	}
+	it("launches a valid isolated child and preserves explicit false on a non-repository sibling", async () => {
+		const repo = createRepo("pi-admission-clean-");
+		mockPi.onCall({ output: "Inspected" });
+		mockPi.onCall({ output: "Shared cwd inspected" });
+		try {
+			const executor = makeAdmissionExecutor({ worktreeProvider: "native", worktree: true });
+			const result = await executor.executePublic("admission-clean", {
+				workflowScript: `const results = await runs.all([{ key: 'isolated', agent: 'worker', task: 'Inspect', cwd: ${JSON.stringify(repo)}, async: false }, { key: 'shared', agent: 'worker', task: 'Inspect shared', worktree: false, async: false }]); return results.map(r => r.ok);`,
+				async: false, worktree: true, output: false,
+			}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+			assert.notEqual(result.isError, true, JSON.stringify(result));
+			assert.equal(callCount(), 2);
+			assert.deepEqual((result.details as { workflow?: { value?: unknown } }).workflow?.value, [true, true]);
+		} finally {
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/smoke/clean-install.mjs

@@ -0,0 +1,106 @@
+// Run with Node >=22.19.0: node --experimental-strip-types test/smoke/clean-install.mjs [artifact-dir] [0.86.1|1.0.0]
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const source = fileURLToPath(new URL("../../", import.meta.url));
+const version = process.argv[3] ?? "0.86.1";
+const supportedVersions = ["0.86.1", "1.0.0"];
+assert.ok(supportedVersions.includes(version), `requires a supported smoke version: ${supportedVersions.join(", ")}`);
+const root = process.argv[2] ? path.resolve(process.argv[2]) : fs.mkdtempSync(path.join(os.tmpdir(), "clean-install-smoke-"));
+fs.mkdirSync(root, { recursive: true });
+const host = path.join(root, "host");
+const extension = path.join(root, "extension");
+const cwd = path.join(root, "cwd");
+for (const dir of [host, extension, cwd, path.join(root, "home")]) fs.mkdirSync(dir, { recursive: true });
+assert.ok(!fs.existsSync(path.join(host, "node_modules")), "requires a pristine host install");
+assert.ok(!fs.existsSync(path.join(extension, "node_modules")), "requires a pristine extension install");
+const env = {
+	...process.env, HOME: path.join(root, "home"), USERPROFILE: path.join(root, "home"), SELESAI_CODING_AGENT_DIR: path.join(root, "agent"),
+	XDG_CACHE_HOME: path.join(root, "cache"), npm_config_cache: path.join(root, "npm-cache"),
+	NODE_COMPILE_CACHE: path.join(root, "node-cache"), JITI_FS_CACHE: "false", PI_OFFLINE: "1",
+};
+// Do not inherit loader/alias overrides or operator credentials into the child.
+for (const key of Object.keys(env)) {
+	if (/API_KEY|TOKEN|SECRET|PASSWORD/.test(key) || ["NODE_OPTIONS", "NODE_PATH", "JITI_ALIAS"].includes(key)) delete env[key];
+}
+function run(name, command, args, workdir, extra = {}, success = true) {
+	const result = spawnSync(command, args, { cwd: workdir, env: { ...env, ...extra }, encoding: "utf8", timeout: 180000, maxBuffer: 10 * 1024 * 1024 });
+	fs.writeFileSync(path.join(root, `${name}.log`), `${result.stdout ?? ""}${result.stderr ?? ""}`);
+	assert.ifError(result.error);
+	if (success) assert.equal(result.status, 0, `${name}: ${result.stdout}\n${result.stderr}`);
+	else assert.notEqual(result.status, 0, `${name} unexpectedly passed`);
+	return result;
+}
+fs.writeFileSync(path.join(host, "package.json"), JSON.stringify({ private: true, dependencies: { "@selesai/code": version } }));
+run("host-install", "npm", ["install", "--no-audit", "--no-fund"], host);
+run("build-package", process.execPath, ["scripts/build-package.mjs"], source);
+const packed = JSON.parse(run("pack", "npm", ["pack", "--json", "--pack-destination", root, path.join(source, "dist-pkg")], source).stdout)[0];
+assert.ok(packed.files.some(file => file.path === "runner-peer-preload.mjs"), "peer preload must ship");
+assert.ok(packed.files.some(file => file.path === "runner-peer-loader.mjs"), "older-Node peer loader must ship");
+assert.equal(packed.files.some(file => file.path.endsWith(".ts") && !file.path.endsWith(".d.ts")), false, "package must not ship TypeScript sources");
+assert.ok(packed.files.some(file => file.path === "index.js"), "compiled extension entry must ship");
+assert.ok(packed.files.some(file => file.path === "src/inspectors/inspector-runner.js"), "compiled inspector runner must ship");
+assert.ok(packed.files.some(file => file.path === "src/runs/background/subagent-runner-bootstrap.js"), "compiled background bootstrap must ship");
+assert.ok(packed.files.some(file => file.path === "src/runs/background/subagent-runner.js"), "compiled background execution module must ship");
+fs.writeFileSync(path.join(extension, "package.json"), JSON.stringify({ private: true, dependencies: { "pi-subagents": `file:${path.join(root, packed.filename)}` } }));
+run("extension-install", "npm", ["install", "--no-audit", "--no-fund"], extension);
+const installed = path.join(extension, "node_modules/pi-subagents");
+const inspectorRun = path.join(root, "inspector-run");
+fs.mkdirSync(inspectorRun);
+fs.writeFileSync(path.join(inspectorRun, "status.json"), JSON.stringify({
+	runId: "smoke-inspector", mode: "single", state: "completed", startedAt: Date.now(), cwd,
+	steps: [{ agent: "worker", status: "completed", recentOutput: ["done"] }],
+}));
+const inspector = run("inspector", process.execPath, [
+	path.join(installed, "inspector-runner.mjs"), "--async-dir", inspectorRun, "--run-id", "smoke-inspector",
+], cwd);
+assert.match(inspector.stdout, /pi-subagents inspector for smoke-inspector/);
+const pi = path.join(host, "node_modules/@selesai/code");
+const { createJiti } = await import(pathToFileURL(path.join(extension, "node_modules/jiti/lib/jiti.mjs")).href);
+const { resolveHostPeerAliases, findHostPeerPackageDir, resolvePackageSubpath } = await import(pathToFileURL(path.join(installed, "src/runs/background/runner-aliases.js")).href);
+assert.equal(findHostPeerPackageDir(pi, "@earendil-works/pi-client"), undefined, "stable host must remain missing client");
+run("pristine-public-sdk", process.execPath, ["--input-type=module", "-e", `await import(${JSON.stringify(pathToFileURL(resolvePackageSubpath(pi, ".")).href)})`], cwd);
+const resolved = resolveHostPeerAliases(pi);
+assert.deepEqual(resolved.missing, []);
+const tui = findHostPeerPackageDir(pi, "@earendil-works/pi-tui");
+assert.ok(tui.startsWith(host + path.sep), "TUI must come from the host install");
+assert.equal(resolved.aliases["@earendil-works/pi-tui"], resolvePackageSubpath(tui, "."));
+for (const specifier of ["@earendil-works/chord", "@earendil-works/chord/context"]) {
+	assert.ok(resolved.aliases[specifier]);
+}
+assert.equal(resolved.aliases["@earendil-works/pi-client/unix"], undefined);
+fs.writeFileSync(path.join(root, "aliases.json"), JSON.stringify(resolved, null, 2));
+// Pi serves its own packages to extensions as virtual modules; the fixture stands in with jiti aliases to the host install.
+delete process.env.SELESAI_SUBAGENT_CHILD;
+const entryLoader = createJiti(import.meta.url, {
+	moduleCache: false,
+	tryNative: false,
+	alias: { "@selesai/code": resolvePackageSubpath(pi, "."), ...resolved.aliases },
+});
+const entryStarted = performance.now();
+const entry = await entryLoader.import(path.join(installed, "index.js"));
+assert.equal(typeof entry.default, "function", "compiled extension entry must export its factory");
+console.log(`PASS compiled package entry loaded through Jiti in ${Math.round(performance.now() - entryStarted)} ms`);
+for (const file of ["sdk-child.ts", "sdk-extension.ts"]) fs.copyFileSync(new URL(file, import.meta.url), path.join(cwd, file));
+const childEnv = {
+	SMOKE_EXTENSION: installed,
+	JITI_ALIAS: JSON.stringify(resolved.aliases),
+	PI_ASYNC_NATIVE_RUNNER: "1",
+};
+const jiti = path.join(extension, "node_modules/jiti/lib/jiti-cli.mjs");
+const args = [jiti, path.join(cwd, "sdk-child.ts")];
+const preload = Object.keys(resolved.aliases).length ? ["--import", pathToFileURL(path.join(installed, "runner-peer-preload.mjs")).href] : [];
+const positive = run("child", process.execPath, [...preload, ...args], cwd, childEnv);
+assert.match(positive.stdout, /PASS public SDK\/default child factory/);
+const packedSelection = run("packed-selection", process.execPath, [
+	path.join(source, "test/smoke/packed-runner-selection.mjs"),
+	installed,
+	resolvePackageSubpath(pi, "."),
+], cwd, childEnv);
+assert.match(packedSelection.stdout, /PASS packed node_modules selects compiled JavaScript/);
+assert.equal(findHostPeerPackageDir(pi, "@earendil-works/pi-client"), undefined);
+console.log(`${positive.stdout.trim()}\nArtifacts: ${root}`);

package/dist/extensions/pi-subagents/test/smoke/npm-background.mjs

@@ -0,0 +1,43 @@
+// Real npm CLI -> public subagent tool -> detached Node runner -> SDK session.
+// Reuse clean-install.mjs provisioning; no installs during this check.
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+if (process.platform !== "linux" || process.arch !== "x64") {
+	console.log(`SKIP npm background smoke: requires Linux x64/bubblewrap; ${process.platform}/${process.arch} not validated.`);
+	process.exit(0);
+}
+
+const npmRoot = process.argv[2];
+const root = process.argv[3];
+assert.ok(npmRoot && path.isAbsolute(npmRoot));
+assert.ok(root && path.isAbsolute(root) && !fs.existsSync(root), "fresh artifact root required");
+const installed = path.join(npmRoot, "extension/node_modules/pi-subagents");
+const sdk = "host/node_modules/@selesai/code";
+const version = JSON.parse(fs.readFileSync(path.join(npmRoot, sdk, "package.json"), "utf8")).version;
+assert.equal(version, "0.86.1");
+for (const name of ["", "tmp", "home", "agent", "work/.selesai/agents"]) fs.mkdirSync(path.join(root, name), { recursive: true });
+fs.cpSync(installed, path.join(root, "package"), { recursive: true });
+fs.mkdirSync(path.join(root, "package/test/smoke"), { recursive: true });
+for (const name of ["standalone-parent.ts", "standalone-provider.ts", "standalone-observer.ts", "standalone-revival.ts", "standalone-shared.ts"]) fs.copyFileSync(new URL(name, import.meta.url), path.join(root, "package/test/smoke", name));
+fs.copyFileSync(process.execPath, path.join(root, "node"));
+fs.writeFileSync(path.join(root, "agent/settings.json"), JSON.stringify({ defaultProvider: "standalone-smoke", defaultModel: "local", packages: [] }));
+fs.writeFileSync(path.join(root, "work/.selesai/agents/binary-smoke.md"), "---\nname: binary-smoke\ndescription: Real npm background launch\nmodel: standalone-smoke/local\ntools:\nextensions:\n  - /stage/package/test/smoke/standalone-observer.ts\n  - /stage/package/test/smoke/standalone-provider.ts\n---\nReturn the scripted response.\n");
+const aliases = JSON.parse(fs.readFileSync(path.join(npmRoot, "aliases.json"), "utf8")).aliases;
+const mapped = Object.fromEntries(Object.entries(aliases).map(([key, value]) => [key, value.replaceAll(npmRoot, "/npm-fixture")]));
+const args = ["--die-with-parent", "--unshare-net", "--unshare-pid", "--ro-bind", "/usr", "/usr", "--symlink", "usr/bin", "/bin"];
+for (const lib of ["/lib", "/lib64", "/etc/ld.so.cache"]) if (fs.existsSync(lib)) args.push("--ro-bind", lib, lib);
+args.push("--proc", "/proc", "--dev", "/dev", "--bind", root, "/stage", "--bind", path.join(root, "tmp"), "/tmp", "--ro-bind", npmRoot, "/npm-fixture", "--ro-bind", path.join(npmRoot, "extension/node_modules"), "/stage/node_modules", "--chdir", "/stage/work", "--clearenv");
+for (const [key, value] of Object.entries({ PATH: "/stage:/usr/bin:/bin", HOME: "/stage/home", SELESAI_CODING_AGENT_DIR: "/stage/agent", PI_OFFLINE: "1", JITI_FS_CACHE: "false", JITI_ALIAS: JSON.stringify(mapped), TERM: "dumb", PI_STANDALONE_SMOKE_MODE: "single" })) args.push("--setenv", key, value);
+args.push("--", "/stage/node", "--import", "/stage/package/runner-peer-preload.mjs", `/npm-fixture/${sdk}/dist/cli.js`, "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session", "--mode", "rpc", "--extension", "/stage/package/test/smoke/standalone-provider.ts", "--extension", "/stage/package/test/smoke/standalone-parent.ts");
+const result = spawnSync("bwrap", args, { encoding: "utf8", timeout: 90000, maxBuffer: 10 * 1024 * 1024 });
+fs.writeFileSync(path.join(root, "parent.log"), `${result.stdout ?? ""}${result.stderr ?? ""}`);
+assert.ifError(result.error);
+assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+assert.match(result.stdout + result.stderr, /PASS standalone native async/);
+const lifecycle = fs.readFileSync(path.join(root, "lifecycle.jsonl"), "utf8").trim().split("\n").map(JSON.parse);
+assert.ok(lifecycle.filter((event) => event.event === "start").every((event) => event.executable === "/stage/node"));
+fs.writeFileSync(path.join(root, "npm-launch.json"), JSON.stringify({ version, runtime: "Node", publicLaunch: true, network: "unshared" }, null, 2));
+console.log(`PASS npm ${version}: real public background launch, SDK identity, notification and observed runner exit; ${root}`);

package/dist/extensions/pi-subagents/test/smoke/packed-runner-selection.mjs

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import * as nodeModule from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { mock } from "node:test";
+
+const installed = process.argv[2];
+const piEntry = process.argv[3];
+assert.ok(installed && path.isAbsolute(installed));
+assert.ok(piEntry && path.isAbsolute(piEntry));
+assert.match(installed, /[/\\]node_modules[/\\]/);
+process.argv[1] = piEntry;
+const require = nodeModule.createRequire(path.join(installed, "package.json"));
+const jitiPackage = require.resolve("jiti/package.json");
+const { createJiti } = await import(pathToFileURL(path.join(path.dirname(jitiPackage), "lib/jiti.mjs")).href);
+const jiti = createJiti(import.meta.url, { fsCache: false });
+const { executeAsyncSingle } = await jiti.import(path.join(installed, "src/runs/background/async-execution.js"));
+const spawn = mock.method(childProcess, "spawn", () => { throw new Error("packed spawn captured"); });
+nodeModule.syncBuiltinESMExports();
+const result = executeAsyncSingle("packed-selection", {
+	agent: "worker",
+	task: "Inspect packed launch",
+	agentConfig: {
+		name: "worker", description: "packed selector", systemPrompt: "", systemPromptMode: "replace",
+		inheritGlobalContext: false, inheritProjectContext: false, inheritSkills: false,
+	},
+	ctx: { pi: { events: { emit() {} } }, cwd: process.cwd(), currentSessionId: "packed-selector" },
+	artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+	shareEnabled: false,
+	maxSubagentDepth: 1,
+	acceptance: false,
+});
+assert.equal(result.isError, true);
+assert.match(result.content[0].text, /packed spawn captured/);
+assert.equal(spawn.mock.callCount(), 1);
+const [, args, options] = spawn.mock.calls[0].arguments;
+assert.match(args.at(-2), /[/\\]subagent-runner-bootstrap\.js$/);
+assert.doesNotMatch(args.join(" "), /jiti-cli\.mjs/);
+assert.equal(args.includes("--experimental-strip-types"), false);
+assert.equal(options.env.PI_ASYNC_NATIVE_RUNNER, "1");
+console.log("PASS packed node_modules selects compiled JavaScript");

package/dist/extensions/pi-subagents/test/smoke/runner-loader-capability.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import * as nodeModule from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const expected = process.argv[2];
+assert.ok(expected === "jiti" || expected === "native", "expected jiti or native");
+const nativeCapability = Boolean(process.features.typescript) && typeof nodeModule.registerHooks === "function";
+assert.equal(nativeCapability, expected === "native");
+
+const source = fileURLToPath(new URL("../../", import.meta.url));
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "runner-loader-capability-"));
+try {
+	const aliasTarget = path.join(root, "host-tui.mjs");
+	fs.writeFileSync(aliasTarget, 'export const identity = "HOST_TUI_IDENTITY";\n');
+	fs.writeFileSync(path.join(root, "dep.ts"), 'export const value: string = "TS_REDIRECT";\n');
+	fs.writeFileSync(path.join(root, "target.ts"), [
+		'import { identity } from "@earendil-works/pi-tui";',
+		expected === "native" ? 'import { value } from "./dep.js";' : 'const value = "JITI";',
+		`if (identity !== "HOST_TUI_IDENTITY" || value !== ${JSON.stringify(expected === "native" ? "TS_REDIRECT" : "JITI")}) throw new Error("wrong loader identity");`,
+		`console.log(${JSON.stringify(`PASS_${expected.toUpperCase()}_LOADER`)})`,
+	].join("\n"));
+	const env = {
+		...process.env,
+		JITI_ALIAS: JSON.stringify({ "@earendil-works/pi-tui": aliasTarget }),
+		PI_ASYNC_NATIVE_RUNNER: expected === "native" ? "1" : "0",
+	};
+	const preload = pathToFileURL(path.join(source, "runner-peer-preload.mjs")).href;
+	const args = expected === "native"
+		? ["--import", preload, "--experimental-strip-types", path.join(root, "target.ts")]
+		: ["--import", preload, path.join(source, "node_modules/jiti/lib/jiti-cli.mjs"), path.join(root, "target.ts")];
+	const result = spawnSync(process.execPath, args, { cwd: root, env, encoding: "utf8" });
+	assert.ifError(result.error);
+	assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+	assert.match(result.stdout, new RegExp(`PASS_${expected.toUpperCase()}_LOADER`));
+
+	if (typeof nodeModule.registerHooks !== "function") {
+		const eager = path.join(root, "eager-register-hooks.mjs");
+		fs.writeFileSync(eager, 'import { registerHooks } from "node:module"; registerHooks({});\n');
+		const oldResult = spawnSync(process.execPath, ["--import", pathToFileURL(eager).href, "--eval", 'console.log("UNREACHABLE")'], { encoding: "utf8" });
+		assert.notEqual(oldResult.status, 0);
+		assert.doesNotMatch(oldResult.stdout, /UNREACHABLE/);
+		assert.match(oldResult.stderr, /does not provide an export named 'registerHooks'/);
+	}
+} finally {
+	fs.rmSync(root, { recursive: true, force: true });
+}

package/dist/extensions/pi-subagents/test/smoke/sdk-child.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { pathToFileURL } from "node:url";
+import { AgentSession } from "@selesai/code";
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core";
+import { createModels } from "@earendil-works/pi-ai";
+
+const state = globalThis.__sdkSmoke = { AgentSession, BACKGROUND_CONTEXT, createModels, started: 0, stopped: 0, faux: undefined };
+// Exercise the runner's reachable watchdog graph, including its runtime TUI import.
+await import(pathToFileURL(`${process.env.SMOKE_EXTENSION}/src/watchdog/tool-actions.js`).href);
+const { loadRunnerChildSessionFactory } = await import(pathToFileURL(`${process.env.SMOKE_EXTENSION}/src/runs/background/runner-child-sessions.js`).href);
+const factory = await loadRunnerChildSessionFactory({});
+const errors = [];
+let started = 0, stopped = 0;
+try {
+	const child = await factory.create({
+		cwd: process.cwd(), storage: { kind: "memory" }, model: "sdk-smoke/local", tools: [],
+		extensionPaths: [`${process.cwd()}/sdk-extension.ts`], ambientExtensions: false,
+		noSkills: true, noContextFiles: true, runtime: {},
+		hooks: [{ name: "lifecycle", factory(pi) {
+			pi.on("session_start", () => { started++; });
+			pi.on("session_shutdown", () => { stopped++; });
+		} }], onExtensionError(error) { errors.push(error); },
+	});
+	try {
+		assert.equal(child.modelId, "sdk-smoke/local");
+		await child.prompt("Return the local scripted response.");
+		assert.equal(state.faux.state.callCount, 1);
+		assert.ok(child.messages.some(m => m.role === "assistant" && m.content.some(c => c.type === "text" && c.text === "local response verified")));
+	} finally { await child.dispose(); }
+	assert.deepEqual([started, stopped, state.started, state.stopped], [1, 1, 1, 1]);
+	assert.deepEqual(errors, []);
+	console.log("PASS public SDK/default child factory: local prompt, API identity, startup/shutdown");
+	const { buildInProcessChildLaunch } = await import(pathToFileURL(`${process.env.SMOKE_EXTENSION}/src/runs/shared/child-launch.js`).href);
+	for (const tools of [
+		["read", "subagent", "contact_supervisor", "subagent_supervisor"],
+		["read", "subagent", "contact_supervisor"],
+		["read", "contact_supervisor"],
+	]) {
+		const launch = buildInProcessChildLaunch({
+			host: "runner", cwd: process.cwd(), childAgentName: "coordinator-smoke", childIndex: 0,
+			sessionEnabled: false, model: "sdk-smoke/local", tools,
+			runId: `coordination-${tools.length}`, parentSessionId: "root-A", orchestratorIntercomTarget: "root-A",
+			extensions: [`${process.cwd()}/sdk-extension.ts`],
+			inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+		});
+		let snapshot;
+		launch.session.hooks.push({ name: "coordination-tools", factory(pi) {
+			pi.on("session_start", () => { snapshot = { registered: pi.getAllTools().map(tool => tool.name), active: pi.getActiveTools() }; });
+		} });
+		const coordinated = await factory.create(launch.session);
+		try {
+			assert.deepEqual(new Set(snapshot.registered), new Set(tools));
+			assert.deepEqual(new Set(snapshot.active), new Set(tools));
+		} finally { await coordinated.dispose(); }
+	}
+	console.log("PASS native coordinator/leaf tools: real SDK registration and explicit allowlists");
+} finally { await factory.dispose(); }

package/dist/extensions/pi-subagents/test/smoke/{pi085-extension.ts → sdk-extension.ts}

@@ -4,11 +4,11 @@ import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core";
 import { createModels, fauxProvider, fauxAssistantMessage } from "@earendil-works/pi-ai";
 
 export default function(pi) {
-	const state = globalThis.__pi085Smoke;
+	const state = globalThis.__sdkSmoke;
 	assert.equal(AgentSession, state.AgentSession);
 	assert.equal(BACKGROUND_CONTEXT, state.BACKGROUND_CONTEXT);
 	assert.equal(createModels, state.createModels);
-	state.faux = fauxProvider({ provider: "pi085-smoke", models: [{ id: "local" }], tokensPerSecond: 100000 });
+	state.faux = fauxProvider({ provider: "sdk-smoke", models: [{ id: "local" }], tokensPerSecond: 100000 });
 	state.faux.setResponses([fauxAssistantMessage("local response verified")]);
 	pi.registerProvider(state.faux.provider);
 	pi.on("session_start", () => { state.started++; });

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

@@ -0,0 +1,140 @@
+// Linux real-binary smoke from xz-dev's PR #2049. No filesystem core SDK or execution network.
+// node test/smoke/standalone-background.mjs /absolute/pi-binary [fresh-artifacts] [mode] [/absolute/prebuilt.tgz]
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+if (process.platform !== "linux" || process.arch !== "x64") {
+	console.log(`SKIP standalone background smoke: requires Linux x64/bubblewrap; ${process.platform}/${process.arch} not validated.`);
+	process.exit(0);
+}
+
+const source = fileURLToPath(new URL("../../", import.meta.url));
+const binary = process.argv[2];
+const mode = process.argv[4] ?? "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", "bootstrap-errors"].includes(mode), "unknown standalone smoke mode");
+assert.ok(binary && path.isAbsolute(binary) && fs.existsSync(binary), "an existing absolute Pi binary path is required on Linux x64");
+const release = JSON.parse(fs.readFileSync(new URL("standalone-release.json", import.meta.url), "utf8"));
+assert.equal(process.platform, release.platform, "requires Linux/bubblewrap");
+assert.equal(process.arch, release.arch);
+assert.equal(createHash("sha256").update(fs.readFileSync(binary)).digest("hex"), release.binarySha256);
+const root = process.argv[3] ? path.resolve(process.argv[3]) : fs.mkdtempSync(path.join(os.tmpdir(), "pi-standalone-smoke-"));
+fs.mkdirSync(root, { recursive: true });
+assert.deepEqual(fs.readdirSync(root), [], "requires an empty artifact directory");
+const coreSdk = /(?:^|\/)(?:@earendil-works\/(?:pi-coding-agent|pi-agent-core|pi-ai|pi-tui)|typebox)(?:\/|$)/;
+function run(name, command, args) {
+	const result = spawnSync(command, args, { cwd: source, encoding: "utf8", timeout: 90_000, maxBuffer: 10 * 1024 * 1024 });
+	fs.writeFileSync(path.join(root, `${name}.log`), `${result.stdout ?? ""}${result.stderr ?? ""}`);
+	assert.ifError(result.error);
+	return result;
+}
+// The matrix packs once and passes the tarball so every mode stages the same candidate.
+const prebuilt = process.argv[5];
+let tarball;
+if (prebuilt) {
+	assert.ok(path.isAbsolute(prebuilt) && fs.existsSync(prebuilt), "the prebuilt package must be an existing absolute path");
+	tarball = { filename: path.basename(prebuilt) };
+	fs.copyFileSync(prebuilt, path.join(root, tarball.filename));
+} else {
+	const built = run("build-package", process.execPath, ["scripts/build-package.mjs"]);
+	assert.equal(built.status, 0, built.stderr);
+	const packed = run("pack", "npm", ["pack", "--ignore-scripts", "--json", "--pack-destination", root, path.join(source, "dist-pkg")]);
+	assert.equal(packed.status, 0, packed.stderr);
+	tarball = JSON.parse(packed.stdout)[0];
+}
+assert.equal(run("extract", "tar", ["-xf", path.join(root, tarball.filename), "-C", root]).status, 0);
+// Copy rather than symlink: ancestor resolution must not escape into the checkout's dev SDK/shim.
+fs.cpSync(path.join(source, "node_modules"), path.join(root, "package/node_modules"), {
+	recursive: true,
+	filter: (entry) => !coreSdk.test(path.relative(source, entry).split(path.sep).join("/")),
+});
+for (const name of ["home", "agent", "work", "tmp", "cache", "bun-cache", "package/test/smoke"]) fs.mkdirSync(path.join(root, name), { recursive: true });
+fs.copyFileSync(binary, path.join(root, "pi-native"));
+for (const name of ["theme", "assets", "export-html", "photon_rs_bg.wasm"]) {
+	const asset = path.join(path.dirname(binary), name);
+	if (fs.existsSync(asset)) fs.cpSync(asset, path.join(root, name), { recursive: true });
+}
+for (const name of ["standalone-parent.ts", "standalone-provider.ts", "standalone-observer.ts", "standalone-fault.ts", "standalone-revival.ts", "standalone-shared.ts"]) fs.copyFileSync(new URL(name, import.meta.url), path.join(root, "package/test/smoke", name));
+fs.writeFileSync(path.join(root, "work/bunfig.toml"), '[install]\nauto = "disable"\n');
+fs.writeFileSync(path.join(root, "work/negative.ts"), 'import "@selesai/code";\n');
+fs.mkdirSync(path.join(root, "work/.selesai/agents"), { recursive: true });
+fs.writeFileSync(path.join(root, "work/.selesai/agents/binary-smoke.md"), `---\nname: binary-smoke\ndescription: Isolated native async regression\nmodel: standalone-smoke/local\ntools: ${mode === "tool-timeout" ? "bash" : ""}\nextensions:\n  - /stage/package/test/smoke/standalone-observer.ts\n  - /stage/package/test/smoke/standalone-provider.ts\n---\nReturn the scripted response.\n`);
+fs.writeFileSync(path.join(root, "agent/settings.json"), JSON.stringify({ defaultProvider: "standalone-smoke", defaultModel: "local", packages: [] }));
+fs.mkdirSync(path.join(root, "agent/extensions"), { recursive: true });
+fs.writeFileSync(path.join(root, "agent/extensions/ambient-sentinel.ts"), 'import fs from "node:fs"; export default function () { fs.writeFileSync("/stage/ambient-loaded", String(process.pid)); }\n');
+const sandbox = ["--die-with-parent", "--unshare-net", "--unshare-pid", "--ro-bind", "/usr", "/usr", "--symlink", "usr/bin", "/bin"];
+for (const lib of ["/lib", "/lib64"]) if (fs.existsSync(lib)) sandbox.push("--ro-bind", lib, lib);
+// glibc may dlopen libgcc_s when a workflow worker exits; expose only the loader cache.
+if (fs.existsSync("/etc/ld.so.cache")) sandbox.push("--ro-bind", "/etc/ld.so.cache", "/etc/ld.so.cache");
+sandbox.push("--proc", "/proc", "--dev", "/dev", "--bind", root, "/stage", "--bind", path.join(root, "tmp"), "/tmp", "--chdir", "/stage/work", "--clearenv");
+for (const [key, value] of Object.entries({ PATH: "/usr/bin:/bin", HOME: "/stage/home", SELESAI_CODING_AGENT_DIR: "/stage/agent", XDG_CACHE_HOME: "/stage/cache", BUN_INSTALL_CACHE_DIR: "/stage/bun-cache", JITI_FS_CACHE: "false", PI_OFFLINE: "1", TERM: "dumb", PI_STANDALONE_SMOKE_MODE: mode })) sandbox.push("--setenv", key, value);
+const negative = run("negative", "bwrap", [...sandbox, "--setenv", "BUN_BE_BUN", "1", "--", "/stage/pi-native", "--no-install", "/stage/work/negative.ts"]);
+assert.notEqual(negative.status, 0, "bare Bun must not resolve a downloaded or installed SDK");
+assert.match(negative.stderr, /Cannot find (?:module|package).*pi-coding-agent/);
+const version = run("version", "bwrap", [...sandbox, "--", "/stage/pi-native", "--version"]);
+assert.equal(version.status, 0, version.stderr);
+fs.writeFileSync(path.join(root, "identity.json"), JSON.stringify({ binary, sha256: release.binarySha256, version: version.stdout.trim(), packed: tarball.filename, network: "unshared", automaticInstall: "disabled; negative control verified" }, null, 2));
+const bootstrap = "/stage/package/src/runs/background/binary-bootstrap.js";
+if (mode === "missing-bootstrap") fs.renameSync(path.join(root, "package/src/runs/background/binary-bootstrap.js"), path.join(root, "withheld-binary-bootstrap.js"));
+const hostArgs = ["/stage/pi-native", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session", "--mode", "rpc"];
+console.log(`Artifacts: ${root}`);
+if (mode === "bootstrap-errors") {
+	const nativeStep = {
+		agent: "binary-smoke", task: "Return the scripted response.", context: "fresh", model: "standalone-smoke/local",
+		tools: [], extensions: ["/stage/package/test/smoke/standalone-provider.ts"],
+		inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+	};
+	const cases = [
+		{ name: "authorization-positive", barrier: true, succeeds: true },
+		{ name: "missing-input", expected: /Missing absolute SELESAI_SUBAGENT_RUNNER_CONFIG/ },
+		{ name: "relative-input", configPath: "relative.json", expected: /Missing absolute SELESAI_SUBAGENT_RUNNER_CONFIG/ },
+		{ name: "missing-file", configPath: "/stage/not-present.json", expected: /ENOENT/ },
+		{ name: "malformed-json", payload: "{", expected: /Subagent binary runner error/ },
+		{ name: "invalid-shape", payload: "{}", expected: /Invalid runner configuration: 'id' must be a non-empty string/ },
+		{ name: "wrong-authorization", barrier: true, expected: /startup control token does not match/ },
+		{ name: "missing-authorization", barrier: true, expected: /waiting for runner startup control 'proceed'/ },
+	];
+	for (const entry of cases) {
+		const asyncDir = `/stage/${entry.name}`;
+		fs.mkdirSync(path.join(root, entry.name));
+		const payload = entry.barrier ? JSON.stringify({
+			id: entry.name, asyncDir, cwd: "/stage/work", resultPath: `${asyncDir}/result.json`, placeholder: "{previous}",
+			sessionId: "bootstrap-fixture-parent", completionOwnerId: "bootstrap-fixture-owner",
+			steps: [nativeStep], launchBarrierToken: "expected-token", timeoutMs: 20000,
+			artifactConfig: { enabled: false }, sessionDir: `${asyncDir}/sessions`,
+		}) : entry.payload;
+		const configPath = payload === undefined ? entry.configPath : `/stage/${entry.name}.json`;
+		if (payload !== undefined) fs.writeFileSync(path.join(root, `${entry.name}.json`), payload, { mode: 0o600 });
+		if (entry.name === "wrong-authorization" || entry.succeeds) fs.writeFileSync(path.join(root, entry.name, "runner-startup-proceed.json"), JSON.stringify({ action: "proceed", token: entry.succeeds ? "expected-token" : "wrong-token" }));
+		const invocation = run(entry.name, "bwrap", [...sandbox, "--setenv", "PI_STANDALONE_CASE", entry.name, ...(configPath ? ["--setenv", "SELESAI_SUBAGENT_RUNNER_CONFIG", configPath] : []), "--", ...hostArgs, "--extension", "/stage/package/test/smoke/standalone-observer.ts", "--extension", bootstrap]);
+		assert.equal(invocation.status, entry.succeeds ? 0 : 1, invocation.stdout + invocation.stderr);
+		const observed = fs.readFileSync(path.join(root, "bootstrap-observer.jsonl"), "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.case === entry.name);
+		assert.deepEqual(observed.map((event) => event.event), ["observer-ready"], "installed observer must never see an outer session start");
+		const lifecycleFile = path.join(root, "lifecycle.jsonl");
+		const events = fs.existsSync(lifecycleFile) ? fs.readFileSync(lifecycleFile, "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.case === entry.name) : [];
+		if (entry.succeeds) {
+			assert.deepEqual(events.map((event) => event.event), ["start", "request", "shutdown"], "the identical authorized task must actually execute and shut down");
+			const result = JSON.parse(fs.readFileSync(path.join(root, entry.name, "result.json"), "utf8"));
+			assert.equal(result.state, "complete");
+			assert.match(JSON.stringify(result), /standalone child response verified/);
+		} else {
+			assert.match(invocation.stderr, entry.expected);
+			assert.deepEqual(events, [], "the observed positive-control task must not start without authorization");
+			if (entry.barrier) assert.equal(JSON.parse(fs.readFileSync(path.join(root, entry.name, "runner-startup.json"), "utf8")).state, "error");
+		}
+		console.log(`PASS standalone native async bootstrap: ${entry.name}`);
+	}
+} else {
+	const faultExtension = ["persistence-failure", "authorization-failure", "revival"].includes(mode) ? ["--extension", "/stage/package/test/smoke/standalone-fault.ts"] : [];
+	const result = run("parent", "bwrap", [...sandbox, "--", ...hostArgs, "--extension", "/stage/package/test/smoke/standalone-provider.ts", ...faultExtension, "--extension", "/stage/package/test/smoke/standalone-parent.ts"]);
+	assert.equal(result.status, 0, result.stdout + result.stderr);
+	assert.match(result.stdout, /PASS standalone native async/);
+	console.log(result.stdout.split("\n").filter((line) => line.startsWith("PASS ")).join("\n"));
+}
+assert.equal(fs.existsSync(path.join(root, "ambient-loaded")), false, "outer bootstrap must not load ambient extensions");
+assert.deepEqual(fs.readdirSync(root, { recursive: true }).filter((entry) => coreSdk.test(entry)), [], "no staged or downloaded filesystem SDK/shim may appear");
+assert.deepEqual(fs.readdirSync(path.join(root, "bun-cache")), [], "the smoke must not populate Bun's install cache");

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

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { mock } from "bun:test";
+import type { ExtensionAPI } from "@selesai/code";
+
+// Bun's named fs binding requires mock.module; fault only atomic rename after real spawn.
+export default function injectStartupFailure(pi: ExtensionAPI) {
+	const mode = process.env.PI_STANDALONE_SMOKE_MODE;
+	if (!["persistence-failure", "authorization-failure", "revival"].includes(mode ?? "")) throw new Error("unsupported startup hook mode");
+	pi.on("session_start", () => {
+		const originalRename = fs.renameSync;
+		let injected = false;
+		const hook: typeof fs.renameSync = (from, to) => {
+			const target = String(to);
+			const asyncDir = path.dirname(target);
+			if (mode === "revival" && /\/runner-startup-(?:ack|confirm|proceed)\.json$/.test(target) && fs.existsSync(path.join(asyncDir, "runner-startup.json"))) {
+				const control = JSON.parse(fs.readFileSync(from, "utf8"));
+				const startup = JSON.parse(fs.readFileSync(path.join(asyncDir, "runner-startup.json"), "utf8"));
+				const events = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line));
+				const record = { runId: path.basename(asyncDir), action: control.action, stateBefore: startup.state, tokenMatches: control.token === startup.token, childStartedBeforeCommit: events.some((event) => event.event === "start" && event.pid === startup.pid) };
+				originalRename(from, to);
+				fs.appendFileSync("/stage/handshake.jsonl", JSON.stringify(record) + "\n");
+				return;
+			}
+			if (mode !== "revival" && !injected && target.includes("/async-subagent-runs/") && target.endsWith(mode === "persistence-failure" ? "/status.json" : "/runner-startup-proceed.json")) {
+				const status = JSON.parse(fs.readFileSync(mode === "persistence-failure" ? from : path.join(asyncDir, "status.json"), "utf8"));
+				if (typeof status.pid === "number") {
+					assert.notEqual(status.pid, process.pid);
+					process.kill(status.pid, 0);
+					injected = true;
+					fs.renameSync = originalRename;
+					fs.writeFileSync("/stage/failure-injected.json", JSON.stringify({ asyncDir, pid: status.pid, target, mode }));
+					throw new Error(`fixture ${mode} after real spawn`);
+				}
+			}
+			return originalRename(from, to);
+		};
+		fs.renameSync = hook;
+		mock.module("node:fs", () => ({ ...fs, default: fs, renameSync: hook }));
+		fs.writeFileSync("/stage/startup-hook-ready.json", JSON.stringify({ mode, pid: process.pid }));
+	});
+}