@selesai/code 0.8.6 → 0.8.7

package/dist/extensions/pi-subagents/test/unit/external-runs.test.ts

@@ -1,66 +1,159 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import {
+	EXTERNAL_RUN_LIMITS,
 	EXTERNAL_RUN_REGISTRY_KEY,
-	registerExternalRunProvider,
+	EXTERNAL_RUN_REGISTRY_VERSION,
+	listExternalRuns,
+	registerExternalRun,
 	snapshotExternalRuns,
+	unregisterExternalRun,
+	updateExternalRun,
 } from "../../src/api/external-runs.ts";
 
 function clearRegistry(): void {
 	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)];
 }
 
-test("external-run providers expose scoped observational records without controls", () => {
+test("external runs register, update, list, and unregister cached display records", () => {
 	clearRegistry();
-	const dispose = registerExternalRunProvider({
-		name: "interactive-shell",
-		listExternalRuns: () => [{
-			id: "review-794",
-			sessionId: "session-a",
-			source: "interactive_shell",
-			state: "completed",
-			completionReason: "auto-close-quiet",
-			cwd: "/tmp/review",
-			reportPath: "/tmp/review.md",
-			exitCode: null,
-			residualRisks: ["The terminal runtime owns process control."],
-		}],
+	assert.deepEqual(registerExternalRun({
+		id: "review-1083",
+		sessionId: "session-a",
+		source: "interactive-shell",
+		label: "Dependency review",
+		state: "running",
+		startedAt: 100,
+		currentAction: "Inspecting package metadata",
+	}), {
+		id: "review-1083",
+		sessionId: "session-a",
+		source: "interactive-shell",
+		label: "Dependency review",
+		state: "running",
+		startedAt: 100,
+		currentAction: "Inspecting package metadata",
 	});
-	assert.deepEqual(snapshotExternalRuns("session-a"), [{
-		provider: "interactive-shell",
-		id: "review-794",
+	assert.deepEqual(snapshotExternalRuns("session-b"), []);
+	assert.deepEqual(updateExternalRun("session-a", "review-1083", {
+		state: "completed",
+		updatedAt: 190,
+		endedAt: 200,
+		preview: "Review complete",
+		reportPath: "/tmp/review.md",
+	}), {
+		id: "review-1083",
 		sessionId: "session-a",
-		source: "interactive_shell",
+		source: "interactive-shell",
+		label: "Dependency review",
 		state: "completed",
-		completionReason: "auto-close-quiet",
-		cwd: "/tmp/review",
+		startedAt: 100,
+		updatedAt: 190,
+		endedAt: 200,
+		currentAction: "Inspecting package metadata",
+		preview: "Review complete",
 		reportPath: "/tmp/review.md",
-		exitCode: null,
-		residualRisks: ["The terminal runtime owns process control."],
-	}]);
-	assert.deepEqual(snapshotExternalRuns("session-b"), []);
-	dispose();
+	});
+	assert.deepEqual(listExternalRuns("session-a"), snapshotExternalRuns("session-a"));
+	assert.equal(unregisterExternalRun("session-a", "review-1083"), true);
+	assert.equal(unregisterExternalRun("session-a", "review-1083"), false);
+	assert.deepEqual(snapshotExternalRuns("session-a"), []);
 	clearRegistry();
 });
 
-test("external-run providers reject malformed and duplicate records", () => {
+test("external run validation is atomic and display text is bounded", () => {
 	clearRegistry();
-	assert.throws(() => registerExternalRunProvider({ name: " bad", listExternalRuns: () => [] }), /trimmed/);
-	registerExternalRunProvider({
-		name: "interactive-shell",
-		listExternalRuns: () => [
-			{ id: "run", sessionId: "session-a", source: "interactive_shell", state: "running", extra: true },
-		] as never,
+	registerExternalRun({
+		id: "run",
+		sessionId: "session-a",
+		source: "tool",
+		label: "Initial",
+		state: "running",
+		startedAt: 1,
 	});
-	assert.throws(() => snapshotExternalRuns("session-a"), /unknown fields: extra/);
-	clearRegistry();
-	registerExternalRunProvider({
-		name: "interactive-shell",
-		listExternalRuns: () => [
-			{ id: "run", sessionId: "session-a", source: "interactive_shell", state: "running" },
-			{ id: "run", sessionId: "session-a", source: "interactive_shell", state: "running" },
-		],
+	assert.throws(
+		() => updateExternalRun("session-a", "run", { state: "invalid" as never, label: "Changed" }),
+		/state is invalid/,
+	);
+	assert.equal(snapshotExternalRuns("session-a")[0]?.label, "Initial");
+	const updated = updateExternalRun("session-a", "run", {
+		label: `\u001b[31m${"x".repeat(EXTERNAL_RUN_LIMITS.maxTextLength + 20)}`,
+		preview: `line 1\n${"p".repeat(EXTERNAL_RUN_LIMITS.maxPreviewLength + 20)}`,
 	});
-	assert.throws(() => snapshotExternalRuns("session-a"), /duplicate run 'run'/);
+	assert.equal(updated.label.length, EXTERNAL_RUN_LIMITS.maxTextLength);
+	assert.ok(updated.preview!.length <= EXTERNAL_RUN_LIMITS.maxPreviewLength);
+	assert.doesNotMatch(updated.label, /\u001b/);
+	assert.doesNotMatch(updated.preview!, /\n/);
+	assert.throws(
+		() => registerExternalRun({ id: "unsafe\nrun", sessionId: "session-a", source: "tool", label: "Unsafe", state: "running", startedAt: 1 }),
+		/display-safe/,
+	);
+	assert.throws(
+		() => registerExternalRun({ id: "extra", sessionId: "session-a", source: "tool", label: "Extra", state: "running", startedAt: 1, cwd: "/private" } as never),
+		/unknown fields: cwd/,
+	);
+	assert.throws(
+		() => registerExternalRun({ id: "invalid-date", sessionId: "session-a", source: "tool", label: "Invalid date", state: "running", startedAt: Number.MAX_SAFE_INTEGER }),
+		/safe timestamp/,
+	);
+	clearRegistry();
+});
+
+test("external snapshots throw on malformed cached records by default", () => {
+	clearRegistry();
+	try {
+		(globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)] = {
+			version: EXTERNAL_RUN_REGISTRY_VERSION,
+			runs: new Map<string, unknown>([
+				["session-a\0bad", { id: "bad", sessionId: "session-a", source: "tool", label: "Bad", state: "running", startedAt: Number.NaN }],
+				["session-a\0good", { id: "good", sessionId: "session-a", source: "tool", label: "Good", state: "running", startedAt: 1 }],
+			]),
+		};
+		assert.throws(
+			() => snapshotExternalRuns("session-a"),
+			/Malformed cached external run 'session-a\0bad': External run startedAt must be a non-negative safe timestamp/,
+		);
+	} finally {
+		clearRegistry();
+	}
+});
+
+test("external snapshots can remove malformed cached records for display-only callers", () => {
+	clearRegistry();
+	const diagnostics: string[] = [];
+	try {
+		(globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)] = {
+			version: EXTERNAL_RUN_REGISTRY_VERSION,
+			runs: new Map<string, unknown>([
+				["session-a\0bad", { id: "bad", sessionId: "session-a", source: "tool", label: "Bad", state: "running", startedAt: Number.NaN }],
+				["session-a\0good", { id: "good", sessionId: "session-a", source: "tool", label: "Good", state: "running", startedAt: 1 }],
+			]),
+		};
+		assert.deepEqual(snapshotExternalRuns("session-a", { ignoreMalformed: true, onMalformedRecord: (message) => diagnostics.push(message) }).map((run) => run.id), ["good"]);
+		assert.deepEqual(diagnostics, ["Malformed cached external run 'session-a\0bad': External run startedAt must be a non-negative safe timestamp."]);
+		assert.deepEqual(snapshotExternalRuns("session-a").map((run) => run.id), ["good"]);
+	} finally {
+		clearRegistry();
+	}
+});
+
+test("external snapshots apply count and serialized byte caps without provider callbacks", () => {
+	clearRegistry();
+	for (let index = 0; index < EXTERNAL_RUN_LIMITS.maxSnapshotRuns + 5; index++) {
+		registerExternalRun({
+			id: `run-${index}`,
+			sessionId: "session-a",
+			source: "tool",
+			label: `Run ${index}`,
+			state: index === 0 ? "running" : "completed",
+			startedAt: index,
+			updatedAt: index,
+			preview: "p".repeat(EXTERNAL_RUN_LIMITS.maxPreviewLength),
+		});
+	}
+	const snapshot = snapshotExternalRuns("session-a");
+	assert.ok(snapshot.length <= EXTERNAL_RUN_LIMITS.maxSnapshotRuns);
+	assert.ok(Buffer.byteLength(JSON.stringify(snapshot), "utf8") <= EXTERNAL_RUN_LIMITS.maxSerializedBytes);
+	assert.equal(snapshot[0]?.id, "run-0", "active jobs sort ahead of terminal jobs");
 	clearRegistry();
 });

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

@@ -3,6 +3,7 @@ import { describe, it } from "node:test";
 import { Editor, type EditorComponent, visibleWidth } from "@earendil-works/pi-tui";
 import type { ExtensionContext } from "@selesai/code";
 import type { SubagentState } from "../../src/shared/types.ts";
+import { EXTERNAL_RUN_REGISTRY_KEY, EXTERNAL_RUN_REGISTRY_VERSION, registerExternalRun } from "../../src/api/external-runs.ts";
 import { collectFleetSnapshot } from "../../src/tui/fleet.ts";
 import {
 	FLEET_STATUS_WIDGET_KEY,
@@ -13,6 +14,10 @@ import {
 	resolveFleetViewPlacement,
 } from "../../src/tui/fleet-status.ts";
 
+function clearExternalRuns(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)];
+}
+
 function stateForTest(): SubagentState {
 	return {
 		baseCwd: process.cwd(),
@@ -46,6 +51,73 @@ describe("below-editor subagent FleetView", () => {
 		assert.equal(formatFleetTokens(1_250_000), "↓ 1.3M tokens");
 	});
 
+	it("renders cached external jobs with an external marker and elapsed time", () => {
+		clearExternalRuns();
+		registerExternalRun({
+			id: "external-review",
+			sessionId: "session-current",
+			source: "interactive-shell",
+			label: "Dependency review",
+			state: "running",
+			startedAt: Date.now() - 11_000,
+			currentAction: "Inspecting package metadata",
+		});
+		const state = stateForTest();
+		state.activeAsyncCapacity = { used: 0, limit: 0 };
+		assert.deepEqual(collectFleetStatusEntries(state).map((entry) => ({ key: entry.key, agent: entry.agent, description: entry.description })), [{
+			key: "external:external-review",
+			agent: "external · Dependency review",
+			description: "Inspecting package metadata",
+		}]);
+		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;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			const tui = { requestRender() {}, focusedComponent: Object.create(Editor.prototype) as Editor };
+			const component = widgetFactory!(tui, theme);
+			const compact = component.render(80)[0]!;
+			assert.match(compact, /1 active job/);
+			assert.doesNotMatch(compact, /Async runs|tokens/);
+			fleet.handleKey("\x1b[B");
+			const expanded = component.render(80).join("\n");
+			assert.match(expanded, /external · Dependency review · running/);
+			assert.match(expanded, /11s/);
+			assert.doesNotMatch(expanded.split("\n").find((line) => line.includes("Dependency review"))!, /tokens/);
+		} finally {
+			fleet.dispose();
+			clearExternalRuns();
+		}
+	});
+
+	it("warns when compact FleetView cannot inspect external jobs", () => {
+		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 + 1,
+			runs: new Map(),
+		};
+		try {
+			assert.deepEqual(collectFleetStatusEntries(stateForTest()), []);
+			assert.match(warnings[0]!, /Failed to inspect external jobs/);
+		} finally {
+			console.warn = originalWarn;
+			clearExternalRuns();
+		}
+	});
+
 	it("resolves configured FleetView placement with a below-editor fallback", () => {
 		assert.equal(resolveFleetViewPlacement(undefined), "belowEditor");
 		assert.equal(resolveFleetViewPlacement("belowEditor"), "belowEditor");
@@ -417,6 +489,16 @@ describe("below-editor subagent FleetView", () => {
 				thinking: "medium",
 				startedAt: 10,
 				lastUpdate: 20,
+				...(index === 4 ? {
+					children: [{
+						id: "nested-hidden-child",
+						parentRunId: "nested-4",
+						depth: 2,
+						path: [{ runId: "supervisor", stepIndex: 0 }, { runId: "nested-4" }],
+						state: "running" as const,
+						agent: "hidden-child",
+					}],
+				} : {}),
 			})),
 		});
 		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[] }) | undefined;
@@ -448,7 +530,8 @@ describe("below-editor subagent FleetView", () => {
 				assert.match(line!, new RegExp(state));
 			}
 			assert.doesNotMatch(lines, /leaf-4.*running/);
-			assert.match(lines, /\+1 nested leaves/);
+			assert.doesNotMatch(lines, /hidden-child/);
+			assert.match(lines, /\+2 nested leaves/);
 		} finally {
 			fleet.dispose();
 		}
@@ -594,6 +677,174 @@ describe("below-editor subagent FleetView", () => {
 		}]);
 	});
 
+	it("renders a workflow-owned foreground child under its workflow parent", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			startedAt: 10,
+			updatedAt: 20,
+			nestedChildren: [{
+				id: "owner-nested",
+				parentRunId: "workflow-1",
+				depth: 1,
+				path: [{ runId: "workflow-1" }],
+				state: "running",
+				agent: "owner-nested",
+			}],
+		});
+		state.foregroundControls.set("child-1", {
+			runId: "child-1",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "review",
+			mode: "single",
+			startedAt: 11,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "reviewer", startedAt: 11, updatedAt: 20 }]]),
+			nestedChildren: [{
+				id: "nested-review",
+				parentRunId: "child-1",
+				parentStepIndex: 0,
+				depth: 1,
+				path: [{ runId: "child-1", stepIndex: 0 }],
+				state: "running",
+				agent: "nested-reviewer",
+			}],
+		});
+		state.foregroundControls.set("child-2", {
+			runId: "child-2",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "test",
+			mode: "single",
+			startedAt: 12,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "tester", startedAt: 12, updatedAt: 20 }]]),
+			nestedChildren: [{
+				id: "nested-test",
+				parentRunId: "child-2",
+				parentStepIndex: 0,
+				depth: 1,
+				path: [{ runId: "child-2", stepIndex: 0 }],
+				state: "running",
+				agent: "nested-tester",
+			}],
+		});
+		const entries = collectFleetStatusEntries(state);
+		assert.deepEqual(entries.map((entry) => [entry.key, entry.parentKey]), [
+			["async:workflow-1", undefined],
+			["foreground-active:child-1:0", "async:workflow-1"],
+			["foreground-active:child-2:0", "async:workflow-1"],
+		]);
+
+		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;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			const component = widgetFactory!({ requestRender() {}, focusedComponent: Object.create(Editor.prototype) as Editor }, theme);
+			const compact = component.render(120);
+			assert.match(compact[0]!, /2 active agents/, "workflow wrappers must not be counted as leaf agents");
+			assert.doesNotMatch(compact[0]!, /3 active agents/);
+			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
+			const lines = component.render(120);
+			const workflowIndex = lines.findIndex((line) => line.includes("workflow · running"));
+			const childIndex = lines.findIndex((line) => line.includes("reviewer · running"));
+			const nestedIndex = lines.findIndex((line) => line.includes("nested-reviewer"));
+			const secondChildIndex = lines.findIndex((line) => line.includes("tester · running"));
+			const secondNestedIndex = lines.findIndex((line) => line.includes("nested-tester"));
+			const ownerNestedIndex = lines.findIndex((line) => line.includes("owner-nested"));
+			assert.ok(workflowIndex >= 0 && childIndex > workflowIndex && nestedIndex > childIndex);
+			assert.ok(secondChildIndex > nestedIndex && secondNestedIndex > secondChildIndex && ownerNestedIndex > secondNestedIndex);
+			assert.match(lines[childIndex]!, /├─.*reviewer/);
+			assert.match(lines[nestedIndex]!, /├─.*nested-reviewer/);
+			assert.match(lines[secondNestedIndex]!, /├─.*nested-tester/);
+			assert.match(lines[ownerNestedIndex]!, /└─.*owner-nested/);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("renders recursive nested runs and steps within the existing row budget", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("supervisor", {
+			asyncId: "supervisor",
+			asyncDir: "/tmp/supervisor",
+			status: "running",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			steps: [{ agent: "supervisor", index: 0, status: "running" }],
+			nestedChildren: [{
+				id: "level-one",
+				parentRunId: "supervisor",
+				parentStepIndex: 0,
+				depth: 1,
+				path: [{ runId: "supervisor", stepIndex: 0 }],
+				state: "running",
+				agent: "level-one",
+				children: [{
+					id: "level-two",
+					parentRunId: "level-one",
+					depth: 2,
+					path: [{ runId: "supervisor", stepIndex: 0 }, { runId: "level-one" }],
+					state: "running",
+					mode: "parallel",
+					steps: [{
+						agent: "level-two",
+						status: "running",
+						children: [0, 1, 2, 3].map((index) => ({
+							id: `leaf-${index}`,
+							parentRunId: "level-two",
+							depth: 3,
+							path: [{ runId: "level-two" }],
+							state: "running" as const,
+							agent: `leaf-${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) { if (content) 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);
+			const component = widgetFactory!({ requestRender() {}, focusedComponent: Object.create(Editor.prototype) as Editor }, theme);
+			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
+			const lines = component.render(140).join("\n");
+			assert.match(lines, /level-one/);
+			assert.match(lines, /level-two/);
+			assert.match(lines, /leaf-0/);
+			assert.match(lines, /leaf-1/);
+			assert.doesNotMatch(lines, /leaf-[23]/);
+			assert.match(lines, /\+2 nested leaves/);
+		} finally {
+			fleet.dispose();
+		}
+	});
+
 	it("uses the same item keys as the full inspector", () => {
 		const state = stateForTest();
 		state.foregroundControls.set("foreground", {