pi-squire 0.14.0 → 0.16.0

package/src/local-state.ts

@@ -0,0 +1,21 @@
+// Atomic session-local records independent of Pi's transcript buffering.
+// This is not a cross-process registry or a lock; duplicate-open arbitration
+// belongs to the tree restoration layer.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function readState<T>(path: string): T | undefined {
+	try {
+		return JSON.parse(readFileSync(path, "utf8")) as T;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+export function writeState(path: string, state: unknown): void {
+	mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+	const temporary = `${path}.${process.pid}.tmp`;
+	writeFileSync(temporary, JSON.stringify(state), { mode: 0o600 });
+	renameSync(temporary, path);
+}

package/src/navigator-view.ts

@@ -0,0 +1,186 @@
+// Read-only dashboard/navigation projection. Never supplies locators to close or task accounting.
+import type { DashboardRow } from "./dashboard.ts";
+import {
+	type DelegationState,
+	deriveState,
+	isStarted,
+	locateSession,
+	type Results,
+	recordedName,
+	type StartedRecorded,
+	sessionIdOf,
+} from "./results.ts";
+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 (
+		["running", "done", "gone"].includes(item.state) || (item.state === "window-closed" && item.live !== undefined)
+	);
+}
+
+function sameTarget(a: OpenDelegate, b: OpenDelegate): boolean {
+	return (
+		a.window.id === b.window.id && a.window.name === b.window.name && JSON.stringify(a.live) === JSON.stringify(b.live)
+	);
+}
+
+/** Current evidence supersedes historical navigation, but never mutates a saved launch/result. */
+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();
+
+	constructor(
+		results: Results,
+		tmux: TmuxClient,
+		reader: Pick<LiveActivityReader, "locator"> = new LiveActivityReader(),
+	) {
+		this.results = results;
+		this.tmux = tmux;
+		this.reader = reader;
+	}
+
+	async items(history = false): Promise<OpenDelegate[] | undefined> {
+		const windows: TmuxWindow[] | undefined = await listWindows(this.tmux);
+		if (!windows && !history) 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;
+			}),
+		);
+		if (history) return items;
+		return items.filter(openItem).reverse();
+	}
+
+	private async item(
+		record: StartedRecorded,
+		latest: boolean,
+		windows: TmuxWindow[] | undefined,
+	): Promise<OpenDelegate> {
+		const historical: TmuxWindow | undefined = windows ? ownWindow(windows, record) : undefined;
+		const live: LiveLocator | undefined =
+			latest && !record.closed ? await this.reader.locator(sessionIdOf(record)) : undefined;
+		if (live) this.current.add(record.id);
+		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,
+			navigable: !!window && !window.exited,
+			window: window ?? { id: record.windowId, name: record.windowName, exited: true, session: "" },
+		};
+	}
+
+	private async liveWindow(
+		live: LiveLocator | undefined,
+		windows: TmuxWindow[] | undefined,
+	): Promise<TmuxWindow | undefined> {
+		if (!live || !windows || !(await verifyLiveWindow(this.tmux, live).catch(() => false))) return undefined;
+		const found: TmuxWindow | undefined = windows.find(
+			(entry) => entry.id === live.locator.windowId && entry.name === live.locator.windowName,
+		);
+		// Exact Pi pane, not a different active pane's pane_dead.
+		return found ? { ...found, exited: false } : undefined;
+	}
+
+	async verified(item: OpenDelegate): Promise<boolean> {
+		const all: StartedRecorded[] = this.results.list().filter(isStarted);
+		const record: StartedRecorded | undefined = all.find((entry) => entry.id === item.id);
+		if (!record || sessionIdOf(record) !== sessionIdOf(item.record)) return false;
+		const latest: boolean = all.filter((entry) => sessionIdOf(entry) === sessionIdOf(record)).at(-1)?.id === record.id;
+		const current: OpenDelegate = await this.item(record, latest, await listWindows(this.tmux));
+		if (!current.navigable || !sameTarget(item, current)) return false;
+		if (!current.live) return true;
+		const final: LiveLocator | undefined = await this.reader.locator(sessionIdOf(record));
+		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"}`,
+		`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,37 +1,30 @@
 // The delegate navigator: the `/delegates` panel and `/delegate-open`. It lists
-// the delegations whose window is open and reaches one of them: a switch of
+// 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, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+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 DelegationState, deriveState, isStarted, type Results, recordedName } from "./results.ts";
-import type { TmuxClient, TmuxWindow } from "./tmux.ts";
-import { listWindows, ownWindow, type Tracking } from "./tracking.ts";
+import { type Results, sessionIdOf } 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; switch is what enter does in the panel. */
+/** What `/delegate-open` does; dashboard Enter opens details before switching. */
 export type OpenMode = "switch" | "peek";
 
 export const OPEN_USAGE = "/delegate-open <id> [--switch|--peek]";
 const OPEN_FLAGS = ["--switch", "--peek"] as const;
 
-/** One delegation whose window is open. */
-type OpenDelegate = {
-	id: string;
-	name: string;
-	agent: string;
-	state: DelegationState;
-	window: TmuxWindow;
-};
-
 /** What the panel hands back: the action the user chose on one delegation, or none. */
-type PanelResult = { action: "switch" | "close" | "peek"; id: string } | { action: "new" } | undefined;
+type PanelResult = DashboardIntent;
 
 /** What the peek hands back: switch to the delegate, or nothing. */
 type PeekResult = { action: "switch" } | undefined;
 
-const HINT = "↑↓ select · enter switch · p peek · x close · n new · esc leave";
-const EMPTY = "No open delegates · n new · esc close";
 const PEEK_HINT = "r refresh · enter switch · esc back";
 
 /** Where a peek shows: over the panel or the editor, not in its place. */
@@ -51,54 +44,6 @@ function peekBody(peek: Capture, rows: number): string[] {
 		.slice(-Math.max(5, rows - 8));
 }
 
-/** The panel's list of open delegates, as a pi-tui component. */
-class Panel implements Component {
-	private selected = 0;
-	private readonly items: readonly OpenDelegate[];
-	private readonly theme: PanelTheme;
-	private readonly done: (result: PanelResult) => void;
-	private readonly redraw: () => void;
-
-	constructor(parts: {
-		items: readonly OpenDelegate[];
-		theme: PanelTheme;
-		done: (result: PanelResult) => void;
-		redraw: () => void;
-	}) {
-		this.items = parts.items;
-		this.theme = parts.theme;
-		this.done = parts.done;
-		this.redraw = parts.redraw;
-	}
-
-	invalidate(): void {}
-
-	handleInput(data: string): void {
-		const item = this.items[this.selected];
-		const count = this.items.length;
-		if (matchesKey(data, "escape")) this.done(undefined);
-		else if (matchesKey(data, "n")) this.done({ action: "new" });
-		else if (item === undefined) return;
-		else if (matchesKey(data, "up")) this.selected = (this.selected + count - 1) % count;
-		else if (matchesKey(data, "down")) this.selected = (this.selected + 1) % count;
-		else if (matchesKey(data, "enter")) this.done({ action: "switch", id: item.id });
-		else if (matchesKey(data, "p")) this.done({ action: "peek", id: item.id });
-		else if (matchesKey(data, "x")) this.done({ action: "close", id: item.id });
-		this.redraw();
-	}
-
-	render(width: number): string[] {
-		const fit = (text: string): string => truncateToWidth(text, Math.max(1, width));
-		if (this.items.length === 0) return [this.theme.bold("Delegates"), "", EMPTY].map(fit);
-		const lines = this.items.map((item, index) => {
-			const where = item.window.session === "" ? item.window.id : `${item.window.id} in ${item.window.session}`;
-			const row = `${item.name} · ${item.agent} · ${item.state} · ${where}`;
-			return index === this.selected ? this.theme.fg("accent", `▸ ${row}`) : `  ${row}`;
-		});
-		return [this.theme.bold("Delegates"), "", ...lines, "", this.theme.fg("dim", HINT)].map(fit);
-	}
-}
-
 /** A snapshot of one delegate's pane, shown as an overlay: `r` refreshes, enter switches, esc returns. */
 class PeekView implements Component {
 	private capture: Capture = { text: "", error: undefined, loading: true };
@@ -143,6 +88,7 @@ class PeekView implements Component {
 	}
 
 	handleInput(data: string): void {
+		if (isKeyRelease(data)) return;
 		if (matchesKey(data, "escape")) this.done(undefined);
 		else if (matchesKey(data, "r")) this.refresh();
 		else if (matchesKey(data, "enter")) this.done({ action: "switch" });
@@ -160,7 +106,7 @@ 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): Promise<void>;
+	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>;
 	/** Ids of the delegations whose window is open, for completions. */
@@ -192,25 +138,31 @@ export function openCompletions(prefix: string, ids: readonly string[]): { value
 	return hits.length > 0 ? hits.map((value) => ({ value: head + value, label: value })) : null;
 }
 
-type Env = { results: Results; tmux: TmuxClient; tracking: Pick<Tracking, "close"> };
-
-/** The open delegations, newest first, from the records and one listing; undefined when tmux cannot be asked. */
-async function openDelegates({ results, tmux }: Env): Promise<OpenDelegate[] | undefined> {
-	const windows = await listWindows(tmux);
-	if (windows === undefined) return undefined;
-	const found: OpenDelegate[] = [];
-	for (const record of results.list()) {
-		if (!isStarted(record)) continue;
-		const window = ownWindow(windows, record);
-		if (window === undefined || window.exited) continue;
-		const state = deriveState(record, "open");
-		if (state !== "running" && state !== "done") continue;
-		found.push({ id: record.id, name: recordedName(record), agent: record.agent, state, window });
-	}
-	return found.reverse();
+/** Context-bearing action seam; presentation never owns close/resume 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">;
+	actions: Partial<NavigatorActions>;
+	view: NavigatorView;
+};
+
+async function verifiedWindow(env: Env, item: OpenDelegate): Promise<boolean> {
+	env.actions.assertActive?.();
+	const verified: boolean = await env.view.verified(item);
+	env.actions.assertActive?.();
+	return verified;
 }
 
-/** The parent's own session name, or undefined when tmux cannot say. */
+/** The parent\'s own session name, or undefined when tmux cannot say. */
 async function ownSessionName(tmux: TmuxClient): Promise<string | undefined> {
 	try {
 		return (await tmux.ownSession())?.name;
@@ -232,41 +184,84 @@ async function clientOf(tmux: TmuxClient): Promise<{ client: string } | { refusa
 }
 
 async function switchTo(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promise<void> {
+	env.actions.assertActive?.();
 	const found = await clientOf(env.tmux);
 	if ("refusal" in found) return ctx.ui.notify(`delegate: cannot switch: ${found.refusal}`, "warning");
 	try {
+		env.actions.assertActive?.();
+		if (!(await verifiedWindow(env, item)))
+			return ctx.ui.notify(
+				"delegate: no verified open window for this delegation; window changed or unavailable",
+				"error",
+			);
 		await env.tmux.switchTo(found.client, item.window.id);
 	} catch (err) {
 		return ctx.ui.notify(`delegate: could not switch: ${(err as Error).message}`, "error");
 	}
+	try {
+		env.actions.assertActive?.();
+	} catch (err) {
+		return ctx.ui.notify(
+			`delegate: switched to ${item.name} (${item.window.id}); session ownership lost: ${(err as Error).message}`,
+			"warning",
+		);
+	}
 	ctx.ui.notify(
 		`delegate: switched to ${item.name} (${item.window.id}) · your tmux last-session key returns you`,
 		"info",
 	);
 }
 
-/** Close through the `delegation_close` path, asking first only while the delegate runs. */
+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") {
-		const message = `${item.name} is still running. Close it and kill its window?`;
+	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;
 	}
 	try {
-		ctx.ui.notify(`delegate: ${(await env.tracking.close(item.id)).text}`, "info");
+		env.actions.assertActive?.();
+		const result = await (env.actions.close?.(item.id, ctx) ?? env.tracking.close(item.id, ctx));
+		env.actions.assertActive?.();
+		ctx.ui.notify(
+			`delegate: ${result.text}`,
+			("isError" in result && result.isError) || result.details?.complete === false ? "error" : "info",
+		);
 	} catch (err) {
 		ctx.ui.notify(`delegate: ${(err as Error).message}`, "error");
 	}
 }
 
-/** Show the panel; resolves with what the user chose. */
-function show(ctx: ExtensionContext, items: readonly OpenDelegate[]): Promise<PanelResult> {
+/** 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): Panel =>
-			new Panel({
-				items,
-				theme: theme as unknown as PanelTheme,
+		(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: (): void => tui.requestRender(),
+				redraw: () => tui.requestRender(),
+				rows: () => tui.terminal.rows,
 			}),
 	);
 }
@@ -278,7 +273,10 @@ async function peek(env: Env, ctx: ExtensionContext, item: OpenDelegate): Promis
 			new PeekView({
 				item,
 				theme: theme as unknown as PanelTheme,
-				read: (windowId: string): Promise<string> => env.tmux.capture(windowId),
+				read: async (windowId: string): Promise<string> => {
+					if (!(await verifiedWindow(env, item))) throw new Error("no verified open window");
+					return env.tmux.capture(item.live?.locator.paneId ?? windowId);
+				},
 				done,
 				redraw: (): void => tui.requestRender(),
 				rows: (): number => tui.terminal.rows,
@@ -291,6 +289,24 @@ 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,
@@ -300,17 +316,31 @@ async function act(
 	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;
@@ -321,7 +351,8 @@ async function act(
 
 /** 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 openDelegates(env);
+	const items = await env.view.items();
+	env.actions.assertActive?.();
 	if (items === undefined) return noTmux(ctx);
 	const item = items.find((candidate) => candidate.id === id);
 	if (item === undefined) {
@@ -329,30 +360,44 @@ async function openOne(env: Env, ctx: ExtensionContext, id: string, mode: OpenMo
 		return ctx.ui.notify(`delegate: no open delegate ${JSON.stringify(id)}; open: ${known}`, "error");
 	}
 	if (mode === "switch") return switchTo(env, ctx, item);
-	if (!ctx.hasUI) return noUi(ctx);
+	if (ctx.mode !== "tui") return noUi(ctx);
 	if (await peek(env, ctx, item)) await switchTo(env, ctx, item);
 }
 
-/** The navigator over the records, tmux and tracking. `startNew` is the new-delegate flow, wired by the entry. */
+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. */
 export function createNavigator(
 	results: Results,
 	tmux: TmuxClient,
-	tracking: Pick<Tracking, "close">,
+	tracking: Pick<Tracking, "close" | "closeAll">,
 	startNew: (ctx: ExtensionContext) => Promise<void> | void,
+	actions: Partial<NavigatorActions> = {},
 ): Navigator {
-	const env: Env = { results, tmux, tracking };
+	const env: Env = { results, tmux, tracking, actions, view: new NavigatorView(results, tmux) };
 	return {
-		async panel(ctx: ExtensionContext): Promise<void> {
-			if (!ctx.hasUI) return noUi(ctx);
+		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 (;;) {
-				const items = await openDelegates(env);
-				if (items === undefined) return noTmux(ctx);
-				if (!(await act(env, startNew, ctx, items, await show(ctx, items)))) return;
+				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),
 		async openIds(): Promise<string[]> {
-			return (await openDelegates(env))?.map((item) => item.id) ?? [];
+			return (await env.view.items())?.map((item) => item.id) ?? [];
 		},
 	};
 }

package/src/new-delegate.ts

@@ -47,6 +47,8 @@ export type NewDelegateDeps = {
 	roster(ctx: ExtensionContext): Roster;
 	/** The refusal text for an empty roster. */
 	noAgents(): string;
+	/** The model and thinking `agent` runs on when the request names none: its own, else the parent's. */
+	defaults(agent: Agent, ctx: ExtensionContext): { model?: string; thinking: string };
 	/** Why `value` is not a usable label, or undefined; the check `--label` gets. */
 	labelProblem(value: string): string | undefined;
 	/** Start the delegate as `/delegate` would, notifying the start or the refusal. */
@@ -207,12 +209,12 @@ export class SettingsForm implements Component {
 		this.options = options;
 		const { agent, models, style } = options;
 		for (const model of models) this.byId.set(`${model.provider}/${model.id}`, model);
-		this.model = agent.model;
-		this.thinking = agent.thinking;
+		this.model = agent.model ?? "";
+		this.thinking = agent.thinking ?? "";
 		this.autoExit = agent.autoExit;
 		this.cwd = options.cwd;
 		this.clampInitialThinking();
-		const modelItems: SelectItem[] = [...new Set([agent.model, ...this.byId.keys()])].map((value) => ({
+		const modelItems: SelectItem[] = [...new Set([this.model, ...this.byId.keys()])].map((value) => ({
 			value,
 			label: value,
 		}));
@@ -360,8 +362,8 @@ export class SettingsForm implements Component {
 			return;
 		}
 		this.options.done({
-			...(this.model === this.options.agent.model ? {} : { model: this.model }),
-			...(this.thinking === this.options.agent.thinking ? {} : { thinking: this.thinking }),
+			...(this.model === (this.options.agent.model ?? "") ? {} : { model: this.model }),
+			...(this.thinking === (this.options.agent.thinking ?? "") ? {} : { thinking: this.thinking }),
 			...(this.autoExit === this.options.agent.autoExit ? {} : { autoExit: this.autoExit }),
 			...(this.cwd === this.options.cwd ? {} : { cwd: this.cwd }),
 			...(this.worktree === "" ? {} : { worktree: this.worktree }),
@@ -410,14 +412,20 @@ export async function startNewDelegate(ctx: ExtensionContext, deps: NewDelegateD
 	if (unavailable !== undefined) return fail(unavailable);
 	const roster = deps.roster(ctx);
 	if (roster.agents.length === 0) return fail(deps.noAgents());
-	const options = roster.agents.map((agent) => `${agent.name} — ${agent.description}`);
+	const options = roster.agents.map(
+		(agent) =>
+			`${agent.name}${agent.displayName === undefined ? "" : ` (${agent.displayName})`} — ${agent.description}`,
+	);
 	const picked = await ctx.ui.select("New delegate: agent", options);
 	const agent = roster.agents[options.indexOf(picked ?? "")];
 	if (agent === undefined) return;
 	const task = await ctx.ui.editor(`Task for ${agent.name}`);
 	if (task === undefined) return;
 	if (task.trim() === "") return fail("a task is required");
-	const typed = await ctx.ui.input(`Label (optional; empty for ${agent.name}-<id>)`, "letters, digits, _ or -");
+	const typed = await ctx.ui.input(
+		`Label (optional; empty for ${agent.displayName ?? agent.name}-<id>)`,
+		"letters, digits, _ or -",
+	);
 	if (typed === undefined) return;
 	const label = typed.trim() === "" ? undefined : typed.trim();
 	const badLabel = label === undefined ? undefined : deps.labelProblem(label);
@@ -425,7 +433,8 @@ export async function startNewDelegate(ctx: ExtensionContext, deps: NewDelegateD
 	const chosen = await ctx.ui.custom<FormResult | undefined>(
 		(_tui, theme, _keys, done): Component =>
 			new SettingsForm({
-				agent,
+				// The rows start at what a request naming nothing runs on.
+				agent: { ...agent, ...deps.defaults(agent, ctx) } as Agent,
 				models: ctx.modelRegistry.getAvailable() as Model<never>[],
 				cwd: ctx.cwd,
 				style: theme,