@selesai/code 0.8.5 → 0.8.7

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

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { visibleWidth, type MarkdownTheme } from "@earendil-works/pi-tui";
+import { EXTERNAL_RUN_REGISTRY_KEY, EXTERNAL_RUN_REGISTRY_VERSION, registerExternalRun } from "../../src/api/external-runs.ts";
 import { collectFleetSnapshot, openSubagentFleet, SubagentFleetComponent } from "../../src/tui/fleet.ts";
 import { persistForegroundRunHistory, restoreForegroundRunHistory } from "../../src/runs/foreground/foreground-history.ts";
 import { FLEET_STATUS_WIDGET_KEY } from "../../src/tui/fleet-status.ts";
@@ -13,6 +14,10 @@ import type { SubagentState } from "../../src/shared/types.ts";
 import { fauxAssistantMessage } from "@earendil-works/pi-ai/providers/faux";
 import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 
+function clearExternalRuns(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)];
+}
+
 function stateForTest(): SubagentState {
 	return {
 		baseCwd: process.cwd(),
@@ -168,6 +173,138 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("shows cached external jobs as display-only without reading paths or invoking controls", async () => {
+		clearExternalRuns();
+		registerExternalRun({
+			id: "external-review",
+			sessionId: "session-current",
+			source: "interactive-shell",
+			label: "Dependency review",
+			state: "completed",
+			startedAt: 100,
+			updatedAt: 200,
+			currentAction: "Inspecting package metadata",
+			preview: "No dependency blockers found.",
+			reportPath: "/outside/trusted/roots/report.md",
+			transcriptPath: "/outside/trusted/roots/transcript.jsonl",
+		});
+		const state = stateForTest();
+		const snapshot = collectFleetSnapshot(state);
+		assert.equal(snapshot.error, undefined);
+		assert.deepEqual(snapshot.items.map((item) => ({ key: item.key, kind: item.kind, agent: item.agent })), [{
+			key: "external:external-review",
+			kind: "external",
+			agent: "Dependency review",
+		}]);
+		let steerCalls = 0;
+		let stopCalls = 0;
+		let inspectCalls = 0;
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 32, columns: 120 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{
+				refreshMs: 60_000,
+				markdownTheme,
+				actions: {
+					async steer() { steerCalls++; return { text: "unexpected" }; },
+					stop() { stopCalls++; return { text: "unexpected" }; },
+					async inspect() { inspectCalls++; return { text: "unexpected" }; },
+				},
+			},
+		);
+		try {
+			const initial = component.render(120).join("\n");
+			assert.match(initial, /Fleet inspector.*external display-only/);
+			assert.match(initial, /Source: external · display-only/);
+			assert.match(initial, /Owner: interactive-shell/);
+			assert.match(initial, /Inspecting package metadata/);
+			assert.match(initial, /Elapsed: 100ms/);
+			assert.match(initial, /No dependency blockers found/);
+			assert.match(initial, /Report path: \/outside\/trusted\/roots\/report\.md/);
+			assert.match(initial, /Transcript path: \/outside\/trusted\/roots\/transcript\.jsonl/);
+			assert.doesNotMatch(initial, /Herdr ·|steer ·|stop ·/);
+			component.handleInput("H");
+			assert.match(component.render(120).join("\n"), /display-only and have no Herdr controls/);
+			component.handleInput("s");
+			assert.match(component.render(120).join("\n"), /display-only and remain controlled/);
+			component.handleInput("D");
+			assert.match(component.render(120).join("\n"), /display-only and remain controlled/);
+			await new Promise((resolve) => setImmediate(resolve));
+			assert.deepEqual({ steerCalls, stopCalls, inspectCalls }, { steerCalls: 0, stopCalls: 0, inspectCalls: 0 });
+		} finally {
+			component.dispose();
+			clearExternalRuns();
+		}
+	});
+
+	it("keeps running external elapsed time live when endedAt is present", () => {
+		clearExternalRuns();
+		try {
+			const startedAt = Date.now() - 5_000;
+			registerExternalRun({
+				id: "external-running",
+				sessionId: "session-current",
+				source: "interactive-shell",
+				label: "Running external job",
+				state: "running",
+				startedAt,
+				updatedAt: startedAt + 100,
+				endedAt: startedAt + 100,
+			});
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 120 }, requestRender() {} } as never,
+				theme as never,
+				stateForTest(),
+				() => {},
+				{ refreshMs: 60_000, markdownTheme },
+			);
+			try {
+				const rendered = component.render(120).join("\n");
+				assert.match(rendered, /Elapsed: 5\.0s/);
+				assert.doesNotMatch(rendered, /Elapsed: 100ms/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			clearExternalRuns();
+		}
+	});
+
+	it("ignores malformed cached external jobs while rendering Fleet", () => {
+		clearExternalRuns();
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (message?: unknown) => warnings.push(String(message));
+		(globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)] = {
+			version: EXTERNAL_RUN_REGISTRY_VERSION,
+			runs: new Map<string, unknown>([[
+				"session-current\0bad",
+				{ id: "bad", sessionId: "session-current", source: "tool", label: "Bad external", state: "running", startedAt: Number.NaN },
+			]]),
+		};
+		const state = stateForTest();
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 60_000, markdownTheme },
+		);
+		try {
+			const snapshot = collectFleetSnapshot(state);
+			assert.equal(snapshot.error, undefined);
+			assert.deepEqual(snapshot.items, []);
+			assert.match(warnings[0]!, /Removed Malformed cached external run/);
+			assert.match(component.render(100).join("\n"), /No current-session Fleet jobs/);
+		} finally {
+			console.warn = originalWarn;
+			component.dispose();
+			clearExternalRuns();
+		}
+	});
+
 	it("shows live prompt summaries and opens Prompt Audit with the authored prompt visible", async () => {
 		const sentinel = "PROMPT_AUDIT_SENTINEL_1021";
 		const secondSentinel = "PROMPT_AUDIT_SECOND_CHILD";
@@ -367,16 +504,26 @@ describe("native subagent fleet", () => {
 		assert.equal(snapshot.items[0]?.agent, "workflow");
 	});
 
-	it("labels workflow-owned foreground children and opens their parent Herdr inspector", async () => {
+	it("hides workflow-owned foreground duplicates and opens the workflow parent inspector", async () => {
 		const state = stateForTest();
 		state.asyncJobs.set("workflow-1", {
 			asyncId: "workflow-1",
 			asyncDir: "/tmp/workflow-1",
+			sessionId: "session-current",
 			status: "running",
 			mode: "workflow",
 			startedAt: 10,
 			updatedAt: 20,
 		});
+		state.asyncJobs.set("unrelated", {
+			asyncId: "unrelated",
+			asyncDir: "/tmp/unrelated",
+			sessionId: "session-current",
+			status: "running",
+			mode: "single",
+			startedAt: 5,
+			updatedAt: 30,
+		});
 		state.foregroundControls.set("child-1", {
 			runId: "child-1",
 			parentWorkflowRunId: "workflow-1",
@@ -387,8 +534,7 @@ describe("native subagent fleet", () => {
 			activeChildren: new Map([[0, { index: 0, agent: "reviewer", startedAt: 10, updatedAt: 20 }]]),
 		});
 		const snapshot = collectFleetSnapshot(state);
-		const child = snapshot.items.find((item) => item.key === "foreground-active:child-1:0");
-		assert.equal(child?.kind, "foreground-active");
+		assert.deepEqual(snapshot.items.map((item) => item.key), ["async:unrelated", "async:workflow-1"]);
 		const calls: Array<{ runId: string; asyncDir: string; index?: number }> = [];
 		const component = new SubagentFleetComponent(
 			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
@@ -406,7 +552,7 @@ describe("native subagent fleet", () => {
 			},
 		);
 		try {
-			assert.ok(component.render(100).some((line) => line.includes("Workflow child of: workflow-1 (review)")));
+			assert.ok(component.render(100).some((line) => line.includes("workflow")));
 			component.handleInput("H");
 			await new Promise((resolve) => setImmediate(resolve));
 			assert.deepEqual(calls, [{ runId: "workflow-1", asyncDir: "/tmp/workflow-1" }]);
@@ -536,6 +682,7 @@ describe("native subagent fleet", () => {
 			fs.writeFileSync(outputPath, "restored foreground output", "utf-8");
 
 			const state = stateForTest();
+			state.artifactDirPreference = "project";
 			state.foregroundRuns!.set("restored", {
 				runId: "restored",
 				mode: "single",
@@ -556,6 +703,7 @@ describe("native subagent fleet", () => {
 
 			const restored = stateForTest();
 			restored.baseCwd = cwd;
+			restored.artifactDirPreference = "project";
 			assert.equal(restoreForegroundRunHistory(restored, { resultsDir }), 1);
 			const snapshot = collectFleetSnapshot(restored);
 			assert.deepEqual(snapshot.items.map((item) => item.key), ["foreground-recent:restored:0"]);
@@ -636,6 +784,7 @@ describe("native subagent fleet", () => {
 			const cwd = path.join(root, "project");
 			const artifactsRoot = getProjectArtifactsDir(cwd);
 			const state = stateForTest();
+			state.artifactDirPreference = "project";
 			for (let index = 0; index < 3; index++) {
 				const outputPath = path.join(artifactsRoot, "outputs", `run-${index}`, "output.md");
 				fs.mkdirSync(path.dirname(outputPath), { recursive: true });
@@ -654,6 +803,7 @@ describe("native subagent fleet", () => {
 
 			const restored = stateForTest();
 			restored.baseCwd = cwd;
+			restored.artifactDirPreference = "project";
 			assert.equal(restoreForegroundRunHistory(restored, { resultsDir, limit: 2 }), 2);
 			assert.deepEqual([...restored.foregroundRuns!.keys()], ["run-2", "run-1"]);
 
@@ -802,6 +952,7 @@ describe("native subagent fleet", () => {
 			fs.writeFileSync(path.join(asyncDir, "status.json"), "{in-flight status", "utf-8");
 			const state = stateForTest();
 			state.baseCwd = path.join(root, "parent-cwd");
+			state.artifactDirPreference = "project";
 			state.asyncJobs.set("async-custom-cwd", {
 				asyncId: "async-custom-cwd",
 				asyncDir,
@@ -883,6 +1034,7 @@ describe("native subagent fleet", () => {
 		try {
 			const state = stateForTest();
 			state.baseCwd = path.join(root, "parent-cwd");
+			state.artifactDirPreference = "project";
 			const effectiveCwd = path.join(root, "effective-cwd");
 			const now = Date.now();
 			state.foregroundControls.set("foreground-live", {
@@ -1282,6 +1434,40 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("periodically redraws only while the overlay remains open", (t) => {
+		t.mock.timers.enable({ apis: ["setTimeout"] });
+		const state = stateForTest();
+		let renderRequests = 0;
+		let closed = false;
+		const tui = { terminal: { rows: 28, columns: 90 }, requestRender: () => { renderRequests++; } };
+		const component = new SubagentFleetComponent(
+			tui as never,
+			theme as never,
+			state,
+			() => { closed = true; },
+			{ refreshMs: 10 },
+		);
+		t.mock.timers.tick(249);
+		assert.equal(renderRequests, 0, "refresh cadence is bounded away from a hot loop");
+		t.mock.timers.tick(1);
+		assert.equal(renderRequests, 1);
+		component.handleInput("\x1b");
+		assert.equal(closed, true);
+		t.mock.timers.tick(1_000);
+		assert.equal(renderRequests, 1, "closing cancels periodic redraws");
+
+		const disposed = new SubagentFleetComponent(
+			tui as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 250 },
+		);
+		disposed.dispose();
+		t.mock.timers.tick(1_000);
+		assert.equal(renderRequests, 1, "disposing cancels periodic redraws");
+	});
+
 	it("refreshes the roster while the overlay remains open", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-refresh-"));
 		try {
@@ -1293,7 +1479,7 @@ describe("native subagent fleet", () => {
 				theme as never,
 				state,
 				() => {},
-				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 10 },
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 250 },
 			);
 			let invalidations = 0;
 			const originalInvalidate = component.invalidate.bind(component);
@@ -1305,7 +1491,7 @@ describe("native subagent fleet", () => {
 				assert.ok(component.render(90).some((line) => line.includes("No tracked children")));
 				const initialOutput = Array.from({ length: 40 }, (_, index) => `output line ${index}`).join("\n");
 				const asyncDir = writeAsyncRun(root, { id: "appeared-live", output: initialOutput });
-				await new Promise((resolve) => setTimeout(resolve, 35));
+				await new Promise((resolve) => setTimeout(resolve, 275));
 				let lines = component.render(90);
 				assert.ok(lines.some((line) => line.includes("appeared")));
 				assert.ok(lines.some((line) => line.includes("output line 39")));

package/dist/extensions/pi-subagents/test/unit/handoff-adoption.test.ts

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { describe, it } from "node:test";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+describe("handoff workflow carry-over", () => {
+	it("adopts the previous session's active async workflows and tells the agent", () => {
+		const script = String.raw`
+			import os from "node:os";
+			import path from "node:path";
+			import fs from "node:fs";
+			import { DIRS } from "./src/shared/types.ts";
+			import registerSubagentExtension from "./index.ts";
+			const handlers = new Map();
+			const events = { listeners: new Map(), on(name, handler) { this.listeners.set(name, handler); return () => this.listeners.delete(name); }, emit(name, payload) { this.listeners.get(name)?.(payload); } };
+			const sent = [];
+			const widgets = [];
+			const pi = new Proxy({
+				events,
+				on(name, handler) { handlers.set(name, handler); },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage(message, options) { sent.push({ message, options }); }, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+
+			const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-handoff-"));
+			const oldSession = path.join(tmp, "old-session.jsonl");
+			const newSession = path.join(tmp, "new-session.jsonl");
+			fs.writeFileSync(oldSession, JSON.stringify({ type: "session", version: 1, id: "old-session", timestamp: new Date().toISOString(), cwd: process.cwd() }) + "\n");
+			fs.writeFileSync(newSession, JSON.stringify({ type: "session", version: 1, id: "new-session", timestamp: new Date().toISOString(), cwd: process.cwd(), parentSession: oldSession }) + "\n");
+
+			// One active async workflow owned by the previous session.
+			const runId = "adopted-workflow-run";
+			const asyncDir = path.join(DIRS.async, runId);
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId,
+				state: "running",
+				sessionId: oldSession,
+				mode: "workflow",
+				workflowKey: "task",
+				agent: "builder",
+				startedAt: Date.now(),
+				steps: [{ agent: "builder", status: "running", phase: "build-1", description: "Implement the carry-over plan" }],
+			}));
+			fs.mkdirSync(path.join(DIRS.async, ".active-runs"), { recursive: true });
+			fs.writeFileSync(path.join(DIRS.async, ".active-runs", runId), "");
+
+			// A result file for an old-session run written during the switch window.
+			const resultRunId = "adopted-completed-run";
+			const resultPath = path.join(DIRS.results, resultRunId + ".json");
+			fs.mkdirSync(DIRS.results, { recursive: true });
+			fs.writeFileSync(resultPath, JSON.stringify({ runId: resultRunId, sessionId: oldSession, agent: "explorer", summary: "done", success: true }));
+
+			const ctx = { cwd: process.cwd(), hasUI: true, ui: { setWidget(key, value) { widgets.push([key, value]); }, requestRender() {}, onTerminalInput() { return () => {}; }, getEditorText() { return ""; }, notify() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager: { getSessionId() { return "new-session"; }, getSessionFile() { return newSession; }, getHeader() { return { parentSession: oldSession }; }, getEntries() { return []; } }, modelRegistry: { getAvailable() { return []; } } };
+
+			registerSubagentExtension(pi);
+			handlers.get("session_start")({ reason: "new", previousSessionFile: oldSession }, ctx);
+			sent.length = 0;
+
+			// No handoff notice until a turn settles.
+			if (sent.length !== 0) throw new Error("handoff notice sent before the first settled turn");
+
+			handlers.get("agent_settled")();
+			const handoff = sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume");
+			if (handoff.length !== 1) throw new Error(JSON.stringify(sent.map((entry) => entry.message)));
+			if (handoff[0].options?.triggerTurn !== true) throw new Error("handoff notice did not trigger a turn");
+			if (typeof handoff[0].message?.content !== "string" || !handoff[0].message.content.includes(runId) || !handoff[0].message.content.includes("carried over")) {
+				throw new Error("handoff notice lacks the adopted workflow: " + JSON.stringify(handoff[0].message));
+			}
+
+			// Only once per adoption.
+			handlers.get("agent_settled")();
+			if (sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume").length !== 1) throw new Error("handoff notice repeated");
+
+			// Compaction resume message now lists the live workflows.
+			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
+			handlers.get("session_compact")({ reason: "threshold" });
+			const compaction = sent.filter((entry) => entry.message?.customType === "subagent-compaction-resume");
+			if (compaction.length !== 1) throw new Error("compaction resume missing: " + JSON.stringify(sent.map((entry) => entry.message?.customType)));
+			if (typeof compaction[0].message?.content !== "string" || !compaction[0].message.content.includes(runId)) {
+				throw new Error("compaction resume lacks the workflow manifest: " + JSON.stringify(compaction[0].message));
+			}
+
+			// Adopted old-session result gets delivered and cleaned up (batched
+			// notification debounces, so poll with a generous bound).
+			let delivered = false;
+			for (let attempt = 0; attempt < 40 && !delivered; attempt++) {
+				await new Promise((resolve) => setTimeout(resolve, 250));
+				delivered = !fs.existsSync(resultPath);
+			}
+			if (!delivered) throw new Error("adopted result file was not delivered");
+
+			await handlers.get("session_shutdown")();
+		`;
+		const env = { ...process.env };
+		delete env.SELESAI_SUBAGENT_CHILD;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		assert.ok(true);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/herdr-inspector-bootstrap.test.ts

@@ -54,6 +54,38 @@ describe("Herdr inspector bootstrap", () => {
 		}
 	});
 
+	it("uses PATH node when Pi is a standalone executable", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-bootstrap-standalone-"));
+		const originalExecPath = process.execPath;
+		try {
+			writeCompletedRun(root);
+			process.execPath = path.join(root, process.platform === "win32" ? "pi.exe" : "pi");
+			const calls: string[][] = [];
+			const client: HerdrClient = {
+				run: async <T>(args: string[]) => {
+					calls.push(args);
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.7.5" as T };
+					if (args[0] === "pane" && args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p9" } } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const opened = await handleHerdrInspectorAction("inspector.open", { id: "run-123" }, {
+				cwd: root,
+				asyncDirRoot: root,
+				resultsDir: path.join(root, "results"),
+				client,
+			});
+			assert.equal(opened.isError, undefined);
+			const command = calls.find((args) => args[0] === "pane" && args[1] === "run")?.[3] ?? "";
+			assert.equal(command.startsWith("& "), process.platform === "win32");
+			assert.match(command, process.platform === "win32" ? /^& "node\.exe" / : /^node /);
+			assert.doesNotMatch(command, /(?:^|[\\/])pi(?:\.exe)?'/);
+		} finally {
+			process.execPath = originalExecPath;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("starts the packaged bootstrap with ordinary Node", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-bootstrap-run-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/herdr-shell-command.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { formatShellCommand } from "../../src/inspectors/herdr/shell-command.ts";
+
+describe("formatShellCommand on POSIX shells", () => {
+	const platform: NodeJS.Platform = "linux";
+
+	it("keeps a shell-safe executable bare so Nushell parses it as a command", () => {
+		assert.equal(
+			formatShellCommand("/usr/bin/node", ["/home/u/.pi/inspector-runner.mjs", "--async-dir", "/tmp/run-1|fc_abc"], platform),
+			"/usr/bin/node '/home/u/.pi/inspector-runner.mjs' '--async-dir' '/tmp/run-1|fc_abc'",
+		);
+	});
+
+	it("keeps bare command names bare", () => {
+		assert.equal(formatShellCommand("pi", ["review the diff"], platform), "pi 'review the diff'");
+	});
+
+	it("uses a bare sh invoker for an executable containing spaces and equals", () => {
+		assert.equal(
+			formatShellCommand("/opt/My Tools/node=bin", ["--flag"], platform),
+			`sh -c 'exec "$0" "$@"' '/opt/My Tools/node=bin' '--flag'`,
+		);
+	});
+
+	it("quotes executable paths and arguments containing quotes", () => {
+		assert.equal(
+			formatShellCommand("/opt/My Tools/it's node", ["it's", "a|b"], platform),
+			"sh -c 'exec \"$0\" \"$@\"' '/opt/My Tools/it'\\''s node' 'it'\\''s' 'a|b'",
+		);
+	});
+
+	it("executes an equals-sign path through the shell wrapper", { skip: process.platform === "win32" }, () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi herdr shell="));
+		try {
+			const executable = path.join(root, "tool=' value");
+			fs.writeFileSync(executable, "#!/bin/sh\nprintf '%s' \"$1\"\n", "utf-8");
+			fs.chmodSync(executable, 0o755);
+			const launched = spawnSync("/bin/sh", ["-c", formatShellCommand(executable, ["arg=' value"], platform)], { encoding: "utf-8" });
+			assert.equal(launched.status, 0, launched.stderr);
+			assert.equal(launched.stdout, "arg=' value");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("formatShellCommand on Windows PowerShell", () => {
+	it("prefixes the call operator and preserves argument quoting", () => {
+		assert.equal(
+			formatShellCommand("C:\\Program Files\\nodejs\\node.exe", ["two words", 'say "hi"'], "win32"),
+			'& "C:\\Program Files\\nodejs\\node.exe" "two words" "say \\"hi\\""',
+		);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/index-child-registration.test.ts

@@ -103,6 +103,28 @@ describe("subagent extension child mode", () => {
 		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
 	});
 
+	it("declares packaged prompts through resources_discover", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./index.ts";
+			import * as fs from "node:fs";
+			const handlers = new Map();
+			const fakePi = new Proxy({
+				events: { on() { return () => {}; }, emit() {} },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				on(event, handler) { handlers.set(event, handler); },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			registerSubagentExtension(fakePi);
+			const handler = handlers.get("resources_discover");
+			if (!handler) throw new Error("resources_discover handler not registered");
+			const result = handler({ type: "resources_discover", cwd: process.cwd(), reason: "startup" });
+			if (!result || !Array.isArray(result.promptPaths) || result.promptPaths.length !== 1) throw new Error("expected one promptPath, got " + JSON.stringify(result));
+			const promptDir = result.promptPaths[0];
+			if (!fs.existsSync(promptDir + "/review-loop.md")) throw new Error("review-loop.md not found under " + promptDir);
+			if (!fs.existsSync(promptDir + "/parallel-review.md")) throw new Error("parallel-review.md not found under " + promptDir);
+		`;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
+	});
+
 	it("shows omitted workflow async as background even when asyncByDefault is false", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-workflow-manifest-config-"));
 		try {
@@ -346,6 +368,75 @@ describe("subagent extension child mode", () => {
 		}
 	});
 
+	it("uses configured main-window renderer spacing for call rows", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-renderer-density-config-"));
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ mainWindowRenderer: { horizontalSpacing: 0 } }), "utf-8");
+
+			const script = String.raw`
+				import registerSubagentExtension from "./index.ts";
+				const events = { on() { return () => {}; }, emit() {} };
+				let registeredTool;
+				const fakePi = new Proxy({
+					events,
+					registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+					registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				registerSubagentExtension(fakePi);
+				if (!registeredTool) throw new Error("tool not registered");
+				const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
+				const call = registeredTool.renderCall({ agent: "worker", async: true }, theme).render(120).map((line) => line.trimEnd());
+				if (call.length !== 1 || call[0] !== "subagentworker[async]") throw new Error("unexpected call row: " + JSON.stringify(call));
+			`;
+			const env = parentToolEnv();
+			env.SELESAI_CODING_AGENT_DIR = agentDir;
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		} finally {
+			fs.rmSync(agentDir, { recursive: true, force: true });
+		}
+	});
+
+	it("uses configured main-window renderer density for slash results", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-slash-renderer-density-config-"));
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ mainWindowRenderer: { horizontalSpacing: 0, compactResultMaxLines: 3 } }), "utf-8");
+
+			const script = String.raw`
+				import registerSubagentExtension from "./index.ts";
+				const events = { on() { return () => {}; }, emit() {} };
+				let slashRenderer;
+				const fakePi = new Proxy({
+					events,
+					registerTool() {}, registerCommand() {}, registerShortcut() {}, sendMessage() {}, getSessionName() {},
+					registerMessageRenderer(type, renderer) { if (type === "subagent-slash-result") slashRenderer = renderer; },
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				registerSubagentExtension(fakePi);
+				if (!slashRenderer) throw new Error("slash renderer not registered");
+				const result = slashRenderer({ details: {
+					requestId: "slash-density",
+					result: { content: [{ type: "text", text: "done" }], details: { mode: "parallel", results: [
+						{ agent: "scout", task: "a", exitCode: 0, messages: [], usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+						{ agent: "reviewer", task: "b", exitCode: 0, messages: [], usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+						{ agent: "writer", task: "c", exitCode: 0, messages: [], usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+					] } },
+				} }, { expanded: false }, { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } });
+				const lines = result.render(120);
+				if (lines.length !== 6) throw new Error("expected outer spacer, box rows, and three capped result rows: " + JSON.stringify(lines));
+				if (!lines[4].includes("rows hidden")) throw new Error("compact cap was not applied: " + JSON.stringify(lines));
+				if (!lines[3].includes(" ✓ Agent 1/3: scout")) throw new Error("zero spacing was not applied: " + JSON.stringify(lines));
+			`;
+			const env = parentToolEnv();
+			env.SELESAI_CODING_AGENT_DIR = agentDir;
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		} finally {
+			fs.rmSync(agentDir, { recursive: true, force: true });
+		}
+	});
+
 	it("registers only subagent_wait and honors waitTool disabled config", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-wait-tool-config-"));
 		try {