@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/fork-context.test.ts

@@ -4,7 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { SessionManager } from "@selesai/code";
-import { createForkContextResolver, forkedChildRequiresThinkingOff, resolveSubagentContext } from "../../src/shared/fork-context.ts";
+import { canPreferFork, canPreferForkFromSnapshot, createForkContextResolver, forkedChildRequiresThinkingOff, resolveSubagentContext } from "../../src/shared/fork-context.ts";
 
 function writeMinimalSessionFile(filePath: string, id = "session"): void {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -54,6 +54,41 @@ describe("forkedChildRequiresThinkingOff", () => {
 	});
 });
 
+describe("canPreferFork", () => {
+	it("requires a persisted session file and a current leaf", () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-prefer-fork-"));
+		try {
+			const parentSessionFile = path.join(tempDir, "parent.jsonl");
+			assert.equal(canPreferFork({
+				getSessionFile: () => undefined,
+				getLeafId: () => "leaf-123",
+			}), false);
+			assert.equal(canPreferFork({
+				getSessionFile: () => parentSessionFile,
+				getLeafId: () => "leaf-123",
+			}), false);
+			writeMinimalSessionFile(parentSessionFile, "parent");
+			assert.equal(canPreferFork({
+				getSessionFile: () => parentSessionFile,
+			}), false);
+			assert.equal(canPreferFork({
+				getSessionFile: () => parentSessionFile,
+				getLeafId: () => null,
+			}), false);
+			assert.equal(canPreferFork({
+				getSessionFile: () => parentSessionFile,
+				getLeafId: () => "leaf-123",
+			}), true);
+			assert.equal(canPreferForkFromSnapshot({
+				parentSessionFile,
+				leafId: "leaf-123",
+			}), true);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+});
+
 describe("createForkContextResolver", () => {
 	it("fresh mode never calls createBranchedSession", () => {
 		let calls = 0;
@@ -157,6 +192,51 @@ describe("createForkContextResolver", () => {
 		}
 	});
 
+	it("nests forked sessions under a per-parent directory so pi -c never picks them", () => {
+		// Regression test: fork files used to be created as top-level siblings of
+		// the parent session. Pi's findMostRecentSession (`pi -c`) scans that
+		// directory non-recursively and picks the largest-mtime *.jsonl, so a
+		// still-running forked subagent out-writes the idle parent and the next
+		// `pi -c` resumed the subagent instead of the conversation the user left.
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fork-nested-"));
+		try {
+			const sessionDir = path.join(tempDir, "sessions");
+			const parent = SessionManager.create(tempDir, sessionDir);
+			parent.appendMessage({ role: "user", content: "parent prompt" });
+			parent.appendMessage({ role: "assistant", content: "parent response" });
+			const parentSessionFile = parent.getSessionFile();
+			const leafId = parent.getLeafId();
+
+			assert.ok(parentSessionFile);
+			assert.ok(leafId);
+
+			const resolver = createForkContextResolver({
+				getSessionFile: () => parentSessionFile,
+				getLeafId: () => leafId,
+				getSessionDir: () => sessionDir,
+			}, "fork");
+
+			const childSessionFile = resolver.sessionFileForIndex(0);
+			assert.ok(childSessionFile);
+			assert.equal(fs.existsSync(childSessionFile), true);
+
+			// The fork is nested under <sessionDir>/<parentBase>/forks/, never a
+			// top-level sibling of the parent.
+			assert.equal(
+				path.dirname(childSessionFile),
+				path.join(sessionDir, path.basename(parentSessionFile, ".jsonl"), "forks"),
+			);
+			// Top-level listing — what pi -c sees — still contains only the parent.
+			const topLevel = fs.readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl"));
+			assert.deepEqual(topLevel, [path.basename(parentSessionFile)]);
+			// The official parentSession header still records the tree relationship.
+			const header = JSON.parse(fs.readFileSync(childSessionFile, "utf-8").split("\n")[0]);
+			assert.equal(header.parentSession, parentSessionFile);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
 	it("fails clearly for an unflushed user-only parent", () => {
 		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fork-user-only-"));
 		try {

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

@@ -8,10 +8,10 @@ import { describe, it } from "node:test";
 import { handleHerdrInspectorAction, readHerdrInspectorBinding } from "../../src/inspectors/herdr/actions.ts";
 import { createHerdrClient, detectHerdr, parseHerdrVersion, supportsRawPanes, type HerdrClient } from "../../src/inspectors/herdr/client.ts";
 import { formatInspectorDashboard, submitInspectorControl } from "../../src/inspectors/herdr/inspector-runner.ts";
-import { createProjectPaneManager, handleHerdrProjectPaneAction, readHerdrProjectPaneBinding } from "../../src/inspectors/herdr/project-panes.ts";
+import { createProjectPaneManager, handleHerdrProjectPaneAction, listHerdrProjectPaneRoots, readHerdrProjectPaneBinding, restoreHerdrProjectPaneSnapshots } from "../../src/inspectors/herdr/project-panes.ts";
 import { consumeSteerRequests, consumeStopRequest } from "../../src/runs/background/control-channel.ts";
 import { SELESAI_SUBAGENT_PI_BINARY_ENV } from "../../src/runs/shared/pi-spawn.ts";
-import type { AsyncStatus } from "../../src/shared/types.ts";
+import type { AsyncStatus, SubagentState } from "../../src/shared/types.ts";
 
 function fakeChild(): EventEmitter & { stdout: PassThrough; stderr: PassThrough; kill(): boolean } {
 	const child = new EventEmitter() as EventEmitter & { stdout: PassThrough; stderr: PassThrough; kill(): boolean };
@@ -76,6 +76,7 @@ describe("Herdr inspector", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-inspector-"));
 		try {
 			const { asyncDir } = writeRun(root);
+			const sessionRoot = path.join(root, "sessions");
 			const missionDir = path.join(root, "other-project", ".pi-subagents", "missions");
 			fs.writeFileSync(path.join(asyncDir, "mission.json"), JSON.stringify({
 				schemaVersion: 1,
@@ -99,6 +100,7 @@ describe("Herdr inspector", () => {
 				asyncDirRoot: root,
 				resultsDir: path.join(root, "results"),
 				client,
+				sessionRoots: [sessionRoot],
 				runnerPath: path.join(root, "runner.ts"),
 				now: () => new Date("2026-01-01T00:00:00.000Z"),
 			});
@@ -109,15 +111,91 @@ describe("Herdr inspector", () => {
 			assert.equal(binding?.openedAt, "2026-01-01T00:00:00.000Z");
 			assert.equal(binding?.missionId, "mission-cross-project");
 			assert.equal(binding?.missionPath, path.join(missionDir, "mission-cross-project.json"));
+			assert.equal(binding?.lastFocusedAt, undefined);
+			const splitCall = calls.find((args) => args[0] === "pane" && args[1] === "split");
+			assert.deepEqual(splitCall?.slice(-1), ["--no-focus"]);
 			const runCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p9");
 			assert.ok(runCall);
+			if (process.platform !== "win32") {
+				assert.ok(!/^[']/.test(runCall[3] ?? ""), `pane run command must not open with a quoted executable; Nushell parses it as a string expression: ${runCall[3]}`);
+			}
 			assert.match(runCall[3] ?? "", /--allow-steer.*true.*--allow-stop.*true/);
+			assert.match(runCall[3] ?? "", /--session-roots.*sessions/);
 
 			const closed = await handleHerdrInspectorAction("inspector.close", { dir: asyncDir }, { cwd: root, asyncDirRoot: root, client });
 			assert.equal(closed.isError, undefined, text(closed));
 			assert.match(text(closed), /subagent run was not stopped/);
 			assert.equal(readHerdrInspectorBinding(asyncDir), undefined);
 			assert.ok(calls.some((args) => args.join(" ") === "pane close w1:p9"));
+
+			calls.length = 0;
+			const focusedOpened = await handleHerdrInspectorAction("inspector.open", { id: "run-123", focus: true }, {
+				cwd: root,
+				asyncDirRoot: root,
+				resultsDir: path.join(root, "results"),
+				client,
+				sessionRoots: [sessionRoot],
+				runnerPath: path.join(root, "runner.ts"),
+				now: () => new Date("2026-01-01T00:00:00.000Z"),
+			});
+			assert.equal(focusedOpened.isError, undefined, text(focusedOpened));
+			const focusedSplitCall = calls.find((args) => args[0] === "pane" && args[1] === "split");
+			assert.deepEqual(focusedSplitCall?.slice(-1), ["--focus"]);
+			assert.equal(readHerdrInspectorBinding(asyncDir)?.lastFocusedAt, "2026-01-01T00:00:00.000Z");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("passes live parent-owned custom session roots to standalone inspectors", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-custom-session-"));
+		try {
+			const { asyncDir, status } = writeRun(root);
+			const sessionRoot = path.join(root, "custom-sessions");
+			status.steps![0] = { ...status.steps![0], sessionFile: path.join(sessionRoot, "run-0", "session.jsonl") };
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+			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:p11" } } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const state = {
+				asyncJobs: new Map([["run-123", { asyncId: "run-123", asyncDir, status: "running", sessionRoot }]]),
+				foregroundControls: new Map(),
+				lastForegroundControlId: null,
+				baseCwd: root,
+				currentSessionId: "session-1",
+			} as unknown as SubagentState;
+
+			const opened = await handleHerdrInspectorAction("inspector.open", { id: "run-123" }, {
+				cwd: root,
+				asyncDirRoot: root,
+				client,
+				state,
+				runnerPath: path.join(root, "runner.ts"),
+			});
+			assert.equal(opened.isError, undefined, text(opened));
+			const runCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p11");
+			assert.match(runCall?.[3] ?? "", /--session-roots/);
+			assert.match(runCall?.[3] ?? "", /custom-sessions/);
+
+			state.asyncJobs.clear();
+			fs.rmSync(path.join(asyncDir, "inspectors"), { recursive: true, force: true });
+			calls.length = 0;
+			const reopened = await handleHerdrInspectorAction("inspector.open", { id: "run-123" }, {
+				cwd: root,
+				asyncDirRoot: root,
+				client,
+				state,
+				runnerPath: path.join(root, "runner.ts"),
+			});
+			assert.equal(reopened.isError, undefined, text(reopened));
+			const untrustedRunCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p11");
+			assert.doesNotMatch(untrustedRunCall?.[3] ?? "", /custom-sessions/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -152,7 +230,7 @@ describe("Herdr inspector", () => {
 					schemaVersion: 1,
 					id: "mission-1",
 					title: "Ship inspector",
-					goal: "Inspect safely",
+					goal: { status: "active" },
 					status: "active",
 					createdAt: "2026-01-01T00:00:00.000Z",
 					updatedAt: "2026-01-01T00:00:00.000Z",
@@ -165,7 +243,7 @@ describe("Herdr inspector", () => {
 			assert.match(dashboard, /decision-1: Choose UX/);
 			assert.match(dashboard, /closing it does not stop the run/i);
 
-			assert.match(submitInspectorControl({ asyncDir, runId: "run-123", refreshMs: 1_500 }, "steer keep going"), /queued/);
+			assert.match(submitInspectorControl({ asyncDir, runId: "run-123", refreshMs: 1_500 }, "steer keep going"), /Steering queued for run run-123\. Message: "keep going"/);
 			assert.deepEqual(consumeSteerRequests(asyncDir).map((request) => ({ message: request.message, targetIndex: request.targetIndex, source: request.source })), [
 				{ message: "keep going", targetIndex: 0, source: "herdr-inspector" },
 			]);
@@ -179,12 +257,35 @@ describe("Herdr inspector", () => {
 		}
 	});
 
+	it("renders trusted child session fallback and refuses untrusted roots", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-session-"));
+		try {
+			const { asyncDir, status } = writeRun(root);
+			const sessionRoot = path.join(root, "sessions");
+			const sessionFile = path.join(sessionRoot, "child.jsonl");
+			fs.mkdirSync(sessionRoot, { recursive: true });
+			fs.writeFileSync(sessionFile, `${JSON.stringify({ role: "assistant", content: "session fallback text" })}\n`, "utf-8");
+			status.steps![0] = { ...status.steps![0], recentOutput: [], sessionFile };
+
+			const trusted = formatInspectorDashboard({ status, asyncDir, sessionRoots: [sessionRoot] });
+			assert.match(trusted, /assistant: session fallback text/);
+			assert.doesNotMatch(trusted, /without a trusted root/);
+
+			const untrusted = formatInspectorDashboard({ status, asyncDir });
+			assert.match(untrusted, /without a trusted root/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("opens, reports, and closes a project-owned Herdr pane", async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-project-pane-"));
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi=herdr project pane-"));
 		const previousPiBinary = process.env[SELESAI_SUBAGENT_PI_BINARY_ENV];
 		process.env[SELESAI_SUBAGENT_PI_BINARY_ENV] = path.join(root, "pi-bin");
 		try {
 			const projectRoot = fs.realpathSync(root);
+			const ownerRoot = path.join(root, "owner");
+			fs.mkdirSync(ownerRoot);
 			const calls: string[][] = [];
 			const client: HerdrClient = {
 				run: async <T>(args: string[]) => {
@@ -200,7 +301,7 @@ describe("Herdr inspector", () => {
 			};
 
 			const opened = await handleHerdrProjectPaneAction("project.open", { cwd: root, message: "Own this project mission." }, {
-				cwd: process.cwd(),
+				cwd: ownerRoot,
 				client,
 				now: () => new Date("2026-01-01T00:00:00.000Z"),
 			});
@@ -210,22 +311,46 @@ describe("Herdr inspector", () => {
 			assert.equal(binding?.paneId, "w1:p10");
 			assert.equal(binding?.projectRoot, projectRoot);
 			assert.equal(binding?.startupMessage, "Own this project mission.");
+			assert.deepEqual(listHerdrProjectPaneRoots(ownerRoot), [projectRoot]);
+			const restoredState = { herdrProjectPanes: new Map() } as SubagentState;
+			restoreHerdrProjectPaneSnapshots(restoredState, [...listHerdrProjectPaneRoots(ownerRoot), ownerRoot], Date.parse("2026-01-01T00:00:01.000Z"));
+			const restored = restoredState.herdrProjectPanes?.get(projectRoot);
+			assert.equal(restored?.paneId, "w1:p10");
+			assert.equal(restored?.state, "open");
+			assert.equal(restored?.ownership, "unknown");
+			assert.equal(restored?.agentStatus, "unknown");
 			const splitCall = calls.find((args) => args[0] === "pane" && args[1] === "split");
-			assert.deepEqual(splitCall?.slice(0, 7), ["pane", "split", "--current", "--direction", "right", "--cwd", projectRoot]);
+			assert.deepEqual(splitCall, ["pane", "split", "--current", "--direction", "right", "--cwd", projectRoot, "--no-focus"]);
+			assert.equal(binding?.lastFocusedAt, undefined);
 			const runCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p10");
 			assert.equal(runCall?.[3]?.startsWith("& "), process.platform === "win32");
+			if (process.platform !== "win32") assert.match(runCall?.[3] ?? "", /^sh -c 'exec \"\$0\" \"\$@\"' '/);
 			assert.match(runCall?.[3] ?? "", /pi-bin/);
 			assert.match(runCall?.[3] ?? "", /Own this project mission\./);
 
-			const status = await handleHerdrProjectPaneAction("project.status", { cwd: root }, { cwd: process.cwd(), client });
+			const status = await handleHerdrProjectPaneAction("project.status", { cwd: root }, { cwd: ownerRoot, client });
 			assert.equal(status.isError, undefined, text(status));
 			assert.match(text(status), /project pane w1:p10 is open/);
 
-			const closed = await handleHerdrProjectPaneAction("project.close", { cwd: root }, { cwd: process.cwd(), client });
+			const closed = await handleHerdrProjectPaneAction("project.close", { cwd: root }, { cwd: ownerRoot, client });
 			assert.equal(closed.isError, undefined, text(closed));
 			assert.match(text(closed), /Closed Herdr project pane w1:p10/);
 			assert.equal(readHerdrProjectPaneBinding(root), undefined);
+			assert.deepEqual(listHerdrProjectPaneRoots(ownerRoot), []);
 			assert.ok(calls.some((args) => args.join(" ") === "pane close w1:p10"));
+
+			calls.length = 0;
+			const focused = await handleHerdrProjectPaneAction("project.open", { cwd: root, focus: true }, {
+				cwd: ownerRoot,
+				client,
+				now: () => new Date("2026-01-01T00:00:00.000Z"),
+			});
+			assert.equal(focused.isError, undefined, text(focused));
+			const focusedSplitCall = calls.find((args) => args[0] === "pane" && args[1] === "split");
+			assert.deepEqual(focusedSplitCall, ["pane", "split", "--current", "--direction", "right", "--cwd", projectRoot, "--focus"]);
+			assert.equal(readHerdrProjectPaneBinding(root)?.lastFocusedAt, "2026-01-01T00:00:00.000Z");
+			fs.writeFileSync(path.join(ownerRoot, ".pi-subagents/project-panes/herdr-roots.json"), JSON.stringify({ schemaVersion: 1, kind: "herdr-project-pane-roots", projectRoots: [123] }));
+			assert.throws(() => listHerdrProjectPaneRoots(ownerRoot), /Invalid Herdr project pane root index/);
 		} finally {
 			if (previousPiBinary === undefined) delete process.env[SELESAI_SUBAGENT_PI_BINARY_ENV];
 			else process.env[SELESAI_SUBAGENT_PI_BINARY_ENV] = previousPiBinary;
@@ -298,8 +423,9 @@ describe("Herdr inspector", () => {
 			const legacyBinding = readHerdrProjectPaneBinding(root)!;
 			fs.writeFileSync(path.join(root, ".pi-subagents", "project-panes", "herdr.json"), JSON.stringify({ ...legacyBinding, startupMessage: 42 }));
 			const closed = await handleHerdrProjectPaneAction("project.close", { cwd: root }, { cwd: root, client });
-			assert.equal(closed.isError, undefined, text(closed));
-			assert.equal(readHerdrProjectPaneBinding(root), undefined);
+			assert.equal(closed.isError, true);
+			assert.match(text(closed), /INVALID_PANE_RESPONSE/);
+			assert.equal(readHerdrProjectPaneBinding(root)?.paneId, "w1:p32");
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -319,4 +445,5 @@ describe("Herdr inspector", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
+
 });

package/dist/extensions/pi-subagents/test/unit/herdr-status-bridge.test.ts

@@ -373,13 +373,13 @@ describe("Herdr status bridge", () => {
 
 		assert.deepEqual(busyEvents, [{
 			active: true,
-			label: "⏳ 1 subagent (worker, reviewer)",
+			label: "⏳ 2 subagents (worker, reviewer)",
 		}]);
 		assert.deepEqual(blockedEvents, [{
 			active: true,
 			label: "reviewer needs attention",
 		}]);
-		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker, reviewer)"));
+		assert.ok(commands[0]?.includes("summary=⏳ 2 subagents (worker, reviewer) ⚠"));
 
 		bridge.dispose();
 		await bridge.flush();
@@ -389,6 +389,45 @@ describe("Herdr status bridge", () => {
 		assert.ok(commands.at(-1)?.includes("--clear-state-labels"));
 	});
 
+	it("reports project pane counts and compact title suffixes", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		let paneCount = 1;
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			getProjectPaneCount: () => paneCount,
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: [] });
+
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
+		await bridge.flush();
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "reviewer" });
+		await bridge.flush();
+		events.emit(SUBAGENT_CONTROL_EVENT, {
+			source: "async",
+			noticeText: "worker needs attention",
+			event: { type: "needs_attention", runId: "run-1" },
+		});
+		await bridge.flush();
+		paneCount = 0;
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-2" });
+		await bridge.flush();
+
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker) · 1 pane"));
+		assert.ok(commands[0]?.includes("title-suffix=⏳worker"));
+		assert.ok(commands[1]?.includes("summary=⏳ 2 subagents (worker, reviewer) · 1 pane"));
+		assert.ok(commands[1]?.includes("title-suffix=⏳2"));
+		assert.ok(commands[2]?.includes("title-suffix=⏳2⚠"));
+		assert.ok(commands.at(-1)?.includes("--clear-token"));
+		assert.ok(commands.at(-1)?.includes("title-suffix"));
+
+		bridge.dispose();
+	});
+
 	it("refreshes metadata only while runs are active", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];