@selesai/code 0.13.0 → 0.13.2

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

@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { executeWorkflowHostCommand, normalizeWorkflowHostCommandParams } from "../../src/workflows/host-command.ts";
+
+const roots: string[] = [];
+
+afterEach(() => {
+	for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function commandFor(root: string, source: string): string {
+	const script = path.join(root, `command-${Math.random().toString(16).slice(2)}.cjs`);
+	fs.writeFileSync(script, source, "utf8");
+	return `${JSON.stringify(process.execPath)} ${JSON.stringify(script)}`;
+}
+
+describe("workflow host commands", () => {
+	it("validates the narrow command shape", () => {
+		assert.deepEqual(normalizeWorkflowHostCommandParams({ kind: "command", command: "npm test", timeoutMs: 1000, output: "reports/test.log", role: "ci", provider: "local" }), {
+			kind: "command",
+			command: "npm test",
+			timeoutMs: 1000,
+			output: "reports/test.log",
+			role: "ci",
+			provider: "local",
+		});
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "http", command: "true", timeoutMs: 1000 }), /kind must be 'command'/);
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true" }), /timeoutMs/);
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, output: "../outside.log" }), /relative path/);
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 86_400_001 }), /integer from 1/);
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, output: path.resolve("outside.log") }), /relative path/);
+		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, provider: "bad\nprovider" }), /single-line/);
+	});
+
+	it("runs without stdin and saves bounded command evidence", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-"));
+		roots.push(root);
+		const outputPath = path.join(root, "reports", "command.log");
+		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+		fs.writeFileSync(outputPath, "stale", "utf8");
+		const result = await executeWorkflowHostCommand({
+			key: "unit-tests",
+			params: { kind: "command", command: commandFor(root, `process.stdout.write("passed\\n"); process.stderr.write("warning\\n");`), timeoutMs: 5000, output: "reports/command.log" },
+			cwd: root,
+			defaultOutputPath: path.join(root, "fallback.log"),
+			signal: new AbortController().signal,
+		});
+		assert.equal(result.ok, true);
+		assert.equal(result.state, "passed");
+		assert.equal(result.exitCode, 0);
+		assert.match(result.stdout, /passed/);
+		assert.match(result.stderr, /warning/);
+		assert.equal(result.outputPath, outputPath);
+		assert.match(fs.readFileSync(outputPath, "utf8"), /passed/);
+		if (process.platform !== "win32") assert.equal(fs.statSync(outputPath).mode & 0o777, 0o600);
+		assert.deepEqual(fs.readdirSync(path.dirname(outputPath)), ["command.log"]);
+	});
+
+	it("returns failed and timed-out command evidence", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-failure-"));
+		roots.push(root);
+		const failed = await executeWorkflowHostCommand({
+			key: "failed",
+			params: { kind: "command", command: commandFor(root, `process.stderr.write("bad\\n"); process.exit(3);`), timeoutMs: 5000 },
+			cwd: root,
+			defaultOutputPath: path.join(root, "failed.log"),
+			signal: new AbortController().signal,
+		});
+		assert.equal(failed.state, "failed");
+		assert.equal(failed.exitCode, 3);
+		assert.match(failed.error ?? "", /code 3/);
+
+		const timedOut = await executeWorkflowHostCommand({
+			key: "timeout",
+			params: { kind: "command", command: commandFor(root, `setTimeout(() => {}, 10000);`), timeoutMs: 20 },
+			cwd: root,
+			defaultOutputPath: path.join(root, "timeout.log"),
+			signal: new AbortController().signal,
+		});
+		assert.equal(timedOut.state, "timed-out");
+		assert.match(timedOut.error ?? "", /timed out/);
+	});
+
+	it("rejects symlinked output parents before creating outside directories", { skip: process.platform === "win32" ? "symlink permissions vary on Windows" : undefined }, async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-symlink-"));
+		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-outside-"));
+		roots.push(root, outside);
+		fs.symlinkSync(outside, path.join(root, "link-out"), "dir");
+
+		await assert.rejects(
+			executeWorkflowHostCommand({
+				key: "symlink-output",
+				params: { kind: "command", command: commandFor(root, `process.stdout.write("unused");`), timeoutMs: 5000, output: "link-out/sub/report.log" },
+				cwd: root,
+				defaultOutputPath: path.join(root, "fallback.log"),
+				signal: new AbortController().signal,
+			}),
+			/resolves outside the workflow cwd/,
+		);
+		assert.equal(fs.existsSync(path.join(outside, "sub")), false);
+	});
+
+	it("rejects an explicit output parent redirected while the command runs", { skip: process.platform === "win32" ? "symlink permissions vary on Windows" : undefined }, async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-symlink-race-"));
+		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-symlink-target-"));
+		roots.push(root, outside);
+		const outputParent = path.join(root, "reports");
+		const outsidePath = path.join(outside, "outside.log");
+		const command = commandFor(root, `
+			const fs = require("node:fs");
+			fs.rmdirSync(${JSON.stringify(outputParent)});
+			fs.symlinkSync(${JSON.stringify(outside)}, ${JSON.stringify(outputParent)}, "dir");
+			process.stdout.write("captured");
+		`);
+
+		await assert.rejects(executeWorkflowHostCommand({
+			key: "replaced-output",
+			params: { kind: "command", command, timeoutMs: 5000, output: "reports/command.log" },
+			cwd: root,
+			defaultOutputPath: path.join(root, "fallback.log"),
+			signal: new AbortController().signal,
+		}), /resolves outside the workflow cwd/);
+		assert.equal(fs.existsSync(outsidePath), false);
+	});
+
+	it("stops the owned process tree when the workflow aborts", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-abort-"));
+		roots.push(root);
+		const readyPath = path.join(root, "ready");
+		const leakedPath = path.join(root, "leaked");
+		const command = commandFor(root, `
+			const { spawn } = require("node:child_process");
+			const fs = require("node:fs");
+			fs.writeFileSync(${JSON.stringify(readyPath)}, "ready");
+			spawn(process.execPath, ["-e", ${JSON.stringify(`setTimeout(() => require("node:fs").writeFileSync(${JSON.stringify(leakedPath)}, "leaked"), 400)}`)}], { stdio: "ignore" });
+			setTimeout(() => {}, 10000);
+		`);
+		const controller = new AbortController();
+		const pending = executeWorkflowHostCommand({
+			key: "abort",
+			params: { kind: "command", command, timeoutMs: 5000 },
+			cwd: root,
+			defaultOutputPath: path.join(root, "abort.log"),
+			signal: controller.signal,
+		});
+		for (let attempt = 0; attempt < 100 && !fs.existsSync(readyPath); attempt += 1) await new Promise((resolve) => setTimeout(resolve, 10));
+		assert.equal(fs.existsSync(readyPath), true);
+		controller.abort();
+		assert.equal((await pending).state, "stopped");
+		await new Promise((resolve) => setTimeout(resolve, 500));
+		assert.equal(fs.existsSync(leakedPath), false);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/host-step-status.test.ts

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AsyncStatus, HostStepNodeV1 } from "../../src/shared/types.ts";
+import {
+	HOST_STEP_MAX_LABEL_CHARS,
+	assertHostStepNode,
+	assertWorkflowGraphHostSteps,
+	hostStepWorkflowNode,
+	parseHostStepNode,
+	assertUniqueHostStepIds,
+	upsertHostStep,
+	validHostStepNodes,
+} from "../../src/runs/shared/host-step-status.ts";
+
+function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
+	return {
+		version: 1,
+		kind: "host-step",
+		monitorKind: "gate",
+		id: "gate-ci",
+		label: "CI and review gate",
+		provider: "github-ci",
+		state: "running",
+		updatedAt: 10,
+		...overrides,
+	};
+}
+
+describe("host step status", () => {
+	it("validates host monitor states and command exit evidence", () => {
+		const running = parseHostStepNode(hostStep({ monitorKind: "ci" }), "fixture");
+		assert.equal(running.monitorKind, "ci");
+		assert.equal(hostStepWorkflowNode(running).status, "running");
+		assert.equal(hostStepWorkflowNode(hostStep({ state: "done", verdict: "pass" })).status, "completed");
+		assert.equal(hostStepWorkflowNode(hostStep({ state: "done", verdict: "inconclusive" })).status, "partial");
+		assert.equal(hostStepWorkflowNode(hostStep({ state: "done" })).status, "partial");
+		assert.equal(hostStepWorkflowNode(hostStep({ state: "done", verdict: "fail" })).status, "failed");
+		assert.equal(hostStepWorkflowNode(hostStep({ state: "cancelled" })).status, "stopped");
+		assert.equal(hostStepWorkflowNode(hostStep({ state: "error" })).status, "failed");
+		assert.equal(parseHostStepNode(hostStep({ monitorKind: "command", state: "done", verdict: "pass", exitCode: 0 })).exitCode, 0);
+	});
+
+	it("rejects unbounded or incomplete terminal data", () => {
+		assert.throws(() => assertHostStepNode(hostStep({ label: "x".repeat(HOST_STEP_MAX_LABEL_CHARS + 1) }), "fixture"), /label exceeds/);
+		assert.throws(() => assertHostStepNode(hostStep({ state: "running", verdict: "pass" }), "fixture"), /verdict is only valid/);
+		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "inconclusive", freshness: {} as HostStepNodeV1["freshness"] }), "fixture"), /expected/);
+		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "pass", freshness: { expectedRef: "head", stale: true } }), "fixture"), /stale freshness/);
+		assert.throws(() => assertHostStepNode(hostStep({ exitCode: 1 }), "fixture"), /only valid for command/);
+		assert.throws(() => assertHostStepNode(hostStep({ monitorKind: "command", exitCode: 1 }), "fixture"), /only valid after command settlement/);
+	});
+
+	it("upserts through the host-owned persistence callback without touching legacy child steps", () => {
+		const status: AsyncStatus = {
+			runId: "workflow-1",
+			mode: "workflow",
+			state: "running",
+			startedAt: 1,
+			steps: [{ agent: "reviewer", workflowKey: "review", runId: "child-1", status: "running" }],
+		};
+		const writes: AsyncStatus[] = [];
+		const next = upsertHostStep({ status, hostStep: hostStep({ state: "done", verdict: "pass", updatedAt: 20 }), persist: (value) => writes.push(value) });
+		assert.equal(writes.length, 1);
+		assert.deepEqual(next.steps, status.steps);
+		assert.equal(next.workflowGraph?.nodes[0]?.kind, "host-step");
+		assert.equal(next.workflowGraph?.nodes[0]?.hostStep?.monitorKind, "gate");
+		assert.equal(next.workflowGraph?.nodes[0]?.status, "completed");
+		assert.equal(next.lastUpdate, 20);
+
+		const replaced = upsertHostStep({ status: next, hostStep: hostStep({ state: "error", updatedAt: 30 }), persist: (value) => writes.push(value) });
+		assert.equal(replaced.workflowGraph?.nodes.length, 1);
+		assert.equal(replaced.workflowGraph?.nodes[0]?.status, "failed");
+		assert.equal(writes.length, 2);
+	});
+
+	it("fails closed for malformed graph nodes while strict loaders can reject them", () => {
+		const graph = {
+			runId: "workflow-1",
+			mode: "workflow" as const,
+			phases: [],
+			nodes: [{ id: "bad", kind: "host-step" as const, label: "bad", status: "running" as const }],
+		};
+		assert.deepEqual(validHostStepNodes(graph), []);
+		assert.throws(() => assertHostStepNode(graph.nodes[0]?.hostStep, "status"), /expected an object/);
+	});
+
+	it("rejects ambiguous host-step identities", () => {
+		const duplicate = hostStep({ id: "duplicate" });
+		assert.throws(() => assertUniqueHostStepIds([duplicate, duplicate], "receipt"), /duplicate host step id/);
+		const graph = {
+			runId: "workflow-1",
+			mode: "workflow" as const,
+			phases: [],
+			nodes: [hostStepWorkflowNode(duplicate), hostStepWorkflowNode(duplicate)],
+		};
+		assert.deepEqual(validHostStepNodes(graph), []);
+		assert.throws(() => assertWorkflowGraphHostSteps(graph, "status", "workflow-1"), /duplicate host step id/);
+	});
+});

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

@@ -20,6 +20,76 @@ function parentToolEnv(agentDir?: string): NodeJS.ProcessEnv {
 }
 
 describe("subagent extension child mode", () => {
+	it("defers persistence when startup config expires a cached exclusion", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-model-exclusion-startup-"));
+		const exclusionPath = path.join(agentDir, "model-exclusions.json");
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ modelExclusions: { defaultTtlMs: 300_000 } }), "utf-8");
+			const recordedAt = Date.now() - 600_000;
+			const originalExpiry = Date.now() + 3_600_000;
+			fs.writeFileSync(exclusionPath, JSON.stringify({
+				version: 1,
+				exclusions: [{ provider: "openai", modelId: "old-model", reason: "503", recordedAt, expiresAt: originalExpiry }],
+			}), "utf-8");
+			const script = String.raw`
+				import registerSubagentExtension from "./index.ts";
+				import { isExcluded } from "./src/runs/shared/model-exclusions.ts";
+				const events = { on() { return () => {}; }, emit() {} };
+				const fakePi = new Proxy({
+					events,
+					registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				registerSubagentExtension(fakePi);
+				if (isExcluded("old-model", "openai")) throw new Error("startup TTL clamp did not expire the cached exclusion in memory");
+			`;
+			const env = parentToolEnv(agentDir);
+			env.PI_MODEL_EXCLUSIONS_PATH = exclusionPath;
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+			const persisted = JSON.parse(fs.readFileSync(exclusionPath, "utf-8")).exclusions[0] as { expiresAt: number };
+			assert.equal(persisted.expiresAt, originalExpiry);
+		} finally {
+			fs.rmSync(agentDir, { recursive: true, force: true });
+		}
+	});
+
+	it("applies model exclusion TTL from extension config at registration", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-model-exclusion-config-"));
+		const exclusionPath = path.join(agentDir, "model-exclusions.json");
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ modelExclusions: { defaultTtlMs: 300_000 } }), "utf-8");
+			const recordedAt = Date.now();
+			fs.writeFileSync(exclusionPath, JSON.stringify({
+				version: 1,
+				exclusions: [{ provider: "openai", modelId: "old-model", reason: "503", recordedAt, expiresAt: recordedAt + 3_600_000 }],
+			}), "utf-8");
+			const script = String.raw`
+				import * as fs from "node:fs";
+				import registerSubagentExtension from "./index.ts";
+				import { recordModelFailure } from "./src/runs/shared/model-exclusions.ts";
+				const events = { on() { return () => {}; }, emit() {} };
+				const fakePi = new Proxy({
+					events,
+					registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				registerSubagentExtension(fakePi);
+				recordModelFailure({ modelId: "gpt-5", provider: "openai", reason: "test" });
+				const entries = JSON.parse(fs.readFileSync(process.env.PI_MODEL_EXCLUSIONS_PATH, "utf-8")).exclusions;
+				for (const entry of entries) {
+					if (entry.expiresAt - entry.recordedAt !== 300_000) throw new Error("configured model exclusion TTL was not applied: " + JSON.stringify(entry));
+				}
+			`;
+			const env = parentToolEnv(agentDir);
+			env.PI_MODEL_EXCLUSIONS_PATH = exclusionPath;
+			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("collapses tool detail before direct subagent tool execution", () => {
 		const script = String.raw`
 			import registerSubagentExtension from "./index.ts";
@@ -565,9 +635,13 @@ describe("subagent extension child mode", () => {
 			const handlers = new Map();
 			const events = { on(channel, handler) { eventHandlers.set(channel, handler); return () => {}; }, emit() {} };
 			const widgets = [];
+			const herdrCommands = [];
+			process.env.HERDR_ENV = "1";
+			process.env.HERDR_PANE_ID = "w1:p1";
 			const fakePi = new Proxy({
 				events,
 				on(channel, handler) { handlers.set(channel, handler); },
+				exec(command, args) { herdrCommands.push({ command, args }); return Promise.resolve({ code: 0, stdout: "", stderr: "", killed: false }); },
 				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
 				sendMessage() {}, getSessionName() { return undefined; },
 			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
@@ -593,6 +667,10 @@ describe("subagent extension child mode", () => {
 			handlers.get("tool_result")({ toolName: "subagent" }, ctx);
 			const fleetWidgets = widgets.filter((entry) => entry.key === "subagent-fleet-status");
 			if (!fleetWidgets.some((entry) => typeof entry.value === "function")) throw new Error("management result did not restore active fleet status: " + JSON.stringify(fleetWidgets));
+			if (!herdrCommands.some(({ args }) => args.includes("summary=⏳ 1 subagent"))) throw new Error("management result did not restore Herdr status: " + JSON.stringify(herdrCommands));
+			const herdrCommandCount = herdrCommands.length;
+			handlers.get("tool_result")({ toolName: "subagent" }, ctx);
+			if (herdrCommands.length !== herdrCommandCount) throw new Error("unchanged active jobs redundantly refreshed Herdr status: " + JSON.stringify(herdrCommands));
 			handlers.get("session_shutdown")();
 			fs.rmSync(asyncDir, { recursive: true, force: true });
 		`;
@@ -925,6 +1003,106 @@ describe("subagent extension child mode", () => {
 		}
 	});
 
+	it("ignores the current stale UI context during runtime reload cleanup", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-stale-ui-reload-"));
+		const configDir = path.join(agentDir, "extensions", "subagent");
+		fs.mkdirSync(configDir, { recursive: true });
+		fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ asyncWidget: false, fleetView: false }), "utf-8");
+		const script = String.raw`
+			import registerSubagentExtension from "./index.ts";
+			const handlers = new Map();
+			const events = { on() { return () => {}; }, emit() {} };
+			const fakePi = new Proxy({
+				events,
+				on(channel, handler) { handlers.set(channel, handler); },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage() {}, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			let stale = false;
+			const ctx = {
+				cwd: process.cwd(),
+				get hasUI() {
+					if (stale) throw new Error("This extension ctx is stale after session replacement or reload.");
+					return true;
+				},
+				ui: {
+					setWidget() {}, requestRender() {}, setToolsExpanded() {}, getToolsExpanded() { return false; },
+					theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } },
+				},
+				sessionManager: { getSessionId() { return "stale-ui-session"; }, getSessionFile() { return null; }, getEntries() { return []; } },
+				modelRegistry: { getAvailable() { return []; } },
+			};
+			registerSubagentExtension(fakePi);
+			handlers.get("session_start")({ reason: "startup" }, ctx);
+			stale = true;
+			handlers.get("session_shutdown")({ reason: "reload" });
+		`;
+
+		try {
+			const env = parentToolEnv(agentDir);
+			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("claims the explicit predecessor session during session replacement", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-session-transition-"));
+		const configDir = path.join(agentDir, "extensions", "subagent");
+		fs.mkdirSync(configDir, { recursive: true });
+		fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ completionBatch: { enabled: false } }), "utf-8");
+		const script = String.raw`
+			import fs from "node:fs";
+			import path from "node:path";
+			import registerSubagentExtension from "./index.ts";
+			import { currentCompletionOwnerId } from "./src/shared/completion-owner.ts";
+			const handlers = new Map();
+			const listeners = new Map();
+			const events = {
+				on(channel, handler) { let set = listeners.get(channel); if (!set) listeners.set(channel, set = new Set()); set.add(handler); return () => set.delete(handler); },
+				emit(channel, payload) { for (const handler of [...(listeners.get(channel) ?? [])]) handler(payload); },
+			};
+			const sent = [];
+			const pi = new Proxy({
+				events,
+				on(channel, handler) { handlers.set(channel, handler); },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage(message) { sent.push(message); }, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			const sessions = path.join(process.env.SELESAI_CODING_AGENT_DIR, "sessions");
+			fs.mkdirSync(sessions, { recursive: true });
+			const oldSession = path.join(sessions, "old.jsonl");
+			const newSession = path.join(sessions, "new.jsonl");
+			fs.writeFileSync(oldSession, "");
+			fs.writeFileSync(newSession, "");
+			let currentSession = oldSession;
+			const sessionManager = { getSessionId() { return path.basename(currentSession); }, getSessionFile() { return currentSession; }, getEntries() { return []; } };
+			const ctx = { cwd: process.cwd(), hasUI: false, ui: { setWidget() {}, requestRender() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager, modelRegistry: { getAvailable() { return []; } } };
+			registerSubagentExtension(pi);
+			handlers.get("session_start")({ reason: "startup" }, ctx);
+			currentSession = newSession;
+			handlers.get("session_start")({ reason: "new", previousSessionFile: oldSession }, ctx);
+			const owner = currentCompletionOwnerId();
+			events.emit("subagent:async-complete", { id: "old-owned", agent: "worker", success: true, summary: "old", timestamp: 1, sessionId: oldSession, completionOwnerId: owner });
+			events.emit("subagent:async-complete", { id: "foreign", agent: "worker", success: true, summary: "foreign", timestamp: 2, sessionId: path.join(sessions, "foreign.jsonl"), completionOwnerId: owner });
+			if (sent.length !== 1) throw new Error("expected only the claimed predecessor completion, got " + sent.length);
+			await handlers.get("session_shutdown")({ reason: "quit" });
+		`;
+
+		try {
+			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 the main watchdog command and renderer in parent mode", () => {
 		const script = String.raw`
 			import registerSubagentExtension from "./index.ts";
@@ -1077,32 +1255,6 @@ describe("subagent extension child mode", () => {
 		);
 	});
 
-	it("omits legacy chain controls from the child-safe fanout tool", () => {
-		const readRegisteredTool = (): { description: string; properties: string[]; id: string; runId: string } => {
-			const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fanout-schema-"));
-			fs.mkdirSync(path.join(agentDir, "extensions", "subagent"), { recursive: true });
-			const script = String.raw`
-				import registerFanoutChildSubagentExtension from "./src/extension/fanout-child.ts";
-				import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "./src/runs/shared/pi-args.ts";
-				process.env[SUBAGENT_CHILD_ENV] = "1";
-				process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
-				let tool;
-				registerFanoutChildSubagentExtension({ events: { on() { return () => {}; }, emit() {} }, registerTool(value) { tool = value; }, getSessionName() { return undefined; } });
-				process.stdout.write(JSON.stringify({ description: tool.description, properties: Object.keys(tool.parameters.properties), id: tool.parameters.properties.id.description, runId: tool.parameters.properties.runId.description }));
-			`;
-			const output = execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], {
-				cwd: projectRoot,
-				env: parentToolEnv(agentDir),
-				encoding: "utf-8",
-			});
-			return JSON.parse(output) as { description: string; properties: string[]; id: string; runId: string };
-		};
-
-		const tool = readRegisteredTool();
-		assert.equal(tool.properties.includes("step"), false);
-		assert.doesNotMatch(`${tool.description}\n${tool.id}\n${tool.runId}`, /append-step|approve-checkpoint|reject-checkpoint/);
-	});
-
 	it("lets fanout children call read-only list but blocks mutating management actions", () => {
 		const script = String.raw`
 			import assert from "node:assert/strict";

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

@@ -21,11 +21,12 @@ describe("bounded index segments", () => {
 		assert.equal(first, encodeIndexSegment(longId));
 		assert.match(first, /^~sha256-[a-f0-9]{64}$/);
 		assert.ok(Buffer.byteLength(first, "utf-8") <= MAX_INDEX_SEGMENT_BYTES);
+		assert.deepEqual(indexSegmentAliases(longId), [first]);
 		assert.notEqual(first, encodeIndexSegment(`${longId}other`));
 	});
 
 	it("hashes Windows session file paths that stay under the byte limit", () => {
-		const sessionId = String.raw`C:\Users\theap\.pi\agent\sessions\--C--Users-theap--\2026-08-17T07-29-51-353Z_01a00ea0-72f9-754f-82ca-2b74ded94746.jsonl`;
+		const sessionId = String.raw`C:\Users\theap\.selesai\agent\sessions\--C--Users-theap--\2026-08-17T07-29-51-353Z_01a00ea0-72f9-754f-82ca-2b74ded94746.jsonl`;
 		assert.ok(Buffer.byteLength(encodeURIComponent(sessionId), "utf-8") <= MAX_INDEX_SEGMENT_BYTES);
 		assert.match(encodeIndexSegment(sessionId), /^~sha256-[a-f0-9]{64}$/);
 		assert.equal(encodeIndexSegment(sessionId), encodeIndexSegment(sessionId));

package/dist/extensions/pi-subagents/test/unit/inspect-rpc.test.ts

@@ -146,6 +146,27 @@ describe("inspect-rpc resolution and ownership", () => {
 });
 
 describe("inspect-rpc reply content", () => {
+	it("reads an exact runtime-recorded session under the Pi sessions base", () => {
+		const sessionsBase = fs.mkdtempSync(path.join(os.tmpdir(), "pi-inspect-recorded-session-"));
+		const root = path.join(sessionsBase, "project");
+		try {
+			fs.mkdirSync(root);
+			const { resultsDir } = makeRun(root, {
+				runId: "run-recorded",
+				sessionMessages: [userMessage("recorded task"), assistantMessage("recorded answer")],
+				resultPayload: { summary: "done", results: [{ agent: "worker", output: "recorded answer", success: true }] },
+			});
+			const state = makeState(path.join(sessionsBase, "unrelated"));
+			state.trustedSessionFileRoot = sessionsBase;
+			const reply = buildInspectReply({ requestId: "r-recorded", asyncId: "run-recorded" }, makeDeps(root, resultsDir, state));
+			assert.equal(reply.error, undefined);
+			assert.equal(reply.task, "recorded task");
+			assert.equal(reply.messages?.at(-1)?.text, "recorded answer");
+		} finally {
+			fs.rmSync(sessionsBase, { recursive: true, force: true });
+		}
+	});
+
 	it("returns task, messages, and final output without leaking paths", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-inspect-full-"));
 		const sessionFile = path.join(root, "run-1-session.jsonl");