@selesai/code 0.13.40 → 0.14.3

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

@@ -0,0 +1,203 @@
+import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import { resolveInstalledPiPackageRoot, resolvePiPackageRoot } from "../../src/runs/shared/pi-spawn.ts";
+import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../src/shared/utils.ts";
+import { makeAgent } from "../support/helpers.ts";
+
+test("detached spawn does not keep an inherited bundled-layout PI_PACKAGE_DIR", async (t) => {
+	const bundled = fs.mkdtempSync(path.join(os.tmpdir(), "bundled-pi-"));
+	const previous = process.env.PI_PACKAGE_DIR;
+	const previousRoot = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	// The launch path consults this variable when argv discovery cannot identify
+	// the host; an ambient value from the outer environment would change the spawn env.
+	delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	process.env.PI_PACKAGE_DIR = bundled;
+	const spawn = t.mock.method(childProcess, "spawn", () => {
+		throw new Error("spawn boundary captured");
+	});
+	syncBuiltinESMExports();
+	try {
+		// Re-evaluate the module's launch-time host detection: the top-level
+		// import already cached a root resolved against the ambient environment.
+		const { executeAsyncSingle: launch } = await import("../../src/runs/background/async-execution.ts?pi-package-dir");
+		const result = launch("spawn-package-dir", {
+			agent: "worker",
+			task: "Inspect package dir",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: bundled, currentSessionId: "spawn-package-dir" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(bundled, "sessions"),
+			maxSubagentDepth: 1,
+			acceptance: false,
+		});
+		assert.match(result.content[0]!.text, /spawn boundary captured/);
+		const npmRoot = resolvePiPackageRoot() ?? resolveInstalledPiPackageRoot();
+		assert.equal(spawn.mock.calls[0]!.arguments[2].env.PI_PACKAGE_DIR, npmRoot);
+		assert.notEqual(npmRoot, bundled);
+	} finally {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		if (previous === undefined) delete process.env.PI_PACKAGE_DIR;
+		else process.env.PI_PACKAGE_DIR = previous;
+		if (previousRoot === undefined) delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		else process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = previousRoot;
+		fs.rmSync(bundled, { recursive: true, force: true });
+	}
+});
+
+test("detached launch honors the package-root environment override when host detection cannot identify the package", async (t) => {
+	const detected = [resolvePiPackageRoot(), resolveInstalledPiPackageRoot()].filter((dir): dir is string => Boolean(dir));
+	assert.ok(detected.length > 0, "fixture must start with a detectable host root");
+	const manifests = detected.map((dir) => path.join(dir, "package.json"));
+	// A real, complete host root: the override must carry it through the
+	// launch while the same mock reproduces the closed failure without it.
+	const override = detected[0]!;
+	const exists = fs.existsSync;
+	t.mock.method(fs, "existsSync", (file) => manifests.includes(String(file)) ? false : exists(file));
+	const previous = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = override;
+	const spawn = t.mock.method(childProcess, "spawn", () => {
+		throw new Error("spawn boundary captured");
+	});
+	syncBuiltinESMExports();
+	try {
+		// Re-evaluate the module's launch-time host detection with auto-discovery hidden.
+		const { executeAsyncSingle: launch } = await import("../../src/runs/background/async-execution.ts?env-package-root");
+		const result = launch("env-package-root", {
+			agent: "worker", task: "Inspect files", agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: override, currentSessionId: "env-package-root" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false, sessionRoot: path.join(override, "sessions"), maxSubagentDepth: 1, acceptance: false,
+		});
+		assert.match(result.content[0]!.text, /spawn boundary captured/);
+		assert.equal(spawn.mock.calls[0]!.arguments[2].env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV], override);
+	} finally {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		if (previous === undefined) delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		else process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = previous;
+	}
+});
+
+test("detached launch ignores a whitespace-only package-root override", async (t) => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "blank-package-root-"));
+	const previous = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = "   ";
+	const manifests = [resolvePiPackageRoot(), resolveInstalledPiPackageRoot()]
+		.filter((dir): dir is string => Boolean(dir)).map((dir) => path.join(dir, "package.json"));
+	assert.ok(manifests.length > 0, "fixture must start with a detectable npm root");
+	const exists = fs.existsSync;
+	t.mock.method(fs, "existsSync", (file) => manifests.includes(String(file)) ? false : exists(file));
+	const spawn = t.mock.method(childProcess, "spawn", () => { throw new Error("must not spawn"); });
+	syncBuiltinESMExports();
+	try {
+		// With auto-discovery hidden, a blank override must not count as a host root.
+		const { executeAsyncSingle: launch } = await import("../../src/runs/background/async-execution.ts?blank-package-root");
+		const result = launch("blank-package-root", {
+			agent: "worker", task: "Inspect files", agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: root, currentSessionId: "blank-package-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.equal(result.isError, true);
+		assert.match(result.content[0]!.text, /installed npm package.*neither is available/);
+		assert.equal(spawn.mock.calls.length, 0);
+	} finally {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		if (previous === undefined) delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		else process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = previous;
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});
+
+test("npm detached launch fails closed when the detected package root is absent", async (t) => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "missing-npm-root-"));
+	const previous = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	// An ambient override would satisfy host detection and defeat the fixture.
+	delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	const manifests = [resolvePiPackageRoot(), resolveInstalledPiPackageRoot()]
+		.filter((dir): dir is string => Boolean(dir)).map((dir) => path.join(dir, "package.json"));
+	assert.ok(manifests.length > 0, "fixture must start with a detectable npm root");
+	const exists = fs.existsSync;
+	t.mock.method(fs, "existsSync", (file) => manifests.includes(String(file)) ? false : exists(file));
+	const spawn = t.mock.method(childProcess, "spawn", () => { throw new Error("must not spawn"); });
+	syncBuiltinESMExports();
+	try {
+		// Re-evaluate the module's launch-time host detection with the package withheld.
+		const { executeAsyncSingle: launch } = await import("../../src/runs/background/async-execution.ts?missing-npm-root");
+		const result = launch("missing-npm-root", {
+			agent: "worker", task: "Inspect files", agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: root, currentSessionId: "missing-npm-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.equal(result.isError, true);
+		assert.match(result.content[0]!.text, /installed npm package.*neither is available/);
+		assert.equal(spawn.mock.callCount(), 0);
+	} finally {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		if (previous === undefined) delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		else process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = previous;
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});
+
+test("detached spawn drops inherited Git repository routing variables and keeps other environment", async (t) => {
+	const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "git-env-spawn-"));
+	const inherited = {
+		GIT_DIR: "/outer/repo/.git",
+		GIT_WORK_TREE: "/outer/repo",
+		GIT_INDEX_FILE: "/outer/repo/.git/index",
+		GIT_COMMON_DIR: "/outer/repo/.git",
+		GIT_CONFIG_COUNT: "1",
+		GIT_CONFIG_KEY_0: "core.hooksPath",
+		GIT_CONFIG_VALUE_0: "/outer/hooks",
+		GIT_CONFIG_PARAMETERS: "'core.bare'='true'",
+		GIT_AUTHOR_NAME: "Kept Author",
+		GIT_ENV_SENTINEL_KEEP: "kept",
+	};
+	const previous = Object.fromEntries(Object.keys(inherited).map((key) => [key, process.env[key]]));
+	Object.assign(process.env, inherited);
+	const spawn = t.mock.method(childProcess, "spawn", () => {
+		throw new Error("spawn boundary captured");
+	});
+	syncBuiltinESMExports();
+	try {
+		const { executeAsyncSingle: launch } = await import("../../src/runs/background/async-execution.ts");
+		const result = launch("spawn-git-env", {
+			agent: "worker",
+			task: "Inspect git env",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd, currentSessionId: "spawn-git-env" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(cwd, "sessions"),
+			maxSubagentDepth: 1,
+			acceptance: false,
+		});
+		assert.match(result.content[0]!.text, /spawn boundary captured/);
+		const env = spawn.mock.calls[0]!.arguments[2].env;
+		for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR", "GIT_CONFIG_COUNT", "GIT_CONFIG_KEY_0", "GIT_CONFIG_VALUE_0", "GIT_CONFIG_PARAMETERS"]) {
+			assert.equal(env[key], undefined, key);
+		}
+		assert.equal(env.GIT_AUTHOR_NAME, "Kept Author");
+		assert.equal(env.GIT_ENV_SENTINEL_KEEP, "kept");
+		assert.ok(env.PI_PACKAGE_DIR, "launch-owned variables are still set");
+	} finally {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		for (const [key, value] of Object.entries(previous)) {
+			if (value === undefined) delete process.env[key];
+			else process.env[key] = value;
+		}
+		fs.rmSync(cwd, { recursive: true, force: true });
+	}
+});

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

@@ -1,17 +1,16 @@
 import assert from "node:assert/strict";
 import childProcess from "node:child_process";
 import * as fs from "node:fs";
-import { syncBuiltinESMExports } from "node:module";
+import * as nodeModule from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../src/shared/utils.ts";
 
-test("executeAsyncSingle preloads supplemental server aliases before jiti, but not for complete hosts", async (t) => {
+test("executeAsyncSingle preloads all peer aliases before the selected runner loader when aliases exist", async (t) => {
 	const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "async-spawn-preload-")));
 	const host = path.join(root, "host");
-	const server = "@earendil-works/pi-server";
 	const expectedAliases: Record<string, string> = {};
 	const hostExports: Record<string, string[]> = {
 		"@selesai/code": ["."],
@@ -20,8 +19,6 @@ test("executeAsyncSingle preloads supplemental server aliases before jiti, but n
 		"@earendil-works/pi-tui": ["."],
 		"@earendil-works/pi-ai": ["./compat", "./oauth", "./providers/all"],
 		"typebox": [".", "./compile", "./value"],
-		[server]: [".", "./unix"],
-		"@earendil-works/pi-client": ["./unix"],
 	};
 	// Use real package manifests/targets, as in host-peer-runtime-imports.test.ts.
 	function writeHostPackage(pkg: string) {
@@ -34,7 +31,7 @@ test("executeAsyncSingle preloads supplemental server aliases before jiti, but n
 			if (pkg === "@earendil-works/pi-ai" && subpath === "./compat") expectedAliases[pkg] = path.join(dir, target);
 			return [subpath, target];
 		}));
-		fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: pkg, version: "0.85.0", exports }));
+		fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: pkg, version: "0.85.1", exports }));
 	}
 	const originalArgv1 = process.argv[1];
 	const inheritedGitEnv = {
@@ -50,12 +47,7 @@ test("executeAsyncSingle preloads supplemental server aliases before jiti, but n
 	const previousGitEnv = Object.fromEntries(Object.keys(inheritedGitEnv).map((key) => [key, process.env[key]]));
 	try {
 		Object.assign(process.env, inheritedGitEnv);
-		for (const pkg of Object.keys(hostExports)) {
-			if (pkg !== server) writeHostPackage(pkg);
-		}
-		for (const specifier of [server, `${server}/unix`]) {
-			expectedAliases[specifier] = fileURLToPath(import.meta.resolve(specifier));
-		}
+		for (const pkg of Object.keys(hostExports)) writeHostPackage(pkg);
 		// Production discovers the host from the Pi entrypoint at module load.
 		process.argv[1] = expectedAliases["@selesai/code"];
 		// helpers -> mock-pi -> child-session -> readonly evidence -> child hooks
@@ -66,29 +58,29 @@ test("executeAsyncSingle preloads supplemental server aliases before jiti, but n
 			// Stop at the only external I/O seam: no fake pid or detached lifecycle.
 			throw new Error("spawn boundary captured");
 		});
-		syncBuiltinESMExports();
-		for (const scenario of ["supplemental", "complete", "stable", "missing-stable"]) {
-			if (scenario === "complete") writeHostPackage(server);
-			if (scenario === "stable") {
-				fs.writeFileSync(path.join(host, "package.json"), JSON.stringify({ name: "@selesai/code", version: "0.85.1", exports: { ".": "./index.mjs" } }));
-				for (const pkg of [server, "@earendil-works/pi-client"]) fs.rmSync(path.join(host, "node_modules", pkg), { recursive: true });
-				for (const specifier of [server, `${server}/unix`, "@earendil-works/pi-client/unix"]) delete expectedAliases[specifier];
+		nodeModule.syncBuiltinESMExports();
+		for (const scenario of ["stable", "pre-chord", "missing-pre-chord"]) {
+			if (scenario === "pre-chord") {
+				fs.writeFileSync(path.join(host, "package.json"), JSON.stringify({ name: "@selesai/code", version: "0.84.3", exports: { ".": "./index.mjs" } }));
+				fs.rmSync(path.join(host, "node_modules", "@earendil-works/chord"), { recursive: true });
+				for (const specifier of ["@earendil-works/chord", "@earendil-works/chord/context"]) delete expectedAliases[specifier];
 			}
-			if (scenario === "missing-stable") fs.unlinkSync(expectedAliases["@earendil-works/pi-agent-core/node"]!);
+			if (scenario === "missing-pre-chord") fs.unlinkSync(expectedAliases["@earendil-works/pi-agent-core/node"]!);
+			const configuredExtension = scenario === "pre-chord" ? fileURLToPath(import.meta.url) : undefined;
 			const result = executeAsyncSingle(`spawn-preload-${scenario}`, {
-				agent: "worker", task: "Inspect launch wiring", agentConfig: makeAgent("worker"),
+				agent: "worker", task: "Inspect launch wiring", agentConfig: makeAgent("worker", configuredExtension ? { extensions: [configuredExtension] } : {}),
 				ctx: { pi: { events: { emit() {} } }, cwd: root, currentSessionId: "spawn-preload-session" },
 				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 (scenario === "missing-stable") {
+			if (scenario === "missing-pre-chord") {
 				assert.match(result.content[0]!.text, /@earendil-works\/pi-agent-core\/node/);
-				assert.equal(spawn.mock.callCount(), 3);
+				assert.equal(spawn.mock.callCount(), 2);
 				continue;
 			}
 			assert.match(result.content[0]!.text, /spawn boundary captured/);
-			assert.equal(spawn.mock.callCount(), scenario === "supplemental" ? 1 : scenario === "complete" ? 2 : 3);
+			assert.equal(spawn.mock.callCount(), scenario === "stable" ? 1 : 2);
 			const [command, args, options] = spawn.mock.calls.at(-1)!.arguments;
 			assert.ok(path.isAbsolute(command));
 			for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_CONFIG_COUNT", "GIT_CONFIG_KEY_0", "GIT_CONFIG_VALUE_0"]) {
@@ -99,20 +91,19 @@ test("executeAsyncSingle preloads supplemental server aliases before jiti, but n
 			assert.equal(options.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV], host);
 			const actualAliases = JSON.parse(options.env.JITI_ALIAS) as Record<string, string>;
 			assert.deepEqual(Object.fromEntries(Object.entries(actualAliases).map(([key, target]) => [key, fs.realpathSync(target)])), expectedAliases);
-			const jitiIndex = scenario === "supplemental" ? 2 : 0;
-			if (scenario !== "supplemental") assert.ok(!args.includes("--import"));
-			else {
-				assert.equal(args[0], "--import");
-				assert.equal(args[1], new URL("../../runner-server-preload.mjs", import.meta.url).href);
-				assert.ok(fs.existsSync(fileURLToPath(args[1])));
-			}
-			assert.match(args[jitiIndex], /[/\\]jiti-cli\.mjs$/);
-			assert.match(args[jitiIndex + 1], /[/\\]subagent-runner\.ts$/);
-			assert.equal(args.length, jitiIndex + 3);
+			assert.equal(args[0], "--import");
+			assert.equal(args[1], new URL("../../runner-peer-preload.mjs", import.meta.url).href);
+			assert.ok(fs.existsSync(fileURLToPath(args[1])));
+			const nativeRunner = Boolean(process.features.typescript) && typeof nodeModule.registerHooks === "function";
+			if (nativeRunner) assert.equal(args[2], "--experimental-strip-types");
+			else assert.match(args[2], /[/\\]jiti-cli\.mjs$/);
+			assert.match(args[3], /[/\\]subagent-runner-bootstrap\.ts$/);
+			assert.equal(args.length, 5);
+			assert.equal(options.env.PI_ASYNC_NATIVE_RUNNER, nativeRunner ? "1" : "0");
 		}
 	} finally {
 		t.mock.restoreAll();
-		syncBuiltinESMExports();
+		nodeModule.syncBuiltinESMExports();
 		for (const [key, value] of Object.entries(previousGitEnv)) {
 			if (value === undefined) delete process.env[key];
 			else process.env[key] = value;

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

@@ -51,6 +51,56 @@ function stagedLaneGraph(statuses: WorkflowNodeStatus[] = stagedLaneKeys.map((_,
 	};
 }
 
+const materializedWorkflow = job({
+	asyncId: "wf-1",
+	status: "running",
+	mode: "workflow",
+	agents: ["reviewer"],
+	startedAt: 1_000,
+	updatedAt: 5_000,
+	steps: [
+		{ workflowKey: "rev-core", label: "rev-core", agent: "reviewer", status: "completed", runId: "child-core", startedAt: 1_500, durationMs: 2_500 },
+		{ workflowKey: "rev-r", label: "rev-r", agent: "reviewer", status: "running", runId: "child-r", startedAt: 1_500 },
+		{ workflowKey: "rev-parity", label: "rev-parity", agent: "reviewer", status: "pending" },
+	],
+});
+
+const materializedRunningChild = job({
+	asyncId: "child-r",
+	status: "running",
+	mode: "single",
+	parentWorkflowRunId: "wf-1",
+	workflowKey: "rev-r",
+	agents: ["reviewer"],
+	startedAt: 1_700,
+	updatedAt: 4_900,
+	currentTool: "read",
+	toolCount: 3,
+	turnCount: 1,
+	steps: [{ agent: "reviewer", status: "running" }],
+});
+
+const unmatchedChild = job({
+	asyncId: "child-extra",
+	status: "running",
+	mode: "single",
+	parentWorkflowRunId: "wf-1",
+	agents: ["helper"],
+	startedAt: 2_000,
+	steps: [{ agent: "helper", status: "running" }],
+});
+
+const orphanedChild = job({
+	asyncId: "child-orphan",
+	status: "running",
+	mode: "single",
+	parentWorkflowRunId: "wf-gone",
+	workflowKey: "lane",
+	agents: ["scout"],
+	startedAt: 3_000,
+	steps: [{ agent: "scout", status: "running" }],
+});
+
 describe("async status projection", () => {
 	it("projects already-loaded jobs in deterministic newest-first order", () => {
 		const snapshot = projectAsyncStatusSnapshot([
@@ -257,4 +307,139 @@ describe("async status projection", () => {
 			{ name: "writer · Second (worker)", state: "running" },
 		]);
 	});
+
+	it("projects a materialized workflow child once, as its lane, with the child's live facts", () => {
+		const snapshot = projectAsyncStatusSnapshot([materializedWorkflow, materializedRunningChild], { generatedAt: 5_000 });
+
+		assert.deepEqual(snapshot.runs.map((run) => run.id), ["wf-1"]);
+		assert.deepEqual(snapshot.runs[0]?.children?.map(({ id, kind, label, state }) => ({ id, kind, label, state })), [
+			{ id: "rev-core", kind: "step", label: "rev-core", state: "complete" },
+			{ id: "rev-r", kind: "step", label: "rev-r", state: "running" },
+			{ id: "rev-parity", kind: "step", label: "rev-parity", state: "queued" },
+		]);
+		const running = snapshot.runs[0]?.children?.[1];
+		assert.equal(running?.startedAt, 1_700);
+		assert.deepEqual(running?.activity, { currentTool: "read", toolCount: 3, turnCount: 1 });
+		assert.equal(running?.children, undefined);
+		assert.deepEqual(snapshot.omitted, { runs: 0, children: 0, byteLimitExceeded: false });
+	});
+
+	it("keeps children matching no lane under their parent and orphaned children at the root", () => {
+		const snapshot = projectAsyncStatusSnapshot([materializedWorkflow, materializedRunningChild, unmatchedChild, orphanedChild], { generatedAt: 5_000 });
+
+		assert.deepEqual(snapshot.runs.map((run) => run.id), ["wf-1", "child-orphan"]);
+		assert.deepEqual(snapshot.runs[0]?.children?.map(({ id, kind, label }) => ({ id, kind, label })), [
+			{ id: "rev-core", kind: "step", label: "rev-core" },
+			{ id: "rev-r", kind: "step", label: "rev-r" },
+			{ id: "rev-parity", kind: "step", label: "rev-parity" },
+			{ id: "child-extra", kind: "subagent", label: "helper" },
+		]);
+		assert.deepEqual(snapshot.runs[1]?.children?.map(({ kind, label }) => ({ kind, label })), [{ kind: "step", label: "scout" }]);
+	});
+
+	it("counts a lane and its materialized child once when the depth cap hides them", () => {
+		const snapshot = projectAsyncStatusSnapshot([materializedWorkflow, materializedRunningChild, unmatchedChild], { generatedAt: 5_000, maxDepth: 0 });
+
+		assert.equal(snapshot.runs[0]?.children, undefined);
+		assert.equal(snapshot.omitted.children, 4);
+	});
+
+	it("assigns a materialized child once and gives its exact run id precedence over a reused lane key", () => {
+		const parent = job({
+			asyncId: "duplicate-keys",
+			status: "running",
+			mode: "workflow",
+			steps: [
+				{ agent: "worker", workflowKey: "same", runId: "old", label: "first", status: "completed" },
+				{ agent: "worker", workflowKey: "same", runId: "live", label: "second", status: "running" },
+			],
+		});
+		const child = job({ asyncId: "live", parentWorkflowRunId: parent.asyncId, workflowKey: "same", status: "running", updatedAt: 30 });
+
+		const snapshot = projectAsyncStatusSnapshot([parent, child]);
+		assert.deepEqual(snapshot.runs[0]?.children?.map(({ label, state, updatedAt }) => ({ label, state, updatedAt })), [
+			{ label: "first", state: "complete", updatedAt: undefined },
+			{ label: "second", state: "running", updatedAt: 30 },
+		]);
+		assert.equal(projectAsyncStatusSnapshot([parent, child], { maxDepth: 0 }).omitted.children, 2);
+	});
+
+	it("keeps live children visible as roots when their workflow parent is not running", () => {
+		const parent = job({
+			asyncId: "paused-parent",
+			status: "paused",
+			mode: "workflow",
+			updatedAt: 200,
+			steps: [{ agent: "worker", workflowKey: "lane", runId: "live-child", status: "paused" }],
+			nestedChildren: [{ id: "live-child", state: "running", agent: "worker" }],
+		});
+		const child = job({
+			asyncId: "live-child",
+			parentWorkflowRunId: parent.asyncId,
+			workflowKey: "lane",
+			status: "running",
+			updatedAt: 100,
+			steps: [{ agent: "worker", status: "running" }],
+		});
+
+		const snapshot = projectAsyncStatusSnapshot([parent, child]);
+		assert.deepEqual(snapshot.runs.map(({ id, state }) => ({ id, state })), [
+			{ id: "live-child", state: "running" },
+			{ id: "paused-parent", state: "paused" },
+		]);
+		assert.deepEqual(snapshot.runs[0]?.children?.map((step) => step.id), ["step:0"]);
+		assert.equal(snapshot.runs[1]?.children, undefined);
+		assert.deepEqual(snapshot.omitted, { runs: 0, children: 0, byteLimitExceeded: false });
+
+		const depthCapped = projectAsyncStatusSnapshot([parent, child], { maxDepth: 0 });
+		assert.deepEqual(depthCapped.omitted, { runs: 0, children: 1, byteLimitExceeded: false });
+
+		const capped = projectAsyncStatusSnapshot([parent, child], { maxRuns: 1 });
+		assert.deepEqual(capped.runs.map((run) => run.id), ["live-child"]);
+		assert.deepEqual(capped.omitted, { runs: 1, children: 0, byteLimitExceeded: false });
+
+		const queued = projectAsyncStatusSnapshot([job({ ...parent, status: "complete" }), job({ ...child, status: "queued" })]);
+		assert.deepEqual(queued.runs.map((run) => run.id), ["live-child", "paused-parent"]);
+		assert.equal(queued.runs[1]?.children, undefined);
+		assert.deepEqual(queued.omitted, { runs: 0, children: 0, byteLimitExceeded: false });
+	});
+
+	it("keeps cyclic workflow parent links visible as roots", () => {
+		const first = job({ asyncId: "cycle-a", status: "complete", mode: "workflow", parentWorkflowRunId: "cycle-b" });
+		const second = job({ asyncId: "cycle-b", status: "complete", mode: "workflow", parentWorkflowRunId: "cycle-a" });
+
+		const snapshot = projectAsyncStatusSnapshot([first, second]);
+		assert.deepEqual(snapshot.runs.map((run) => run.id), ["cycle-a", "cycle-b"]);
+		assert.deepEqual(snapshot.omitted, { runs: 0, children: 0, byteLimitExceeded: false });
+	});
+
+	it("orders unmatched materialized children deterministically before applying child caps", () => {
+		const parent = job({ asyncId: "ordered-parent", status: "running", mode: "workflow" });
+		const first = job({ asyncId: "child-a", parentWorkflowRunId: parent.asyncId, status: "complete", updatedAt: 10 });
+		const second = job({ asyncId: "child-b", parentWorkflowRunId: parent.asyncId, status: "complete", updatedAt: 20 });
+		const options = { maxChildrenPerNode: 1 };
+
+		const forward = projectAsyncStatusSnapshot([parent, first, second], options);
+		const reversed = projectAsyncStatusSnapshot([parent, second, first], options);
+		assert.deepEqual(forward.runs[0]?.children?.map((child) => child.id), ["child-b"]);
+		assert.deepEqual(reversed.runs[0]?.children?.map((child) => child.id), ["child-b"]);
+		assert.equal(forward.omitted.children, 1);
+	});
+
+	it("derives safe end times only for terminal steps", () => {
+		const snapshot = projectAsyncStatusSnapshot([job({
+			asyncId: "step-times",
+			status: "running",
+			steps: [
+				{ agent: "finished", status: "completed", startedAt: 1_500, durationMs: 2_500 },
+				{ agent: "active", status: "running", startedAt: 1_500, durationMs: 2_500 },
+				{ agent: "overflow", status: "completed", startedAt: Number.MAX_SAFE_INTEGER, durationMs: Number.MAX_SAFE_INTEGER },
+			],
+		})], { generatedAt: 9_000 });
+
+		const [finished, active, overflow] = snapshot.runs[0]?.children ?? [];
+		assert.deepEqual({ endedAt: finished?.endedAt, updatedAt: finished?.updatedAt }, { endedAt: 4_000, updatedAt: 4_000 });
+		assert.deepEqual({ endedAt: active?.endedAt, updatedAt: active?.updatedAt }, { endedAt: undefined, updatedAt: 1_500 });
+		assert.deepEqual({ endedAt: overflow?.endedAt, updatedAt: overflow?.updatedAt }, { endedAt: undefined, updatedAt: Number.MAX_SAFE_INTEGER });
+	});
 });

package/dist/extensions/pi-subagents/test/unit/authority-policy.test.ts

@@ -12,6 +12,14 @@ describe("authority policy", () => {
 		assert.equal(resolveAuthorityDecision({ action: "steerRun" }), "auto");
 	});
 
+	it("confirms project panes that spawn an unchecked host and leaves plugin-gated inspectors automatic", () => {
+		assert.equal(resolveAuthorityDecision({ action: "inspectorOpen" }), "auto");
+		assert.equal(resolveAuthorityDecision({ action: "projectOpen" }), "confirm");
+		const policy = validateAuthorityPolicy({ inspectorOpen: "forbid", projectOpen: "auto" });
+		assert.equal(resolveAuthorityDecision({ action: "inspectorOpen", policy }), "forbid");
+		assert.equal(resolveAuthorityDecision({ action: "projectOpen", policy }), "auto");
+	});
+
 	it("accepts only fixed actions and decisions", () => {
 		const policy = validateAuthorityPolicy({ discardWorktree: "forbid", stopRun: "confirm" });
 		assert.equal(resolveAuthorityDecision({ action: "discardWorktree", policy }), "forbid");
@@ -19,4 +27,4 @@ describe("authority policy", () => {
 		assert.throws(() => validateAuthorityPolicy({ mergePullRequest: "auto" }), /unknown/);
 		assert.throws(() => validateAuthorityPolicy({ discardWorktree: "sometimes" }), /auto.*confirm.*forbid/);
 	});
-});
+});