@ferris1225/pi-subagents 0.32.2 → 1.0.0

package/src/trajectory.ts

@@ -1,34 +1,11 @@
 /**
- * Append-only inspector backing stores for sub-agent threads.
+ * Append-only lifecycle trajectories for logical sub-agent threads.
  *
- * Two structures, both owned by a single thread record ({@link TrajectoryLog} or
- * {@link InspectRunState}):
- *
- * - {@link TrajectoryLog} — a typed, append-only event log covering
- *   orchestration (dispatch, model-candidate switches, retries, control actions
- *   steer/retarget/park/resume/stop) and live child activity (status transitions,
- *   tool starts/ends, usage). Events keep their generation and source timestamps
- *   forever: resume/restart clears the mutable summary fields but NEVER the
- *   event history, so the inspector can show the full story of a thread across
- *   generations. Fork and worktree events carry typed relationship/lifecycle
- *   payloads so retained source/child state remains inspectable.
- *
- * - {@link TranscriptBuffer} — a bounded rolling window of streamed assistant
- *   text/thinking for the CURRENT generation, dropped on restart and cleared on
- *   parent-session teardown. Render-performance aid only; it trends toward
- *   dropping old output while the trajectory log is the durable record.
- *
- * Aliveness back-compat: the widget's "thinking"/"responding" activity comes from
- * forwarded {@link SubagentLiveEvent}s, which carry no delta payload. The
- * trajectory needs the delta text itself. Rather than widening the live event
- * union (which would silently drop interpreter results from widget consumers),
- * the monitor fan-out handler extracts the delta text alongside forwarding and
- * appends it here — additive, zero churn for the widget path.
- *
- * Secret hygiene: tool arguments are summarized verbatim by key, but obvious
- * credential-bearing fields (token/password/authorization/apiKey/secret/...)
- * are redacted, and values are truncated to a compact length. Arbitrary deep
- * payloads never enter the transcript or the trajectory.
+ * Events cover dispatch, model candidates, retries, controls, tool activity,
+ * usage, worktrees, forks, and settlement. Each event keeps its generation and
+ * timestamp across resume/restart; mutable summary fields reset per generation.
+ * Tool arguments are reduced to a short terminal-safe summary with obvious
+ * credential fields and embedded secrets redacted.
  */
 
 import { stripVTControlCharacters } from "node:util";
@@ -156,75 +133,6 @@ function truncateSummary(text: string): string {
 	return chars.length > TOOL_ARG_SUMMARY_MAX ? `${chars.slice(0, TOOL_ARG_SUMMARY_MAX - 1).join("")}…` : text;
 }
 
-// ---------------------------------------------------------------------------
-// Bounded transcript buffer (per-generation streaming output)
-// ---------------------------------------------------------------------------
-
-export interface TranscriptBudget {
-	/** Max Unicode code points kept per section (not UTF-16 units/display cells). */
-	maxTextChars: number;
-	maxThinkingChars: number;
-}
-
-export const DEFAULT_TRANSCRIPT_BUDGET: TranscriptBudget = {
-	maxTextChars: 8_000,
-	maxThinkingChars: 2_000,
-};
-
-export class TranscriptBuffer {
-	private text = "";
-	private thinking = "";
-	private textDropped = 0;
-	private thinkingDropped = 0;
-
-	constructor(private readonly budget: TranscriptBudget = DEFAULT_TRANSCRIPT_BUDGET) {}
-
-	appendText(delta: string): void {
-		if (!delta) return;
-		const next = cap(
-			(this.text + stripVTControlCharacters(delta)).replace(/\r\n?/g, "\n"),
-			this.budget.maxTextChars,
-		);
-		this.text = next.value;
-		this.textDropped += next.dropped;
-	}
-
-	appendThinking(delta: string): void {
-		if (!delta) return;
-		const next = cap(
-			(this.thinking + stripVTControlCharacters(delta)).replace(/\r\n?/g, "\n"),
-			this.budget.maxThinkingChars,
-		);
-		this.thinking = next.value;
-		this.thinkingDropped += next.dropped;
-	}
-
-	/** Current-generation streams; structured so the renderer can flow-wrap. */
-	snapshot(): { text: string; textTruncated: boolean; thinking: string; thinkingTruncated: boolean } {
-		return {
-			text: this.text,
-			textTruncated: this.textDropped > 0,
-			thinking: this.thinking,
-			thinkingTruncated: this.thinkingDropped > 0,
-		};
-	}
-
-	clear(): void {
-		this.text = "";
-		this.thinking = "";
-		this.textDropped = 0;
-		this.thinkingDropped = 0;
-	}
-}
-
-function cap(value: string, max: number): { value: string; dropped: number } {
-	const points = [...value];
-	const limit = Math.max(0, max);
-	if (points.length <= limit) return { value, dropped: 0 };
-	const dropped = points.length - limit;
-	return { value: points.slice(dropped).join(""), dropped };
-}
-
 // ---------------------------------------------------------------------------
 // Trajectory log
 // ---------------------------------------------------------------------------
@@ -370,134 +278,35 @@ export class TrajectoryLog {
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Inspector run-state projection (trajectory + transcript + retained run info)
-// ---------------------------------------------------------------------------
-
-/**
- * Per-thread projection the inspector reads: live trajectory + bounded
- * transcript + retained snapshot for completed/failed/parked threads so the
- * detail pane survives monitor-row removal. Render code must treat this as
- * read-only.
- */
-export class InspectRunState {
+export class ThreadTrajectoryState {
 	readonly trajectory: TrajectoryLog;
-	readonly transcript = new TranscriptBuffer();
-
-	agent = "";
-	task = "";
-	label = "";
-	model?: string;
-	thinking?: string;
-	status = "queued";
-	startedAt?: number;
-	endedAt?: number;
 
-	/** Present for the monitor-row lifetime and beyond (via retained snapshot). */
-	runInfo?: {
-		usage?: UsageStats;
-		toolCount?: number;
-		activity?: string;
-		currentTool?: string;
-	};
-
-	constructor(
-		readonly runId: number,
-		notify: () => void,
-	) {
-		this.trajectory = new TrajectoryLog(runId, notify);
+	constructor(readonly runId: number) {
+		this.trajectory = new TrajectoryLog(runId, () => {});
 	}
 
 	get generation(): number {
 		return this.trajectory.generation;
 	}
-
-	/** Preserve run metadata before the monitor row goes away (beginTurn sweep,
-	 * finishRun removal). Only fillsAnnounce fields; the inspector's detail pane
-	 * stays truthful even for finished, swept threads. */
-	retainFrom(run: {
-		agent: string;
-		task: string;
-		label?: string;
-		model?: string;
-		thinking?: string;
-		status: string;
-		startedAt?: number;
-		endedAt?: number;
-		usage?: UsageStats;
-		toolCount?: number;
-		activity?: string;
-		currentTool?: string;
-	}): void {
-		this.agent = run.agent;
-		this.task = run.task;
-		this.label = run.label ?? "";
-		this.model = run.model ?? this.model;
-		this.thinking = run.thinking ?? this.thinking;
-		this.status = run.status;
-		this.startedAt = run.startedAt;
-		this.endedAt = run.endedAt;
-		this.runInfo = {
-			usage: run.usage,
-			toolCount: run.toolCount,
-			activity: run.activity,
-			currentTool: run.currentTool,
-		};
-	}
 }
 
-/**
- * Registry of inspector projections for the parent session. Survives monitor
- * row removal so completed/failed/parked threads stay inspectable.
- */
-export class InspectorStore {
-	private readonly states = new Map<number, InspectRunState>();
-	private readonly listeners = new Set<() => void>();
+/** Session-scoped registry of logical-thread trajectories. */
+export class TrajectoryStore {
+	private readonly states = new Map<number, ThreadTrajectoryState>();
 
-	/** Get (creating on demand) the projection for a thread id. */
-	get(runId: number): InspectRunState {
+	get(runId: number): ThreadTrajectoryState {
 		let state = this.states.get(runId);
 		if (!state) {
-			state = new InspectRunState(runId, () => this.emit());
+			state = new ThreadTrajectoryState(runId);
 			this.states.set(runId, state);
 		}
 		return state;
 	}
 
-	find(runId: number): InspectRunState | undefined {
-		return this.states.get(runId);
-	}
-
-	all(): InspectRunState[] {
-		return [...this.states.values()].sort((a, b) => a.runId - b.runId);
-	}
-
-	subscribe(listener: () => void): () => void {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-
-	private emit(): void {
-		for (const listener of this.listeners) {
-			try {
-				listener();
-			} catch {
-				/* subscriber errors must not break the store */
-			}
-		}
-	}
-
-	/** Parent-session teardown only: drop every projection and its history. */
 	clearAll(): void {
-		for (const state of this.states.values()) {
-			state.trajectory.clearAll();
-			state.transcript.clear();
-		}
+		for (const state of this.states.values()) state.trajectory.clearAll();
 		this.states.clear();
-		this.emit();
 	}
 }
 
-export const inspectorStore = new InspectorStore();
+export const trajectoryStore = new TrajectoryStore();

package/src/inspector-panel.ts

@@ -1,363 +0,0 @@
-/**
- * /subagents-inspect — a live overlay listing logical sub-agent threads and the
- * selected thread's real-time work: header facts (run id, agent, generation,
- * model chain, thinking, elapsed, usage/cost), the streaming transcript, recent
- * tools, and the append-only orchestration trajectory.
- *
- * Data comes from a read-only snapshot (buildInspectorSnapshot → monitor +
- * runtime threads + inspectorStore); the component itself never mutates
- * runtime state, except for the explicit park/resume keyboard shortcut which
- * delegates to the same thread control surface as subagent_control.
- *
- * Layout: a two-pane master/detail at wide widths, compact single-pane detail
- * when narrow. Every line is fitted with truncateToWidth — pi hard-crashes on
- * over-wide lines.
- */
-
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { stripVTControlCharacters } from "node:util";
-import {
-	Key,
-	matchesKey,
-	truncateToWidth,
-	visibleWidth,
-	type Component,
-	type TUI,
-} from "@earendil-works/pi-tui";
-import { buildInspectorSnapshot, formatTrajectoryEvent, type InspectorThreadView } from "./inspector.ts";
-import { formatDuration, formatUsageCompact, isRunActiveStatus, monitor, statusIcon, type RunStatus } from "./monitor.ts";
-import type { SubagentRuntime } from "./runtime.ts";
-import { inspectorStore } from "./trajectory.ts";
-
-/** Below this width the overlay falls back to the single-pane layout. */
-const WIDE_MIN = 110;
-const LEFT_PANE_WIDTH = 42;
-const MAX_LIST_ROWS = 12;
-const MAX_TRANSCRIPT_LINES = 9;
-const TICK_MS = 1_000;
-
-export interface InspectorOverlayOptions {
-	runtime: Pick<SubagentRuntime, "threads">;
-	tui: TUI;
-	theme: Theme;
-	done: () => void;
-	notify?: (message: string) => void;
-	tickMs?: number;
-}
-
-export class InspectorOverlay implements Component {
-	private selectedId?: number;
-	private closed = false;
-	private readonly unsubscribeMonitor: () => void;
-	private readonly unsubscribeInspector: () => void;
-	private readonly timer: ReturnType<typeof setInterval>;
-
-	constructor(private readonly options: InspectorOverlayOptions) {
-		// Live updates: any monitor mutation or trajectory append rerenders.
-		this.unsubscribeMonitor = monitor.subscribe(() => this.rerender());
-		this.unsubscribeInspector = inspectorStore.subscribe(() => this.rerender());
-		this.timer = setInterval(() => this.rerender(), options.tickMs ?? TICK_MS);
-		if (typeof this.timer.unref === "function") this.timer.unref();
-	}
-
-	private rerender(): void {
-		if (this.closed) return;
-		try {
-			this.options.tui.requestRender();
-		} catch {
-			/* a closed/failed TUI must not throw through store notifications */
-		}
-	}
-
-	/** Escape path (and any external teardown) unsubscribes cleanly. */
-	dispose(): void {
-		if (this.closed) return;
-		this.closed = true;
-		this.unsubscribeMonitor();
-		this.unsubscribeInspector();
-		clearInterval(this.timer);
-	}
-
-	invalidate(): void {
-		/* stateless render — nothing cached */
-	}
-
-	private move(items: readonly { id: number }[], delta: number): void {
-		if (items.length === 0) return;
-		const index = items.findIndex((item) => item.id === this.selectedId);
-		const current = index === -1 ? items.length - 1 : index;
-		const next = (current + delta + items.length) % items.length;
-		this.selectedId = items[next].id;
-	}
-
-	/** Non-text quick action: park a live thread / resume a parked one. Text
-	 * actions (steer/retarget with payloads) stay on subagent_control. */
-	private togglePark(): void {
-		const id = this.selectedId;
-		if (id === undefined) return;
-		const thread = this.options.runtime.threads.get(id);
-		if (!thread) return;
-		if (thread.state === "parked") {
-			void thread
-				.resume(undefined)
-				.then((pending) => {
-					if (pending.exitCode !== -1) this.options.notify?.(`Could not resume run #${id}: no candidate could start.`);
-				})
-				.catch((error) => this.options.notify?.(`Could not resume run #${id}: ${errorMessageText(error)}`));
-			return;
-		}
-		const phase = thread.control.getPhase();
-		if (phase === "queued" || phase === "starting" || phase === "running" || phase === "steering" || phase === "interrupting" || phase === "retrying" || phase === "settled") {
-			void thread
-				.park()
-				.catch((error) => this.options.notify?.(`Could not park run #${id}: ${errorMessageText(error)}`));
-		}
-	}
-
-	handleInput(data: string): void {
-		if (matchesKey(data, Key.escape)) {
-			this.dispose();
-			this.options.done();
-			return;
-		}
-		const { items } = buildInspectorSnapshot({ runtime: this.options.runtime });
-		if (this.selectedId === undefined || !items.some((item) => item.id === this.selectedId)) {
-			this.selectedId = items.length > 0 ? items[items.length - 1].id : undefined;
-		}
-		if (matchesKey(data, Key.up) || data === "k") this.move(items, -1);
-		else if (matchesKey(data, Key.down) || data === "j" || matchesKey(data, Key.tab)) this.move(items, 1);
-		else if (data === "p") this.togglePark();
-		this.rerender();
-	}
-
-	render(width: number): string[] {
-		const theme = this.options.theme;
-		const fit = (line: string): string => truncateToWidth(line, width);
-		const snapshot = buildInspectorSnapshot({ runtime: this.options.runtime, selectedId: this.selectedId });
-		const { items } = snapshot;
-
-		// Selection stability: keep the chosen id across updates; fall back to
-		// the newest thread only when there is no valid selection.
-		if (this.selectedId === undefined || !items.some((item) => item.id === this.selectedId)) {
-			this.selectedId = items.length > 0 ? items[items.length - 1].id : undefined;
-		}
-		const detail =
-			this.selectedId === undefined
-				? undefined
-				: (buildInspectorSnapshot({ runtime: this.options.runtime, selectedId: this.selectedId }).detail ??
-					snapshot.detail);
-
-		const border = fit(theme.fg("accent", "─".repeat(Math.max(1, width))));
-		const activeCount = items.filter((item) => isRunActiveStatus(item.status)).length;
-		const liveText = activeCount > 0 ? `${activeCount} active` : "no active runs";
-		const header = fit(
-			`${theme.fg("accent", theme.bold("sub-agents"))} ${theme.fg(activeCount > 0 ? "accent" : "dim", "●")} ${theme.fg("dim", `${liveText} · ${items.length} thread${items.length === 1 ? "" : "s"}`)}`,
-		);
-		const footer = fit(
-			theme.fg(
-				"dim",
-				"↑/↓ select · p park/resume · subagent_control steer/retarget/park/resume/fork · subagent_stop destroys · Esc close",
-			),
-		);
-
-		const lines: string[] = [border, header, border];
-		if (items.length === 0) {
-			lines.push(fit(theme.fg("dim", "No sub-agent threads yet — delegate work with the subagent tool; live progress appears here.")));
-			lines.push(border, footer);
-			return lines;
-		}
-
-		if (width >= WIDE_MIN && detail) {
-			const paneLines = this.renderListPane(items, LEFT_PANE_WIDTH - 2);
-			const detailLines = this.renderDetail(detail, width - LEFT_PANE_WIDTH - 3);
-			const rows = Math.max(paneLines.length, detailLines.length);
-			for (let i = 0; i < rows; i++) {
-				const left = padRight(paneLines[i] ?? "", LEFT_PANE_WIDTH);
-				const right = detailLines[i] ?? "";
-				lines.push(fit(`${left} ${theme.fg("borderMuted", "│")} ${right}`));
-			}
-		} else {
-			lines.push(...this.renderListPane(items, width));
-			lines.push(fit(theme.fg("borderMuted", "─ ".repeat(Math.max(1, Math.floor(width / 2))))));
-			if (detail) lines.push(...this.renderDetail(detail, width));
-		}
-		lines.push(border, footer);
-		return lines;
-	}
-
-	private renderListPane(items: ReadonlyArray<{ id: number; agent: string; label: string; status: RunStatus; stateText: string; generation?: number; elapsedMs?: number }>, width: number): string[] {
-		const theme = this.options.theme;
-		const selIndex = Math.max(0, items.findIndex((item) => item.id === this.selectedId));
-		const start = Math.max(0, Math.min(selIndex - Math.floor(MAX_LIST_ROWS / 2), items.length - MAX_LIST_ROWS));
-		const visible = items.slice(start, start + MAX_LIST_ROWS);
-		const lines: string[] = [];
-		for (let i = 0; i < visible.length; i++) {
-			const item = visible[i];
-			const selected = start + i === selIndex;
-			const cursor = selected ? theme.fg("accent", "❯ ") : "  ";
-			const icon = statusIcon(item.status, theme);
-			const safeAgent = safeText(item.agent);
-			const safeLabel = safeText(item.label);
-			const safeState = safeText(item.stateText);
-			const name = selected ? theme.fg("accent", theme.bold(safeAgent)) : theme.fg("accent", safeAgent);
-			const labelPart = safeLabel ? theme.fg("dim", ` · ${safeLabel}`) : "";
-			const state = theme.fg("dim", ` ${item.elapsedMs !== undefined ? formatDuration(item.elapsedMs) + " " : ""}${safeState}`);
-			lines.push(truncateToWidth(`${cursor}${icon} ${theme.fg("dim", `#${item.id}`)} ${name}${labelPart}${state}`, width));
-		}
-		if (items.length > MAX_LIST_ROWS) {
-			lines.push(truncateToWidth(theme.fg("dim", `  ${selIndex + 1}/${items.length} · ↑/↓ for more`), width));
-		}
-		return lines;
-	}
-
-	private renderDetail(view: InspectorThreadView, width: number): string[] {
-		const theme = this.options.theme;
-		const fit = (line: string): string => truncateToWidth(line, width);
-		const dim = (text: string): string => theme.fg("dim", text);
-		const clean = safeText;
-		const lines: string[] = [];
-
-		// Identity + progress facts. Strip untrusted terminal controls BEFORE
-		// applying theme ANSI so OSC/CSI payloads can never reach the terminal.
-		const genPart = view.generation !== undefined ? ` · gen ${view.generation}` : "";
-		const safeState = clean(view.stateText);
-		const safePhase = clean(view.phase ?? "");
-		const phasePart = safePhase && safePhase !== safeState ? ` (${safePhase})` : "";
-		lines.push(fit(`${theme.fg("accent", theme.bold(`#${view.id} ${clean(view.agent)}`))}${dim(`${genPart} · ${safeState}${phasePart}`)}`));
-		if (view.label) lines.push(fit(dim(`label: ${clean(view.label)}`)));
-		lines.push(fit(dim(`task: ${oneLine(view.task)}`)));
-		const relations = [
-			view.forkedFromRunId !== undefined ? `forked from #${view.forkedFromRunId}` : undefined,
-			view.forkChildRunIds.length > 0 ? `fork children ${view.forkChildRunIds.map((id) => `#${id}`).join(", ")}` : undefined,
-		].filter(Boolean);
-		if (relations.length > 0) lines.push(fit(dim(`relation: ${relations.join(" · ")}`)));
-		if (view.isolation === "worktree") {
-			lines.push(fit(dim(`isolation: worktree · ${view.integrationStatus ?? "active"}`)));
-			if (view.originalCwd && view.isolationCwd) lines.push(fit(dim(`cwd: ${clean(view.originalCwd)} → ${clean(view.isolationCwd)}`)));
-			if (view.integrationWorktreePath) lines.push(fit(theme.fg("warning", `retained worktree: ${clean(view.integrationWorktreePath)}`)));
-			if (view.integrationPatchPath) lines.push(fit(theme.fg("warning", `retained patch: ${clean(view.integrationPatchPath)}`)));
-			if (view.integrationError) lines.push(fit(theme.fg("error", `integration: ${clean(view.integrationError)}`)));
-		}
-
-		// Model & thinking.
-		const chain = view.modelChain.length > 0 ? view.modelChain.map(clean).join(" → ") : "";
-		const currentModel = clean(view.model ?? "");
-		const modelLine = view.modelFallbackFrom
-			? `${currentModel} (pool fallback from ${clean(view.modelFallbackFrom)})`
-			: currentModel;
-		const thinkingSuffix = view.thinking ? ` · thinking ${clean(view.thinking)}` : "";
-		if (modelLine || chain) {
-			lines.push(fit(`${theme.fg("text", modelLine)}${dim(`${chain ? ` · chain: ${chain}` : ""}${thinkingSuffix}`)}`));
-		} else if (view.thinking) {
-			lines.push(fit(dim(`thinking ${clean(view.thinking)}`)));
-		}
-
-		// Elapsed + usage/cost + current activity.
-		const elapsed = view.elapsedMs !== undefined ? formatDuration(view.elapsedMs) : "—";
-		const usage = formatUsageCompact(view.usage);
-		const toolsText = view.toolCount > 0 ? ` · ${view.toolCount} tool${view.toolCount === 1 ? "" : "s"}` : "";
-		lines.push(fit(dim(`elapsed ${elapsed} · ${usage || "no usage yet"}${toolsText}`)));
-		const activity = view.activity ?? view.currentTool;
-		if (activity) lines.push(fit(theme.fg("accent", `▸ ${clean(activity)}`)));
-
-		// Streaming transcript: thinking first (dim), then output text.
-		const { text, textTruncated, thinking, thinkingTruncated } = view.transcript;
-		if (thinking) {
-			const thinkingLines = tailLines(thinking, 3);
-			if (thinkingTruncated) lines.push(fit(dim("thinking: … (older output dropped)")));
-			else lines.push(fit(dim("thinking:")));
-			for (const line of thinkingLines) lines.push(fit(dim(`  ${line}`)));
-		}
-		if (text) {
-			const textLines = tailLines(text, MAX_TRANSCRIPT_LINES);
-			if (textTruncated) lines.push(fit(dim("output: … (older output dropped)")));
-			else lines.push(fit(dim("output:")));
-			for (const line of textLines) lines.push(fit(line));
-		} else if (isRunActiveStatus(view.status) && !thinking) {
-			lines.push(fit(dim("(waiting for first output…)")));
-		}
-
-		// Recent tools.
-		if (view.tools.length > 0) {
-			lines.push(fit(dim("recent tools:")));
-			for (const tool of view.tools) {
-				const icon = tool.running ? theme.fg("accent", "●") : tool.isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
-				const summary = tool.summary ? dim(` ${clean(tool.summary)}`) : "";
-				lines.push(fit(`  ${icon} ${clean(tool.tool)}${summary}`));
-			}
-		}
-
-		// Append-only trajectory (current generation, most recent last).
-		if (view.trajectory.length > 0) {
-			const genLabel = view.generation !== undefined ? `gen ${view.generation} ` : "";
-			lines.push(fit(dim(`trajectory (${genLabel}latest ${view.trajectory.length} of ${view.trajectoryTotal}):`)));
-			for (const event of view.trajectory) {
-				lines.push(fit(`  ${dim(`${timeOf(event.at)} `)}${formatTrajectoryEvent(event)}`));
-			}
-		}
-		return lines;
-	}
-}
-
-function safeText(text: string): string {
-	return stripVTControlCharacters(text);
-}
-
-function oneLine(text: string): string {
-	return safeText(text).replace(/\s+/g, " ").trim();
-}
-
-/** Last `max` lines of a possibly multi-line, already collected stream. */
-function tailLines(text: string, max: number): string[] {
-	const lines = safeText(text).split("\n");
-	const tail = lines.slice(-max).map((line) => line.replace(/\s+$/, ""));
-	return tail;
-}
-
-function timeOf(at: number): string {
-	try {
-		const d = new Date(at);
-		return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
-	} catch {
-		return "--:--:--";
-	}
-}
-
-function padRight(line: string, width: number): string {
-	const visible = visibleWidth(line);
-	return visible >= width ? line : `${line}${" ".repeat(width - visible)}`;
-}
-
-function errorMessageText(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-export function registerInspectorCommand(pi: ExtensionAPI, runtime: SubagentRuntime): void {
-	pi.registerCommand("subagents-inspect", {
-		description:
-			"Open the live sub-agent inspector overlay: threads, streaming output, recent tools, and the append-only trajectory per run",
-		handler: async (_args, ctx) => {
-			if (ctx.mode !== "tui") {
-				ctx.ui.notify("/subagents-inspect requires Pi's interactive TUI.", "error");
-				return;
-			}
-			await ctx.ui.custom<undefined>(
-				(tui, theme, _keybindings, done) =>
-					new InspectorOverlay({
-						runtime,
-						tui,
-						theme,
-						done: () => done(undefined),
-						notify: (message) => {
-							try {
-								ctx.ui.notify(message, "warning");
-							} catch {
-								/* notification failures are non-fatal */
-							}
-						},
-					}),
-				{ overlay: true, overlayOptions: { width: "92%", maxHeight: "88%" } },
-			);
-		},
-	});
-}