pi-squire 0.20.0 → 0.20.2

package/src/index.ts

@@ -758,10 +758,11 @@ export default function delegate(
 		pi,
 		results,
 		tmux,
-		async (ctx, sessionId) => {
+		async (ctx, id) => {
 			owner.assert();
-			await navigator.panel(ctx, sessionId);
+			await navigator.openDelegate(ctx, id, "switch");
 		},
+		(ctx, id) => navigator.closeDelegate(ctx, id),
 		() => owner.assert(),
 	);
 
@@ -1449,7 +1450,7 @@ export default function delegate(
 		}
 	}
 
-	/** What the new-delegate form needs, shared by `/delegate` and the panel's `n`. */
+	/** What the no-argument `/delegate` form needs. */
 	const newDelegateDeps: NewDelegateDeps = {
 		unavailable: () => (tmux.insideTmux() ? undefined : NOT_IN_TMUX),
 		roster: rosterFor,
@@ -1703,26 +1704,9 @@ export default function delegate(
 		handler: resumeCommand,
 	});
 
-	const navigator = createNavigator(
-		viewResults,
-		tmux,
-		tracking,
-		(ctx: ExtensionContext) => startNewDelegate(ctx, newDelegateDeps),
-		{
-			assertActive: () => owner.assert(),
-			close: (id, ctx) => tracking.close(id, ctx),
-			resume: (id, ctx) => resumePicker(ctx, id),
-		},
-	);
-
-	pi.registerCommand("delegates", {
-		description: "Open the shared delegate dashboard: details, switch, peek, close, resume",
-		handler: async (_args: string, ctx: ExtensionContext) => navigator.panel(ctx),
-	});
-
-	pi.registerShortcut("alt+shift+d", {
-		description: "Open the delegates panel",
-		handler: (ctx: ExtensionContext) => navigator.panel(ctx),
+	const navigator = createNavigator(viewResults, tmux, tracking, {
+		assertActive: () => owner.assert(),
+		close: (id, ctx) => tracking.close(id, ctx),
 	});
 
 	pi.registerCommand("delegate-open", {

package/src/navigator-view.ts

@@ -1,10 +1,8 @@
-// Read-only dashboard/navigation projection. Never supplies locators to close or task accounting.
-import type { DashboardRow } from "./dashboard.ts";
+// Read-only navigation projection. Never supplies locators to close or task accounting.
 import {
 	type DelegationState,
 	deriveState,
 	isStarted,
-	locateSession,
 	type Results,
 	recordedName,
 	type StartedRecorded,
@@ -13,42 +11,18 @@ import {
 import type { TmuxClient, TmuxWindow } from "./tmux.ts";
 import { verifyLiveWindow } from "./widget-ancestors.ts";
 import { LiveActivityReader, type LiveLocator } from "./widget-live.ts";
-import { WidgetTitleMirrors } from "./widget-title.ts";
-import { WidgetTitleFiles } from "./widget-title-file.ts";
 import { listWindows, ownWindow } from "./windows.ts";
 
 export type OpenDelegate = {
 	id: string;
 	name: string;
-	title?: string;
-	agent: string;
 	state: DelegationState;
 	window: TmuxWindow;
 	navigable: boolean;
 	live?: LiveLocator;
 	record: StartedRecorded;
-	resumedAs?: string;
 };
 
-/** Membership uses scoped records' session edges, never names, placement or a new tree index. */
-export function branchItems(items: OpenDelegate[], target: string | undefined): OpenDelegate[] {
-	if (target === undefined) return items;
-	const sessions: Set<string> = new Set([target]);
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const item of items) {
-			const parent: string | undefined = item.record.identity?.parent;
-			const session: string = sessionIdOf(item.record);
-			if (parent && sessions.has(parent) && !sessions.has(session)) {
-				sessions.add(session);
-				changed = true;
-			}
-		}
-	}
-	return items.filter((item) => sessions.has(sessionIdOf(item.record)));
-}
-
 function openItem(item: OpenDelegate): boolean {
 	if (!item.navigable || item.record.closed || item.record.accountingOnly) return false;
 	return (
@@ -67,8 +41,6 @@ export class NavigatorView {
 	private readonly results: Results;
 	private readonly tmux: TmuxClient;
 	private readonly reader: Pick<LiveActivityReader, "locator">;
-	private readonly titles: WidgetTitleFiles = new WidgetTitleFiles();
-	private readonly mirrors: WidgetTitleMirrors = new WidgetTitleMirrors();
 	// Once positively observed, a disappearing/replaced current runtime must not fall back to its old window.
 	private readonly current: Set<string> = new Set();
 
@@ -82,19 +54,16 @@ export class NavigatorView {
 		this.reader = reader;
 	}
 
-	async items(history = false): Promise<OpenDelegate[] | undefined> {
+	async items(): Promise<OpenDelegate[] | undefined> {
 		const windows: TmuxWindow[] | undefined = await listWindows(this.tmux);
-		if (!windows && !history) return undefined;
+		if (!windows) return undefined;
 		const all: StartedRecorded[] = this.results.list().filter(isStarted);
 		const latest: Map<string, string> = new Map(all.map((record) => [sessionIdOf(record), record.id]));
 		const items: OpenDelegate[] = await Promise.all(
 			all.map(async (record): Promise<OpenDelegate> => {
-				const item: OpenDelegate = await this.item(record, latest.get(sessionIdOf(record)) === record.id, windows);
-				item.resumedAs = all.find((next) => next.resumedFrom === record.id)?.id;
-				return item;
+				return this.item(record, latest.get(sessionIdOf(record)) === record.id, windows);
 			}),
 		);
-		if (history) return items;
 		return items.filter(openItem).reverse();
 	}
 
@@ -110,16 +79,11 @@ export class NavigatorView {
 		const window: TmuxWindow | undefined = this.current.has(record.id)
 			? await this.liveWindow(live, windows)
 			: historical;
-		const path: string | undefined = live?.sessionFile ?? locateSession({ ...record }, undefined);
-		const title: string | undefined =
-			this.titles.read(path, sessionIdOf(record))?.name ?? this.mirrors.read(sessionIdOf(record));
 		let state: import("./results.ts").WindowState = "unknown";
 		if (windows) state = historical && !historical.exited ? "open" : "gone";
 		return {
 			id: record.id,
 			name: recordedName(record),
-			title,
-			agent: record.displayName ?? record.agent,
 			state: deriveState(record, state),
 			record,
 			live,
@@ -132,9 +96,11 @@ export class NavigatorView {
 		live: LiveLocator | undefined,
 		windows: TmuxWindow[] | undefined,
 	): Promise<TmuxWindow | undefined> {
-		if (!live || !windows || !(await verifyLiveWindow(this.tmux, live).catch(() => false))) return undefined;
+		if (!live || !windows) return undefined;
+		const pane = await verifyLiveWindow(this.tmux, live).catch(() => undefined);
+		if (!pane) return undefined;
 		const found: TmuxWindow | undefined = windows.find(
-			(entry) => entry.id === live.locator.windowId && entry.name === live.locator.windowName,
+			(entry) => entry.id === pane.windowId && entry.name === pane.windowName,
 		);
 		// Exact Pi pane, not a different active pane's pane_dead.
 		return found ? { ...found, exited: false } : undefined;
@@ -152,36 +118,3 @@ export class NavigatorView {
 		return JSON.stringify(final) === JSON.stringify(current.live);
 	}
 }
-
-function detailLines(item: OpenDelegate): string[] {
-	const record: StartedRecorded = item.record;
-	return [
-		`delegation: ${record.id} · session: ${sessionIdOf(record)}`,
-		`parent: ${record.identity?.parent ?? "this session"} · root: ${record.identity?.root ?? "this session"} · depth: ${record.identity?.depth ?? 1}`,
-		`title: ${item.title ?? "not set"}`,
-		`launch window: ${record.windowName} (${record.windowId})`,
-		`current verified window: ${item.navigable ? `${item.window.name} (${item.window.id}) in ${item.window.session}` : "unavailable"}`,
-		`cwd: ${record.cwd ?? "unknown"} · workspace: ${record.workspace?.cwd ?? "none recorded"}`,
-		`session file: ${item.live?.sessionFile ?? locateSession({ ...record }, undefined) ?? "not found"}`,
-		`session directory: ${record.sessionDir ?? "not recorded"}`,
-		`result: ${record.result?.status ?? "none received"} · envelope: ${record.result?.envelopePath ?? "none"}`,
-		...(record.forkedFrom === undefined ? [] : [`forked from: ${record.forkedFrom}`]),
-		`resumed from: ${record.resumedFrom ?? "none"} · resumed as: ${item.resumedAs ?? "none"} · auto-exit: ${record.autoExit === true ? "on" : "off"}`,
-		`model: ${record.model} · thinking: ${record.thinking}`,
-	];
-}
-
-export function dashboardRows(items: readonly OpenDelegate[]): DashboardRow[] {
-	const baseDepth: number = Math.min(...items.map((item) => item.record.identity?.depth ?? 1));
-	return items.map((item): DashboardRow => {
-		const where: string = item.navigable ? `${item.window.id} in ${item.window.session}` : "window unavailable";
-		const title: string = item.title && item.title !== item.name ? ` · ${item.title}` : "";
-		const outcome: string = item.record.result ? ` (${item.record.result.status})` : "";
-		return {
-			id: item.id,
-			label: `${item.name}${title} · ${item.agent} · ${item.state}${outcome} · ${where}`,
-			depth: Math.max(0, (item.record.identity?.depth ?? 1) - baseDepth),
-			details: detailLines(item),
-		};
-	});
-}

package/src/navigator.ts

@@ -1,33 +1,22 @@
-// The delegate navigator: the `/delegates` panel and `/delegate-open`. It lists
-// the descendant hierarchy, retains history and reaches a verified open window: a switch of
-// the user's tmux client to its window, a peek at the pane, or a close. Everything here is a command or a key; the model gets no tool that
-// moves the user's terminal.
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Component, isKeyRelease, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import { Dashboard, type DashboardIntent, type DashboardPosition } from "./dashboard.ts";
-import { readIdentity } from "./identity.ts";
-import { branchItems, dashboardRows, NavigatorView, type OpenDelegate } from "./navigator-view.ts";
-
-import { type Results, sessionIdOf } from "./results.ts";
+import { NavigatorView, type OpenDelegate } from "./navigator-view.ts";
+import { isStarted, type Results, recordedName } from "./results.ts";
 import type { TmuxClient } from "./tmux.ts";
 import type { Tracking } from "./tracking.ts";
-import { descendants, readTree } from "./tree-registry.ts";
 
-/** What `/delegate-open` does; dashboard Enter opens details before switching. */
+/** What `/delegate-open` does with a verified window. */
 export type OpenMode = "switch" | "peek";
 
 export const OPEN_USAGE = "/delegate-open <id> [--switch|--peek]";
 const OPEN_FLAGS = ["--switch", "--peek"] as const;
 
-/** What the panel hands back: the action the user chose on one delegation, or none. */
-type PanelResult = DashboardIntent;
-
 /** What the peek hands back: switch to the delegate, or nothing. */
 type PeekResult = { action: "switch" } | undefined;
 
 const PEEK_HINT = "r refresh · enter switch · esc back";
 
-/** Where a peek shows: over the panel or the editor, not in its place. */
+/** A peek overlays the editor without replacing it. */
 const PEEK_OPTIONS = { overlay: true, overlayOptions: { width: "90%", maxHeight: "90%", anchor: "center" } } as const;
 
 type PanelTheme = { fg(color: string, text: string): string; bold(text: string): string };
@@ -105,10 +94,9 @@ class PeekView implements Component {
 
 /** What `src/index.ts` needs from the navigator. */
 export type Navigator = {
-	/** The panel, looping back after a close. */
-	panel(ctx: ExtensionContext, targetSessionId?: string): Promise<void>;
 	/** One action on one open delegation, for `/delegate-open`. */
 	openDelegate(ctx: ExtensionContext, id: string, mode: OpenMode): Promise<void>;
+	closeDelegate(ctx: ExtensionContext, id: string): Promise<void>;
 	/** Ids of the delegations whose window is open, for completions. */
 	openIds(): Promise<string[]>;
 };
@@ -138,19 +126,18 @@ export function openCompletions(prefix: string, ids: readonly string[]): { value
 	return hits.length > 0 ? hits.map((value) => ({ value: head + value, label: value })) : null;
 }
 
-/** Context-bearing action seam; presentation never owns close/resume scope or result wording. */
+/** Context-bearing action seam; presentation never owns close scope or result wording. */
 export type NavigatorActions = {
 	assertActive(): void;
 	close(
 		id: string,
 		ctx: ExtensionContext,
 	): Promise<{ text: string; isError?: boolean; details?: { complete: boolean } }>;
-	resume(id: string, ctx: ExtensionContext): Promise<void>;
 };
 type Env = {
 	results: Results;
 	tmux: TmuxClient;
-	tracking: Pick<Tracking, "close" | "closeAll">;
+	tracking: Pick<Tracking, "close">;
 	actions: Partial<NavigatorActions>;
 	view: NavigatorView;
 };
@@ -212,27 +199,20 @@ async function switchTo(env: Env, ctx: ExtensionContext, item: OpenDelegate): Pr
 	);
 }
 
-function runningDescendants(item: OpenDelegate): boolean {
-	if (!item.record.identity) return false;
-	try {
-		return descendants(readTree(item.record.identity.root), sessionIdOf(item.record)).some(
-			(entry) => !entry.closed && !entry.finished && entry.phase !== "not-started",
-		);
-	} catch {
-		return true; // Unavailable descendant state is not proof that closing is harmless.
-	}
-}
-
-/** Close through the shared control path, confirming running/unknown descendant work. */
-async function close(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<void> {
-	if (item.state === "running" || (item.navigable && item.live !== undefined) || runningDescendants(item)) {
-		const reason: string = item.state === "running" ? "is still running" : "may have live or unfinished work";
-		const message = `${item.name} ${reason}. Close its entire recorded subtree and kill only verified shared-control windows? Reattached navigation windows may remain open.`;
-		if (!(await ctx.ui.confirm("Close delegate", message))) return;
-	}
+async function close(env: Env, ctx: ExtensionContext, id: string): Promise<void> {
+	env.actions.assertActive?.();
+	const record = env.results.find(id);
+	if (!record || !isStarted(record))
+		return ctx.ui.notify("delegate: selected delegate is no longer available", "warning");
+	const name = recordedName(record);
+	const running = record.result || record.closed || record.gone ? "" : `${name} is still running. `;
+	if (
+		!(await ctx.ui.confirm("Close delegate", `${running}Close ${name} and its delegates? Worktrees and branches stay.`))
+	)
+		return;
 	try {
 		env.actions.assertActive?.();
-		const result = await (env.actions.close?.(item.id, ctx) ?? env.tracking.close(item.id, ctx));
+		const result = await (env.actions.close?.(id, ctx) ?? env.tracking.close(id, ctx));
 		env.actions.assertActive?.();
 		ctx.ui.notify(
 			`delegate: ${result.text}`,
@@ -243,30 +223,6 @@ async function close(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promi
 	}
 }
 
-/** Both entry points use this exact dashboard, differing only in initial focus/back destination. */
-function show(
-	ctx: ExtensionContext,
-	items: readonly OpenDelegate[],
-	position: DashboardPosition,
-	branch: string | undefined,
-): Promise<PanelResult> {
-	return ctx.ui.custom<PanelResult>(
-		(tui, theme, _keybindings, done) =>
-			new Dashboard({
-				items: dashboardRows(items),
-				root: readIdentity(ctx.sessionManager.getSessionId()) === undefined,
-				position,
-				detailBack: branch === undefined ? "list" : "exit",
-				branch,
-				theme,
-				done,
-				redraw: () => tui.requestRender(),
-				rows: () => tui.terminal.rows,
-			}),
-		{ blocked: { kind: "question", message: "Choose a delegate action" } },
-	);
-}
-
 /** Peek at a delegate's pane in an overlay; true when the user chose to switch to it. */
 async function peek(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<boolean> {
 	const result = await ctx.ui.custom<PeekResult>(
@@ -290,66 +246,6 @@ async function peek(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promis
 const noUi = (ctx: ExtensionContext): void => ctx.ui.notify("delegate: this needs an interactive session", "error");
 const noTmux = (ctx: ExtensionContext): void => ctx.ui.notify("delegate: could not ask tmux for its windows", "error");
 
-async function closeAll(env: Env, ctx: ExtensionContext): Promise<void> {
-	if (
-		!(await ctx.ui.confirm(
-			"Close all delegate subtrees",
-			"Close every recorded descendant of this root? Worktrees and branches are retained.",
-		))
-	)
-		return;
-	try {
-		env.actions.assertActive?.();
-		const closed = await env.tracking.closeAll(ctx);
-		env.actions.assertActive?.();
-		ctx.ui.notify(`delegate: ${closed.text}`, closed.details.complete ? "info" : "error");
-	} catch (error) {
-		ctx.ui.notify(`delegate: ${String(error)}`, "error");
-	}
-}
-
-/** Carry out what the panel returned; true when the panel should open again. */
-async function act(
-	env: Env,
-	startNew: (ctx: ExtensionContext) => Promise<void> | void,
-	ctx: ExtensionContext,
-	items: OpenDelegate[],
-	result: PanelResult,
-): Promise<boolean> {
-	if (result === undefined) return false;
-	env.actions.assertActive?.();
-	if (result.action === "new") {
-		await startNew(ctx);
-		return false;
-	}
-	if (result.action === "close-all") {
-		await closeAll(env, ctx);
-		return true;
-	}
-	const item = items.find((candidate) => candidate.id === result.id);
-	if (item === undefined) return false;
-	if (result.action === "resume") {
-		if (env.actions.resume) await env.actions.resume(item.id, ctx);
-		else ctx.ui.notify("delegate: resume is unavailable in this dashboard", "warning");
-		return true;
-	}
-	if (result.action === "close") {
-		await close(env, ctx, item);
-		return true;
-	}
-	if (result.action === "peek") {
-		if (!item.navigable) {
-			ctx.ui.notify("delegate: no verified open window to peek", "warning");
-			return true;
-		}
-		if (!(await peek(env, ctx, item))) return true; // back to the panel
-		await switchTo(env, ctx, item);
-		return false;
-	}
-	await switchTo(env, ctx, item);
-	return false;
-}
-
 /** One action on one open delegate, as `/delegate-open` runs it. */
 async function openOne(env: Env, ctx: ExtensionContext, id: string, mode: OpenMode): Promise<void> {
 	const items = await env.view.items();
@@ -357,6 +253,11 @@ async function openOne(env: Env, ctx: ExtensionContext, id: string, mode: OpenMo
 	if (items === undefined) return noTmux(ctx);
 	const item = items.find((candidate) => candidate.id === id);
 	if (item === undefined) {
+		if (env.results.find(id))
+			return ctx.ui.notify(
+				"delegate: no verified open window for this delegation; window changed or unavailable",
+				"error",
+			);
 		const known = items.map((candidate) => candidate.id).join(", ") || "none";
 		return ctx.ui.notify(`delegate: no open delegate ${JSON.stringify(id)}; open: ${known}`, "error");
 	}
@@ -365,40 +266,20 @@ async function openOne(env: Env, ctx: ExtensionContext, id: string, mode: OpenMo
 	if (await peek(env, ctx, item)) await switchTo(env, ctx, item);
 }
 
-function focusTarget(items: OpenDelegate[], target: string | undefined, position: DashboardPosition): boolean {
-	if (target === undefined) return true;
-	position.id = items.filter((item) => sessionIdOf(item.record) === target).at(-1)?.id;
-	return position.id !== undefined;
-}
-
-/** The navigator over the records, tmux and tracking. `startNew` is wired by the entry. */
+/** The command and compact-widget actions over the same verified navigation view. */
 export function createNavigator(
 	results: Results,
 	tmux: TmuxClient,
-	tracking: Pick<Tracking, "close" | "closeAll">,
-	startNew: (ctx: ExtensionContext) => Promise<void> | void,
+	tracking: Pick<Tracking, "close">,
 	actions: Partial<NavigatorActions> = {},
 ): Navigator {
 	const env: Env = { results, tmux, tracking, actions, view: new NavigatorView(results, tmux) };
 	return {
-		async panel(ctx: ExtensionContext, targetSessionId?: string): Promise<void> {
-			if (ctx.mode !== "tui") return noUi(ctx);
-			const position: DashboardPosition = { detail: targetSessionId !== undefined, offset: 0 };
-			let initial = true;
-			for (;;) {
-				actions.assertActive?.();
-				const items = branchItems((await env.view.items(true)) ?? [], targetSessionId);
-				actions.assertActive?.();
-				if (initial && !focusTarget(items, targetSessionId, position))
-					return ctx.ui.notify("delegate: selected delegate is no longer available", "warning");
-				initial = false;
-				const result: PanelResult = await show(ctx, items, position, targetSessionId);
-				if (!(await act(env, startNew, ctx, items, result))) return;
-			}
-		},
 		openDelegate: (ctx: ExtensionContext, id: string, mode: OpenMode): Promise<void> => openOne(env, ctx, id, mode),
+		closeDelegate: (ctx: ExtensionContext, id: string): Promise<void> => close(env, ctx, id),
 		async openIds(): Promise<string[]> {
-			return (await env.view.items())?.map((item) => item.id) ?? [];
+			actions.assertActive?.();
+			return ((await env.view.items()) ?? []).map((item) => item.id);
 		},
 	};
 }

package/src/result-sessions.ts

@@ -78,6 +78,32 @@ export function finishedModel(sessionPath: string | undefined): string | undefin
 	return undefined;
 }
 
+/** Approximate copied context from the last assistant request, excluding its output. */
+export function sessionInputTokens(sessionPath: string): number | undefined {
+	let lines: string[];
+	try {
+		lines = readFileSync(sessionPath, "utf8").split("\n");
+	} catch {
+		return undefined;
+	}
+	for (let i = lines.length - 1; i >= 0; i--) {
+		let entry: { type?: unknown; message?: { role?: unknown; usage?: Record<string, unknown> } };
+		try {
+			entry = JSON.parse(lines[i]);
+		} catch {
+			continue;
+		}
+		if (entry?.type !== "message" || entry.message?.role !== "assistant") continue;
+		const usage = entry.message.usage;
+		const counts = [usage?.input, usage?.cacheRead, usage?.cacheWrite];
+		if (!counts.every((count): count is number => typeof count === "number" && Number.isFinite(count) && count >= 0))
+			return undefined;
+		const total = counts.reduce((sum, count) => sum + count, 0);
+		return Number.isFinite(total) && total > 0 ? total : undefined;
+	}
+	return undefined;
+}
+
 /** One session-file line, as much of it as the branch walk reads. */
 type BranchEntry = { type?: unknown; id?: unknown; parentId?: unknown; thinkingLevel?: unknown };
 

package/src/results.ts

@@ -164,9 +164,9 @@ export type Results = {
 	/** Record a workspace attempt, or its next state; never counted as running. */
 	recordAttempt(attempt: WorkspaceAttempt, ctx: ExtensionContext): void;
 	/** Record a close; does nothing when there is no such delegation or it is already closed. */
-	recordClose(id: string): void;
+	recordClose(id: string, wake?: boolean): void;
 	/** Import only confirmed own direct-child closes; no foreign semantic writes. */
-	syncCloses(): void;
+	syncCloses(wake?: boolean): void;
 	/** Delegations with no result, no recorded close and no gone-window record. */
 	running(): StartedRecorded[];
 	/** Record that the window is gone with no result, and tell the parent once. False when it no longer applies. */

package/src/tmux.ts

@@ -85,6 +85,12 @@ export type PaneLocator = {
 	exited: boolean;
 };
 
+export type PaneListing = {
+	server: Pick<PaneLocator, "socket" | "serverPid" | "serverStarted"> | undefined;
+	panes: ReadonlyMap<string, PaneLocator>;
+	windows: TmuxWindow[];
+};
+
 export interface TmuxClient {
 	/** Whether this process runs in a tmux pane. */
 	insideTmux(): boolean;
@@ -102,6 +108,7 @@ export interface TmuxClient {
 	inspectPane?(paneId?: string): Promise<PaneLocator | undefined>;
 	/** Every window on the server, in one tmux call. */
 	listWindows(): Promise<TmuxWindow[]>;
+	listPanes(): Promise<PaneListing>;
 	/** Kill a window. */
 	kill(windowId: string): Promise<void>;
 	/** The session the parent's pane is in; undefined when it cannot be told. */
@@ -300,6 +307,34 @@ async function inspectPane(run: Run, paneId = process.env.TMUX_PANE): Promise<Pa
 	};
 }
 
+async function listPanes(run: Run): Promise<PaneListing> {
+	const format =
+		"#{socket_path}\t#{pid}\t#{start_time}\t#{pane_id}\t#{window_id}\t#{pane_dead}\t#{pane_active}\t#{session_name}\t#{window_name}";
+	const out = await run(["list-panes", "-a", "-F", format]);
+	const panes = new Map<string, PaneLocator>();
+	const windows = new Map<string, TmuxWindow>();
+	let server: PaneListing["server"];
+	for (const line of out.split("\n").filter((line) => line !== "")) {
+		const [socket, pid, started, paneId, windowId, dead, active, session, ...name] = line.split("\t");
+		if (
+			!socket ||
+			!/^\d+$/.test(pid) ||
+			!/^\d+$/.test(started) ||
+			!/^%[0-9]+$/.test(paneId) ||
+			!/^@[0-9]+$/.test(windowId) ||
+			!["0", "1"].includes(dead) ||
+			!["0", "1"].includes(active) ||
+			!name.length
+		)
+			throw new Error("tmux reported an invalid pane listing");
+		server = { socket, serverPid: Number(pid), serverStarted: started };
+		const pane = { ...server, paneId, windowId, windowName: name.join("\t"), exited: dead === "1" };
+		panes.set(paneId, pane);
+		if (active === "1") windows.set(windowId, { id: windowId, session, name: pane.windowName, exited: pane.exited });
+	}
+	return { server, panes, windows: [...windows.values()] };
+}
+
 /**
  * The real client. A window is opened relative to the session of the pane in
  * `TMUX_PANE`, not whatever session a client happens to have attached, so it
@@ -340,6 +375,8 @@ export function createTmuxClient(options: { timeoutMs?: number } = {}): TmuxClie
 
 		inspectPane: (paneId) => inspectPane(run, paneId),
 
+		listPanes: () => listPanes(run),
+
 		async currentWindow() {
 			const pane = process.env.TMUX_PANE;
 			if (!pane) return undefined;

package/src/tracking.ts

@@ -340,6 +340,7 @@ export async function closeDelegation(
 	id: string | undefined,
 	ctx: ExtensionContext,
 	assertActive: () => void,
+	wake = true,
 ): Promise<CloseResult> {
 	const local = id ? results.find(id) : undefined;
 	if (local && !isStarted(local))
@@ -350,7 +351,7 @@ export async function closeDelegation(
 	const root = readIdentity(actor)?.root ?? actor;
 	const result = await closeTree({ root, actor, id, tmux, assertActive });
 	assertActive();
-	results.syncCloses();
+	results.syncCloses(wake);
 	return result;
 }
 
@@ -372,7 +373,7 @@ function closeTool(results: Results, tmux: TmuxClient, assertActive: () => void)
 			_onUpdate: unknown,
 			ctx: ExtensionContext,
 		): Promise<ReturnType<typeof toolResult>> {
-			const { text, details } = await closeDelegation(results, tmux, params.id, ctx, assertActive);
+			const { text, details } = await closeDelegation(results, tmux, params.id, ctx, assertActive, false);
 			return { ...toolResult(text, details), ...(!details.complete ? { isError: true } : {}) };
 		},
 	};

package/src/tree-registry.ts

@@ -98,6 +98,10 @@ export function treeTransaction<T>(root: string, work: (state: TreeState) => T):
 export function readTree(root: string, timeoutMs = 5000): TreeState {
 	return withTreeLock(`${treePath(root)}.lock`, () => load(root), timeoutMs);
 }
+/** Atomic file replacement gives display readers a whole snapshot without writer admission. */
+export function readTreeDisplay(root: string): TreeState {
+	return load(root);
+}
 export function treeCounts(state: TreeState): TreeCounts {
 	const charged: TreeEntry[] = state.entries.filter((entry) => entry.phase !== "not-started");
 	return {

package/src/tree-view.ts

@@ -97,6 +97,7 @@ export function visibleRecordFacts(
 	ctx: ExtensionContext,
 	timeoutMs = 5000,
 	notify = true,
+	read: typeof readTree = readTree,
 ): VisibleFacts {
 	const session: string = ctx.sessionManager.getSessionId();
 	const root: string = readIdentity(session)?.root ?? session;
@@ -106,7 +107,7 @@ export function visibleRecordFacts(
 	let complete = true;
 	let entries: TreeEntry[];
 	try {
-		entries = descendants(readTree(root, timeoutMs), session).filter((entry) => entry.phase !== "not-started");
+		entries = descendants(read(root, timeoutMs), session).filter((entry) => entry.phase !== "not-started");
 	} catch (error) {
 		if (notify)
 			ctx.ui.notify(