@selesai/code 0.5.20 → 0.5.21

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

@@ -51,6 +51,14 @@ describe("buildDoctorReport", () => {
 	it("formats a bounded successful environment summary", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-doctor-success-"));
 		try {
+			const state = makeState(root);
+			state.subagentSpawns = {
+				sessionId: "session-abc123",
+				count: 3,
+				configuredLimit: 4,
+				granted: 1,
+				grantHistory: [{ sessionId: "session-abc123", amount: 1, grantedAt: 0, previousLimit: 4, limit: 5 }],
+			};
 			const paths = {
 				tempRootDir: path.join(root, "temp-root"),
 				asyncDir: path.join(root, "async"),
@@ -61,8 +69,8 @@ describe("buildDoctorReport", () => {
 
 			const report = buildDoctorReport({
 				cwd: root,
-				config: { defaultSessionDir: "~/subagent-sessions", intercomBridge: { mode: "always" } },
-				state: makeState(root),
+				config: { defaultSessionDir: "~/subagent-sessions", intercomBridge: { mode: "always" }, maxSubagentSpawnsPerSession: 4 },
+				state,
 				currentSessionFile: path.join(root, "sessions", "parent.jsonl"),
 				currentSessionId: "session-abc123",
 				orchestratorTarget: "subagent-chat-abc123",
@@ -105,6 +113,9 @@ describe("buildDoctorReport", () => {
 			assert.match(report, /- temp root: ok /);
 			assert.match(report, /- agents: total 4 \(builtin 1, package 0, user 1, project 2\)/);
 			assert.match(report, /- chains: total 2 \(builtin 0, package 0, user 1, project 1\)/);
+			assert.match(report, /Spawn budget\n- usage: 3\/5 used, 2 remaining \(configured 4; granted 1; grant allowance 3\)/);
+			assert.match(report, /- recent grants: \+1 at 1970-01-01T00:00:00\.000Z \(4 → 5\)/);
+			assert.match(report, /new parent session resets usage and grants; compaction does not/);
 			assert.match(report, /- skills: total 2 \(project 1, user-package 1\)/);
 			assert.match(report, /- bridge: active/);
 			assert.match(report, /- supervisor channel: available \(native:pi-subagents-supervisor-channel\)/);

package/dist/extensions/pi-subagents/test/unit/dynamic-fanout.test.ts

@@ -190,7 +190,7 @@ describe("dynamic fanout helpers", () => {
 		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
 	});
 
-	it("collects ordered child result records and validates aggregate schema", () => {
+	it("collects ordered child result records and validates aggregate schema", async () => {
 		const step: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
 			parallel: { agent: "reviewer", task: "Review {item.path}" },
@@ -211,7 +211,7 @@ describe("dynamic fanout helpers", () => {
 		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
 		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
 		assert.equal(collected[1]?.timedOut, true);
-		assert.doesNotThrow(() => validateDynamicCollection({ type: "array", minItems: 2 }, collected));
-		assert.throws(() => validateDynamicCollection({ type: "object" }, collected), DynamicFanoutError);
+		await assert.doesNotReject(validateDynamicCollection({ type: "array", minItems: 2 }, collected));
+		await assert.rejects(validateDynamicCollection({ type: "object" }, collected), DynamicFanoutError);
 	});
 });

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

@@ -0,0 +1,351 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { Editor, visibleWidth } from "@earendil-works/pi-tui";
+import type { ExtensionContext } from "@selesai/code";
+import type { SubagentState } from "../../src/shared/types.ts";
+import { collectFleetSnapshot } from "../../src/tui/fleet.ts";
+import {
+	FLEET_STATUS_WIDGET_KEY,
+	SubagentFleetStatus,
+	collectFleetStatusEntries,
+	formatFleetElapsed,
+	formatFleetTokens,
+} from "../../src/tui/fleet-status.ts";
+
+function stateForTest(): SubagentState {
+	return {
+		baseCwd: process.cwd(),
+		currentSessionId: "session-current",
+		asyncJobs: new Map(),
+		fleetJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+const theme = {
+	fg: (_name: string, text: string) => text,
+	bg: (_name: string, text: string) => text,
+	bold: (text: string) => text,
+};
+
+describe("below-editor subagent FleetView", () => {
+	it("formats elapsed time and token counts like the Claude Code fleet", () => {
+		assert.equal(formatFleetElapsed(10_600), "11s");
+		assert.equal(formatFleetTokens(999), "↓ 999 tokens");
+		assert.equal(formatFleetTokens(13_100), "↓ 13.1k tokens");
+		assert.equal(formatFleetTokens(1_250_000), "↓ 1.3M tokens");
+	});
+
+	it("renders main plus active children below the editor and bounds every line", () => {
+		const state = stateForTest();
+		const now = Date.now();
+		for (let index = 0; index < 7; index++) {
+			state.foregroundControls.set(`run-${index}`, {
+				runId: `run-${index}`,
+				mode: "single",
+				startedAt: now - 11_000 + index,
+				updatedAt: now,
+				currentAgent: `worker-${index}`,
+				description: index === 0 ? "Inspect\nmodule 0" : `Inspect module ${index}`,
+				tokens: index === 0 ? 13_100 : index,
+			});
+		}
+
+		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(key: string, content: typeof widgetFactory | undefined, options?: { placement?: string }) {
+					assert.equal(key, FLEET_STATUS_WIDGET_KEY);
+					if (content) {
+						assert.equal(options?.placement, "belowEditor");
+						widgetFactory = content;
+					}
+				},
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				requestRender() {},
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			assert.ok(widgetFactory);
+			const component = widgetFactory!({ requestRender() {} }, theme);
+			const lines = component.render(80);
+			assert.ok(lines.some((line) => line.includes("⏺ main")));
+			assert.ok(lines.some((line) => line.includes("worker-0") && line.includes("Inspect module 0")));
+			assert.ok(lines.some((line) => line.includes("11s · ↓ 13.1k tokens")));
+			assert.ok(lines.some((line) => line.includes("↓ 2 more")));
+			for (const line of lines) assert.ok(visibleWidth(line) <= 80, `line exceeded width: ${line}`);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("keeps widget ownership through invalidation so an empty refresh removes it", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+		});
+		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[]; invalidate(): void }) | undefined;
+		let removals = 0;
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: typeof widgetFactory | undefined) {
+					if (content) widgetFactory = content;
+					else removals++;
+				},
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				requestRender() {},
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			const component = widgetFactory!({ requestRender() {} }, theme);
+			component.invalidate();
+			state.foregroundControls.clear();
+			fleet.refresh();
+			assert.equal(removals, 1);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("removes the dynamic widget while the fleet inspector owns the viewport", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+		});
+		const registrations: string[] = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: unknown) {
+					registrations.push(content ? "shown" : "hidden");
+				},
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				requestRender() {},
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			state.fleetInspectorOpen = true;
+			fleet.refresh();
+			state.fleetInspectorOpen = false;
+			fleet.refresh();
+			assert.deepEqual(registrations, ["shown", "hidden", "shown"]);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("shows only the current sequential chain step while retaining active parallel siblings", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("sequential", {
+			asyncId: "sequential",
+			asyncDir: "/tmp/sequential",
+			status: "running",
+			mode: "chain",
+			currentStep: 1,
+			startedAt: 50,
+			updatedAt: 200,
+			steps: [
+				{ agent: "scout", index: 0, status: "complete" },
+				{ agent: "worker", index: 1, status: "running" },
+				{ agent: "reviewer", index: 2, status: "pending" },
+			],
+		});
+		state.asyncJobs.set("parallel-group", {
+			asyncId: "parallel-group",
+			asyncDir: "/tmp/parallel-group",
+			status: "running",
+			mode: "chain",
+			currentStep: 3,
+			activeParallelGroup: true,
+			startedAt: 100,
+			updatedAt: 200,
+			steps: [
+				{ agent: "reviewer", index: 3, status: "running" },
+				{ agent: "tester", index: 4, status: "pending" },
+			],
+		});
+		assert.deepEqual(collectFleetStatusEntries(state).map((entry) => entry.key), [
+			"async:sequential:1",
+			"async:parallel-group:3",
+			"async:parallel-group:4",
+		]);
+	});
+
+	it("shows every active foreground parallel child", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("parallel", {
+			runId: "parallel",
+			mode: "parallel",
+			startedAt: 10,
+			updatedAt: 30,
+			activeChildren: new Map([
+				[0, { index: 0, agent: "reviewer", description: "Review correctness", startedAt: 11, updatedAt: 21, tokens: 100 }],
+				[1, { index: 1, agent: "reviewer", description: "Review quality", startedAt: 12, updatedAt: 22, tokens: 200 }],
+				[2, { index: 2, agent: "reviewer", description: "Review tests", startedAt: 13, updatedAt: 23, tokens: 300 }],
+			]),
+		});
+
+		const entries = collectFleetStatusEntries(state);
+		assert.deepEqual(entries.map((entry) => entry.key), [
+			"foreground-active:parallel:0",
+			"foreground-active:parallel:1",
+			"foreground-active:parallel:2",
+		]);
+		assert.deepEqual(entries.map((entry) => entry.description), ["Review correctness", "Review quality", "Review tests"]);
+		assert.deepEqual(collectFleetSnapshot(state).items.map((item) => item.key), entries.map((entry) => entry.key));
+	});
+
+	it("uses the same item keys as the full inspector", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("foreground", {
+			runId: "foreground",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+			currentIndex: 2,
+		});
+		const asyncJob = {
+			asyncId: "background",
+			asyncDir: "/tmp/background",
+			sessionId: "session-current",
+			status: "running" as const,
+			mode: "single" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			steps: [{ agent: "reviewer", index: 0, status: "running" as const }],
+		};
+		state.asyncJobs.set(asyncJob.asyncId, asyncJob);
+		state.fleetJobs!.set(asyncJob.asyncId, asyncJob);
+
+		const statusKeys = collectFleetStatusEntries(state).map((entry) => entry.key).sort();
+		const inspectorKeys = collectFleetSnapshot(state).items.map((item) => item.key).sort();
+		assert.deepEqual(statusKeys, inspectorKeys);
+	});
+
+	it("uses tracked async task descriptions and per-child token totals", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("async-run", {
+			asyncId: "async-run",
+			asyncDir: "/tmp/async-run",
+			status: "running",
+			mode: "parallel",
+			description: "Review the authentication changes",
+			startedAt: 100,
+			updatedAt: 200,
+			steps: [
+				{ agent: "reviewer", index: 0, status: "running", startedAt: 120, tokens: { input: 4_000, output: 200, total: 4_200 } },
+				{ agent: "worker", index: 1, status: "complete", tokens: { input: 100, output: 20, total: 120 } },
+			],
+		});
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: typeof widgetFactory | undefined) { if (content) widgetFactory = content; },
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				requestRender() {},
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		try {
+			fleet.setContext(ctx);
+			const lines = widgetFactory!({ requestRender() {} }, theme).render(100);
+			assert.ok(lines.some((line) => line.includes("reviewer") && line.includes("Review the authentication changes")));
+			assert.ok(lines.some((line) => line.includes("↓ 4.2k tokens")));
+			assert.ok(!lines.some((line) => line.includes("worker")), "completed async children should leave the status fleet");
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("only captures navigation at an empty editor and opens the selected child", async () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: Date.now() - 1_000,
+			updatedAt: Date.now(),
+			currentAgent: "worker",
+			description: "Implement FleetView",
+		});
+		let editorText = "draft";
+		let inputHandler: ((data: string) => { consume?: boolean } | undefined) | undefined;
+		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
+		const opened: string[] = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: typeof widgetFactory | undefined) { if (content) widgetFactory = content; },
+				onTerminalInput(handler: typeof inputHandler) { inputHandler = handler; return () => { inputHandler = undefined; }; },
+				getEditorText() { return editorText; },
+				requestRender() {},
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, async (key) => { opened.push(key); }, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			assert.ok(inputHandler);
+			assert.ok(widgetFactory);
+			const tui = { requestRender() {}, focusedComponent: Object.create(Editor.prototype) as Editor };
+			const component = widgetFactory!(tui, theme);
+
+			assert.equal(inputHandler!("\x1b[B"), undefined, "non-empty editor should retain Down");
+			editorText = "";
+			tui.focusedComponent = {} as Editor;
+			assert.equal(inputHandler!("\x1b[B"), undefined, "non-editor focus should retain Down");
+			tui.focusedComponent = Object.create(Editor.prototype) as Editor;
+			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true });
+			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true });
+			assert.ok(component.render(100).some((line) => line.includes("⏺ worker")));
+			assert.deepEqual(inputHandler!("\r"), { consume: true });
+			await Promise.resolve();
+			assert.deepEqual(opened, ["foreground-active:run-worker:0"]);
+			await new Promise<void>((resolve) => setImmediate(resolve));
+			widgetFactory!(tui, theme);
+			assert.deepEqual(inputHandler!("\x1b"), { consume: true });
+			assert.ok(component.render(100).some((line) => line.includes("⏺ main")));
+		} finally {
+			fleet.dispose();
+		}
+	});
+});