pi-squire 0.20.1 → 0.20.2

package/src/widget-render.ts

@@ -1,7 +1,7 @@
 import { stripVTControlCharacters } from "node:util";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import type { AncestorRow } from "./widget-ancestors.ts";
+import type { Breadcrumb, WidgetIdentity } from "./widget-ancestors.ts";
 import type { DelegateRow } from "./widget-data.ts";
 
 export type WidgetTheme = Pick<Theme, "fg" | "bold">;
@@ -18,6 +18,15 @@ export function widgetText(value: string): string {
 		.slice(0, 2048);
 }
 
+export function widgetName(row: WidgetIdentity): string {
+	const prefix = row.agent ? `${row.agent}-` : "";
+	return widgetText(
+		prefix && row.identity.startsWith(prefix) && row.identity.length > prefix.length
+			? row.identity.slice(prefix.length)
+			: row.identity,
+	);
+}
+
 function age(timestamp: number, now: number): string {
 	const minutes: number = Math.floor(Math.max(0, now - timestamp) / 60_000);
 	if (minutes < 1) return "just now";
@@ -34,9 +43,9 @@ function appearance(row: DelegateRow): { icon: string; color: "accent" | "succes
 
 function metadata(row: DelegateRow, width: number, coreWidth: number, now: number): string {
 	const model: string = widgetText(row.model.split("/").slice(1).join("/") || row.model);
-	const seen: string = row.lastActive === undefined ? "" : `file ${age(row.lastActive, now)}`;
+	const seen: string = row.lastActive === undefined ? "" : `active ${age(row.lastActive, now)}`;
 	const columns: string[] = [seen, model].filter(Boolean);
-	// Remove model, then file-age, before sacrificing identity/state/title.
+	// Remove model, then active-age, before sacrificing identity/state/title.
 	while (columns.length && coreWidth + visibleWidth(` · ${columns.join(" · ")}`) > width) columns.pop();
 	return columns.length ? ` · ${columns.join(" · ")}` : "";
 }
@@ -44,48 +53,42 @@ function metadata(row: DelegateRow, width: number, coreWidth: number, now: numbe
 function entry(row: DelegateRow, width: number, connector: string, theme: WidgetTheme, now: number): string {
 	const { icon, color } = appearance(row);
 	const state: string = widgetText(row.state);
-	const name: string = widgetText(row.identity);
+	const name: string = widgetName(row);
 	if (width < 16) return truncateToWidth(`${theme.fg(color, icon)} ${theme.bold(name)}`, width);
 	const prefix: string = `${theme.fg("dim", connector)} ${theme.fg(color, icon)} `;
 	const suffix: string = ` · ${theme.fg(color, state)}`;
 	const title: string = widgetText(row.title ?? "");
 	const preferred: number = visibleWidth(prefix + name + suffix) + (title ? Math.min(24, visibleWidth(title)) + 2 : 0);
 	const extra: string = metadata(row, width, preferred, now);
-	const room: number = Math.max(1, width - visibleWidth(prefix + suffix + extra));
+	const count = !row.expanded && row.descendantCount ? theme.fg("dim", ` +${row.descendantCount}`) : "";
+	const room: number = Math.max(1, width - visibleWidth(prefix + suffix + extra + count));
 	const identity: string = truncateToWidth(name, room);
 	const titleRoom: number = room - visibleWidth(identity) - 2;
 	const description: string = title && title !== name && titleRoom >= 4 ? `  ${truncateToWidth(title, titleRoom)}` : "";
-	return truncateToWidth(`${prefix}${theme.bold(identity)}${description}${suffix}${theme.fg("dim", extra)}`, width);
+	return truncateToWidth(
+		`${prefix}${theme.bold(identity)}${description}${suffix}${theme.fg("dim", extra)}${count}`,
+		width,
+	);
 }
 
-/** One secondary line; descendant task counts take priority when both do not fit. */
-export function activityLine(
-	row: DelegateRow,
-	width: number,
-	last: boolean,
-	theme: WidgetTheme,
-	summary = "",
-): string | undefined {
-	const activity: string =
-		row.running && row.activity
-			? `${row.activity.kind === "response" ? "response: " : ""}${widgetText(row.activity.text)}`
-			: "";
-	const facts: string = widgetText(summary);
-	if (!activity && !facts) return;
+/** One secondary line for each running task. */
+export function activityLine(row: DelegateRow, width: number, last: boolean, theme: WidgetTheme): string | undefined {
+	if (!row.running) return;
 	const prefix: string = last ? "   └─ " : "│  └─ ";
-	let text: string = [activity, facts].filter(Boolean).join(" · ");
-	if (facts && visibleWidth(prefix + text) > width) text = facts;
-	return truncateToWidth(theme.fg("dim", prefix + text), width);
+	return truncateToWidth(theme.fg("dim", `${prefix}working...`), width);
 }
 
 export type WidgetRenderOptions = {
 	offset?: number;
 	selectedKey?: string;
 	focused?: boolean;
-	ancestors?: readonly AncestorRow[];
+	breadcrumb?: Breadcrumb;
 	ancestryError?: string;
 };
 
+// Unfocused rows keep the selection column so focusing the list never shifts the tree.
+const GUTTER = "  ";
+
 function selectableEntry(
 	row: DelegateRow,
 	width: number,
@@ -94,29 +97,34 @@ function selectableEntry(
 	now: number,
 	options: WidgetRenderOptions,
 ): string {
-	const gutter: string = options.focused ? "  " : "";
-	const marker: string = options.focused && row.key === options.selectedKey ? theme.fg("accent", "▸ ") : gutter;
+	const marker: string = options.focused && row.key === options.selectedKey ? theme.fg("accent", "▸ ") : GUTTER;
 	return marker + entry(row, width - visibleWidth(marker), last ? "└─" : "├─", theme, now);
 }
 
-function ancestorLines(ancestors: readonly AncestorRow[], options: WidgetRenderOptions, theme: WidgetTheme): string[] {
-	return ancestors.map((ancestor, index) => {
-		const gutter: string = options.focused ? "  " : "";
-		const marker: string = options.focused && ancestor.key === options.selectedKey ? theme.fg("accent", "▸ ") : gutter;
-		const connector: string = index ? `${"  ".repeat(index - 1)}└─ ` : "";
-		return (
-			marker +
-			connector +
-			"↑ " +
-			theme.bold(widgetText(ancestor.identity)) +
-			(ancestor.parent ? " (parent)" : "") +
-			(ancestor.title ? `  ${widgetText(ancestor.title)}` : "")
-		);
-	});
+function breadcrumbLine(
+	breadcrumb: Breadcrumb,
+	width: number,
+	options: WidgetRenderOptions,
+	theme: WidgetTheme,
+): string {
+	const marker = options.focused && breadcrumb.key === options.selectedKey ? theme.fg("accent", "▸ ") : GUTTER;
+	const names = breadcrumb.crumbs.map(widgetName);
+	const self = `${widgetName(breadcrumb.self)} (you)`;
+	let trail = [...names, self].join(" › ");
+	const room = Math.max(0, width - visibleWidth(marker));
+	if (visibleWidth(trail) > room && names.length > 2)
+		trail = [names[0], "…", names[names.length - 1], self].join(" › ");
+	const title = widgetText(breadcrumb.parentTitle ?? "");
+	const titleRoom = room - visibleWidth(trail) - 2;
+	return (
+		marker +
+		theme.bold(truncateToWidth(trail, room)) +
+		(title && titleRoom >= 4 ? `  ${truncateToWidth(title, titleRoom)}` : "")
+	);
 }
 
 function more(count: number): string {
-	return `${count} more direct delegate${count === 1 ? "" : "s"}`;
+	return `${count} more delegate${count === 1 ? "" : "s"}`;
 }
 
 function childLines(
@@ -127,31 +135,32 @@ function childLines(
 	now: number,
 	options: WidgetRenderOptions,
 ): string[] {
-	const depth: number = options.ancestors?.length ?? 0;
-	const indent: string = "  ".repeat(depth);
-	const gutter: string = options.focused ? "  " : "";
-	const branch: string = depth ? `${"  ".repeat(depth - 1)}└─ ` : "";
-	const lines: string[] = [gutter + branch + theme.fg("accent", theme.bold("Delegates"))];
+	const lines: string[] = options.breadcrumb ? [] : [GUTTER + theme.fg("accent", theme.bold("Delegates"))];
 	const start: number = Math.max(0, Math.min(options.offset ?? 0, rows.length - cap));
 	const visible: readonly DelegateRow[] = rows.slice(start, start + cap);
 	const hidden: number = rows.length - start - visible.length;
-	if (start) lines.push(gutter + indent + theme.fg("dim", `├─ ↑ ${more(start)}`));
+	if (start) lines.push(GUTTER + theme.fg("dim", `├─ ↑ ${more(start)}`));
 	for (const [index, row] of visible.entries()) {
 		const last: boolean = index === visible.length - 1 && hidden === 0;
-		lines.push(indent + selectableEntry(row, width - indent.length, last, theme, now, options));
-		const secondary: string | undefined = activityLine(
-			row,
-			width - gutter.length - indent.length,
-			last,
-			theme,
-			row.summary,
-		);
-		if (secondary) lines.push(gutter + indent + secondary);
+		const rowIndent = "  ".repeat(row.depth ?? 0);
+		lines.push(rowIndent + selectableEntry(row, width - rowIndent.length, last, theme, now, options));
+		const secondary: string | undefined = activityLine(row, width - GUTTER.length - rowIndent.length, last, theme);
+		if (secondary) lines.push(GUTTER + rowIndent + secondary);
 	}
-	if (hidden) lines.push(gutter + indent + theme.fg("dim", `└─ +${more(hidden)}`));
+	if (hidden) lines.push(GUTTER + theme.fg("dim", `└─ +${more(hidden)}`));
 	return lines;
 }
 
+function focusedHint(rows: readonly DelegateRow[], options: WidgetRenderOptions): string {
+	if (options.breadcrumb && options.breadcrumb.key === options.selectedKey)
+		return "↑↓ select · enter parent · esc prompt";
+	const selected = rows.find((row) => row.key === options.selectedKey);
+	let treeHint = "";
+	if (selected?.descendantCount) treeHint = selected.expanded ? " · ← collapse" : " · → expand";
+	if (!selected?.expanded && selected?.depth) treeHint += " · ← parent";
+	return `↑↓ select · enter open · x close${treeHint} · esc prompt`;
+}
+
 /** Pure layout: the cap counts child entries, not physical lines or hidden children. */
 export function renderDelegateWidget(
 	rows: readonly DelegateRow[],
@@ -162,20 +171,12 @@ export function renderDelegateWidget(
 	options: WidgetRenderOptions = {},
 ): string[] {
 	if (width <= 0) return [];
-	const ancestors: readonly AncestorRow[] = options.ancestors ?? [];
-	if (!ancestors.length && (cap === 0 || !rows.length) && !options.ancestryError) return [];
-	const gutter: string = options.focused ? "  " : "";
-	const lines: string[] = ancestorLines(ancestors, options, theme);
-	if (options.ancestryError) lines.push(gutter + theme.fg("warning", widgetText(options.ancestryError)));
+	const breadcrumb = options.breadcrumb;
+	if (!breadcrumb && (cap === 0 || !rows.length) && !options.ancestryError) return [];
+	const lines: string[] = breadcrumb ? [breadcrumbLine(breadcrumb, width, options, theme)] : [];
+	if (options.ancestryError) lines.push(GUTTER + theme.fg("warning", widgetText(options.ancestryError)));
 	if (cap > 0 && rows.length) lines.push(...childLines(rows, cap, width, theme, now, options));
-	if (options.focused)
-		lines.push(
-			theme.fg(
-				"dim",
-				ancestors.some((ancestor) => ancestor.key === options.selectedKey)
-					? "↑↓ select · enter switch · esc prompt"
-					: "↑↓ select · enter details · esc prompt",
-			),
-		);
+	if (options.focused) lines.push(theme.fg("dim", focusedHint(rows, options)));
+	else lines.push(theme.fg("dim", "↓ to manage delegates"));
 	return lines.map((line) => truncateToWidth(line, width));
 }

package/src/widget-selection.ts

@@ -1,11 +1,12 @@
 /** Compact-list state only. Stable keys never confer action authority. */
 export class WidgetSelection {
 	private keys: readonly string[] = [];
-	private ancestors = 0;
+	private breadcrumb = 0;
 	private cap = 0;
 	private index = 0;
 	private start = 0;
 	active = false;
+	readonly expanded = new Set<string>();
 
 	get selectedKey(): string | undefined {
 		return this.keys[this.index];
@@ -14,11 +15,11 @@ export class WidgetSelection {
 		return this.start;
 	}
 
-	update(children: readonly string[], cap: number, ancestors: readonly string[] = []): void {
+	update(children: readonly string[], cap: number, breadcrumbKey?: string): void {
 		const selected: string | undefined = this.selectedKey;
-		const keys: readonly string[] = [...ancestors, ...(cap > 0 ? children : [])];
+		const keys: readonly string[] = [...(breadcrumbKey ? [breadcrumbKey] : []), ...(cap > 0 ? children : [])];
 		this.keys = keys;
-		this.ancestors = ancestors.length;
+		this.breadcrumb = breadcrumbKey ? 1 : 0;
 		this.cap = cap;
 		const retained: number = selected === undefined ? -1 : keys.indexOf(selected);
 		this.index = retained >= 0 ? retained : Math.max(0, Math.min(this.index, keys.length - 1));
@@ -29,12 +30,20 @@ export class WidgetSelection {
 	enter(): boolean {
 		if (!this.keys.length) return false;
 		this.active = true;
-		this.index = Math.max(0, this.ancestors - 1);
+		this.index = 0;
 		this.scroll();
 		return true;
 	}
 
+	select(key: string): void {
+		const index = this.keys.indexOf(key);
+		if (index < 0) return;
+		this.index = index;
+		this.scroll();
+	}
+
 	leave(): void {
+		this.expanded.clear();
 		this.active = false;
 		this.start = 0;
 	}
@@ -46,13 +55,13 @@ export class WidgetSelection {
 	}
 
 	private scroll(): void {
-		const child: number = this.index - this.ancestors;
+		const child: number = this.index - this.breadcrumb;
 		if (!this.active || child < 0 || this.cap === 0) {
 			this.start = 0;
 			return;
 		}
 		if (child < this.start) this.start = child;
 		if (child >= this.start + this.cap) this.start = child - this.cap + 1;
-		this.start = Math.max(0, Math.min(this.start, this.keys.length - this.ancestors - this.cap));
+		this.start = Math.max(0, Math.min(this.start, this.keys.length - this.breadcrumb - this.cap));
 	}
 }

package/src/widget.ts

@@ -1,33 +1,35 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Results } from "./results.ts";
-import type { TmuxClient, TmuxWindow } from "./tmux.ts";
-import { type VisibleFacts, visibleRecordFacts } from "./tree-view.ts";
+import { isStarted, type Recorded, type Results, type StartedRecorded } from "./results.ts";
+import type { TmuxClient } from "./tmux.ts";
+import { readTreeDisplay } from "./tree-registry.ts";
+import { visibleRecordFacts } from "./tree-view.ts";
 import { joinActivities } from "./widget-activity-join.ts";
-import { type AncestorRow, AncestorView, switchAncestor } from "./widget-ancestors.ts";
+import { type Breadcrumb, BreadcrumbView, switchAncestor } from "./widget-ancestors.ts";
 import { currentChildWindows } from "./widget-current.ts";
-import { type DelegateRow, DirectDelegateView, type MetadataViewport } from "./widget-data.ts";
+import { type DelegateRow, DirectDelegateView, delegateTree } from "./widget-data.ts";
 import { WidgetFocus } from "./widget-focus.ts";
 import { LiveActivityReader } from "./widget-live.ts";
 import { renderDelegateWidget } from "./widget-render.ts";
 import { WidgetSelection } from "./widget-selection.ts";
 import { DEFAULT_WIDGET_SETTINGS, type WidgetSettings, widgetSettings } from "./widget-settings.ts";
-import { taskSummary } from "./widget-summary.ts";
 import { titlePublisher } from "./widget-title.ts";
-import { listWindows } from "./windows.ts";
+import { listPanes } from "./windows.ts";
 
 export const DELEGATE_WIDGET_KEY = "squire-delegates";
 export const WIDGET_REFRESH_MS = 1000;
-type OpenDashboard = (ctx: ExtensionContext, sessionId: string) => Promise<void>;
+type OpenDelegate = (ctx: ExtensionContext, id: string) => Promise<void>;
 
 /** Observation and UI only; direct Results/task authority and the configured editor/footer stay untouched. */
 class Overview {
 	private readonly results: Results;
 	private readonly tmux: TmuxClient;
 	private readonly view = new DirectDelegateView();
-	private readonly ancestorView = new AncestorView();
+	private readonly breadcrumbView = new BreadcrumbView();
 	private readonly live = new LiveActivityReader();
-	private ancestors: AncestorRow[] = [];
+	private breadcrumb: Breadcrumb | undefined;
 	private ancestryError = "";
+	private breadcrumbRevision = -1;
+	private breadcrumbReadAt = 0;
 	private readonly ctx: ExtensionContext;
 	private readonly selection = new WidgetSelection();
 	private readonly focus: WidgetFocus;
@@ -43,13 +45,15 @@ class Overview {
 	private factsRevision = 0;
 	private layoutRevision = 0;
 	private rows: DelegateRow[] = [];
+	private allRows: DelegateRow[] = [];
 	private configuration: WidgetSettings = { ...DEFAULT_WIDGET_SETTINGS };
 
 	constructor(
 		results: Results,
 		tmux: TmuxClient,
 		ctx: ExtensionContext,
-		open: OpenDashboard,
+		open: OpenDelegate,
+		close: OpenDelegate,
 		assertActive: () => void,
 	) {
 		this.results = results;
@@ -61,10 +65,31 @@ class Overview {
 			changed: (): void => this.changed(),
 			open: async (key: string): Promise<void> => {
 				assertActive();
-				const ancestor: AncestorRow | undefined = this.ancestors.find((row) => row.key === key);
-				if (ancestor) return switchAncestor(ctx, ancestor.sessionId, tmux, assertActive, this.live);
-				if (!this.rows.some((row) => row.key === key)) throw new Error("delegate is no longer visible");
-				await open(ctx, key);
+				if (this.breadcrumb?.key === key)
+					return switchAncestor(ctx, this.breadcrumb.parentSessionId, tmux, assertActive, this.live);
+				const row = this.rows.find((row) => row.key === key);
+				if (!row) throw new Error("delegate is no longer visible");
+				await open(ctx, row.launchId);
+			},
+			close: async (key: string): Promise<void> => {
+				assertActive();
+				if (this.breadcrumb?.key === key) return ctx.ui.notify("delegate: cannot close an ancestor", "warning");
+				const row = this.rows.find((row) => row.key === key);
+				if (!row) throw new Error("delegate is no longer visible");
+				await close(ctx, row.launchId);
+			},
+			horizontal: (direction: -1 | 1): void => {
+				const row = this.rows.find((candidate) => candidate.key === this.selection.selectedKey);
+				if (!row) return;
+				const expanded = this.selection.expanded;
+				if (direction === -1) {
+					if (!expanded.delete(row.key) && row.parentKey) this.selection.select(row.parentKey);
+					return;
+				}
+				if (!row.descendantCount) return;
+				if (!expanded.has(row.key)) return void expanded.add(row.key);
+				const child = this.rows.find((candidate) => candidate.parentKey === row.key);
+				if (child) this.selection.select(child.key);
 			},
 			error: (error: unknown): void =>
 				ctx.ui.notify(`delegate: ${error instanceof Error ? error.message : String(error)}`, "error"),
@@ -95,14 +120,16 @@ class Overview {
 		this.unsubscribe?.();
 		this.focus.stop();
 		this.view.clear();
-		this.ancestorView.clear();
+		this.breadcrumbView.clear();
 		this.ctx.ui.setWidget(DELEGATE_WIDGET_KEY, undefined);
 	}
 
 	private changed(): void {
 		if (this.stopped) return;
 		this.layoutRevision++;
-		this.show(this.rows, this.configuration);
+		const rows = this.treeRows(this.allRows);
+		this.updateSelection(rows, this.configuration);
+		this.show(rows, this.configuration);
 		this.queue();
 	}
 
@@ -138,26 +165,29 @@ class Overview {
 		});
 	}
 
-	private async readAncestors(): Promise<void> {
+	private async readBreadcrumb(): Promise<void> {
+		if (this.breadcrumbRevision === this.factsRevision && Date.now() - this.breadcrumbReadAt < 30_000) return;
+		this.breadcrumbRevision = this.factsRevision;
+		this.breadcrumbReadAt = Date.now();
 		try {
-			this.ancestors = await this.ancestorView.read(this.ctx, this.live);
+			this.breadcrumb = await this.breadcrumbView.read(this.ctx, this.live);
 			this.ancestryError = "";
 		} catch {
-			this.ancestors = [];
+			this.breadcrumb = undefined;
 			this.ancestryError = "Ancestor information unavailable";
 		}
 	}
 
-	private summarize(rows: DelegateRow[], viewport: MetadataViewport, windows: TmuxWindow[] | undefined): void {
-		const visible: DelegateRow[] = rows.slice(viewport.offset, viewport.offset + viewport.limit);
-		if (!visible.length) return;
-		try {
-			const facts: VisibleFacts = visibleRecordFacts(this.results, this.ctx, 20, false);
-			for (const row of visible) row.summary = taskSummary(facts, row.sessionId, windows);
-		} catch {
-			// Optional descendant facts must not freeze fresh ancestors or direct-child state.
-			for (const row of visible) row.summary = "tasks: coverage unavailable";
-		}
+	private treeRows(rows: DelegateRow[]): DelegateRow[] {
+		return delegateTree(rows, this.ctx.sessionManager.getSessionId(), this.selection.expanded);
+	}
+
+	private updateSelection(rows: DelegateRow[], settings: WidgetSettings): void {
+		this.selection.update(
+			rows.map((row) => row.key),
+			settings.maxEntries,
+			this.breadcrumb?.key,
+		);
 	}
 
 	private async refresh(): Promise<void> {
@@ -166,33 +196,43 @@ class Overview {
 		try {
 			const settings: WidgetSettings = this.settings();
 			this.configureCount(settings.maxEntries === 0);
-			const windows =
-				settings.maxEntries > 0 && this.view.needsWindows(this.results) ? await listWindows(this.tmux) : [];
+			let observed: Results = this.results;
+			if (settings.maxEntries > 0) {
+				try {
+					const records = visibleRecordFacts(this.results, this.ctx, 20, false, readTreeDisplay).records;
+					observed = {
+						...this.results,
+						list: (): Recorded[] => records,
+						running: (): StartedRecorded[] =>
+							records
+								.filter(isStarted)
+								.filter((record) => !record.closed && !record.result && !record.gone && !record.accountingOnly),
+					};
+				} catch {}
+			}
+			const listing =
+				settings.maxEntries > 0 && this.view.needsWindows(observed) ? await listPanes(this.tmux) : undefined;
+			const windows = listing?.windows;
 			if (this.stopped || revision !== this.factsRevision) return;
 			const sessionDir: string = this.ctx.sessionManager.getSessionDir();
-			const current = await currentChildWindows(this.results, this.tmux, windows, this.live);
-			await this.readAncestors();
+			const current = await currentChildWindows(observed, listing, this.live);
+			await this.readBreadcrumb();
 			if (this.stopped || revision !== this.factsRevision) return;
-			const eligible: DelegateRow[] = this.view.read(
-				this.results,
-				windows,
-				sessionDir,
-				{ offset: 0, limit: 0 },
-				current,
-			);
-			this.selection.update(
-				eligible.map((row) => row.key),
-				settings.maxEntries,
-				this.ancestors.map((row) => row.key),
-			);
+			const eligible: DelegateRow[] = this.view.read(observed, windows, sessionDir, { offset: 0, limit: 0 }, current);
+			const projected = this.treeRows(eligible);
+			this.updateSelection(projected, settings);
 			const viewport = { offset: this.selection.offset, limit: settings.maxEntries };
 			const layout: number = this.layoutRevision;
-			const rows: DelegateRow[] = this.view.read(this.results, windows, sessionDir, viewport, current);
-			this.summarize(rows, viewport, windows);
-			await joinActivities(rows, viewport, this.results);
+			const visibleKeys = new Set(
+				projected.slice(viewport.offset, viewport.offset + viewport.limit).map((row) => row.key),
+			);
+			const allRows = this.view.read(observed, windows, sessionDir, viewport, current, visibleKeys);
+			const rows = this.treeRows(allRows);
+			await joinActivities(rows, viewport, observed);
 			// Only Results notifications change factsRevision; timer ticks must not
 			// starve a read, and selection changes must discard/requeue its old viewport.
 			if (this.stopped || revision !== this.factsRevision || layout !== this.layoutRevision) return;
+			this.allRows = allRows;
 			this.show(rows, settings);
 		} catch {
 			// Optional metadata/UI failures cannot interrupt launch, poll or result processing.
@@ -212,13 +252,13 @@ class Overview {
 			offset: this.selection.offset,
 			selectedKey: this.selection.selectedKey,
 			focused: this.focus.focused,
-			ancestors: this.ancestors,
+			breadcrumb: this.breadcrumb,
 			ancestryError: this.ancestryError,
 		};
 		const signature: string = JSON.stringify([rows, settings, options, Math.floor(Date.now() / 60_000)]);
 		if (signature === this.signature) return;
 		this.signature = signature;
-		if (!this.ancestors.length && !this.ancestryError && (!rows.length || !settings.maxEntries)) {
+		if (!this.breadcrumb && !this.ancestryError && (!rows.length || !settings.maxEntries)) {
 			this.ctx.ui.setWidget(DELEGATE_WIDGET_KEY, undefined);
 			return;
 		}
@@ -245,7 +285,8 @@ export function registerDelegateWidget(
 	pi: ExtensionAPI,
 	results: Results,
 	tmux: TmuxClient,
-	open: OpenDashboard,
+	open: OpenDelegate,
+	close: OpenDelegate,
 	assertActive: () => void,
 ): void {
 	let overview: Overview | undefined;
@@ -261,7 +302,7 @@ export function registerDelegateWidget(
 		publisher = titlePublisher(ctx.sessionManager.getSessionId());
 		publisher.publish(pi.getSessionName());
 		if (ctx.hasUI && ctx.mode === "tui") {
-			overview = new Overview(results, tmux, ctx, open, assertActive);
+			overview = new Overview(results, tmux, ctx, open, close, assertActive);
 			overview.start();
 		}
 	});

package/src/windows.ts

@@ -1,6 +1,6 @@
 // Reading tmux's window list against the delegation records.
 import type { StartedRecorded, WindowState } from "./results.ts";
-import type { TmuxClient, TmuxWindow } from "./tmux.ts";
+import type { PaneListing, TmuxClient, TmuxWindow } from "./tmux.ts";
 
 /** Every window on the server, asked once; a failed ask is `undefined`, never an empty list. */
 export async function listWindows(tmux: TmuxClient): Promise<TmuxWindow[] | undefined> {
@@ -11,6 +11,14 @@ export async function listWindows(tmux: TmuxClient): Promise<TmuxWindow[] | unde
 	}
 }
 
+export async function listPanes(tmux: TmuxClient): Promise<PaneListing | undefined> {
+	try {
+		return await tmux.listPanes();
+	} catch {
+		return undefined;
+	}
+}
+
 /** The window a delegation owns: one with both its recorded id and its recorded name, since ids restart with every tmux server. */
 export function ownWindow(windows: TmuxWindow[], record: StartedRecorded): TmuxWindow | undefined {
 	return windows.find((window) => window.id === record.windowId && window.name === record.windowName);