pi-squire 0.20.0 → 0.20.2

package/src/widget-activity-runtime.ts

@@ -4,33 +4,20 @@ import type { TmuxClient } from "./tmux.ts";
 import { ActivityCollector } from "./widget-activity.ts";
 import { LIVE_LAUNCH_ENV, LiveActivityPublisher, liveLaunch } from "./widget-live.ts";
 
-function observeLocator(
+async function observeLocator(
 	publisher: LiveActivityPublisher,
 	id: string,
 	token: string,
 	tmux: TmuxClient,
 	ctx: ExtensionContext,
-): ReturnType<typeof setInterval> {
-	let reading = false;
-	const refresh = async (): Promise<void> => {
-		if (reading) return;
-		reading = true;
-		try {
-			const locator = await tmux.inspectPane?.().catch(() => undefined);
-			if (matchesSessionOwner(id, process.pid, token))
-				publisher.publishLocator(locator, token, ctx.sessionManager.getSessionFile());
-		} catch {
-			/* Optional observation cannot block task processing. */
-		} finally {
-			reading = false;
-		}
-	};
-	void refresh();
-	const timer: ReturnType<typeof setInterval> = setInterval(() => {
-		void refresh();
-	}, 1000);
-	timer.unref();
-	return timer;
+): Promise<void> {
+	try {
+		const locator = await tmux.inspectPane?.().catch(() => undefined);
+		if (matchesSessionOwner(id, process.pid, token))
+			publisher.publishLocator(locator, token, ctx.sessionManager.getSessionFile());
+	} catch {
+		/* Optional observation cannot block task processing. */
+	}
 }
 
 /** Observe raw lifecycle after a positive startup owner gate; never grants task/action authority. */
@@ -43,12 +30,8 @@ export function registerActivityRuntime(
 	const seed: string | undefined = process.env[LIVE_LAUNCH_ENV];
 	let collector: ActivityCollector | undefined;
 	let publisher: LiveActivityPublisher | undefined;
-	let timer: ReturnType<typeof setInterval> | undefined;
 
 	const stop = (): void => {
-		if (timer) clearInterval(timer);
-		timer = undefined;
-
 		collector?.clear();
 		collector = undefined;
 		publisher?.stop();
@@ -66,7 +49,7 @@ export function registerActivityRuntime(
 		collector = new ActivityCollector();
 		publisher = new LiveActivityPublisher(id, liveLaunch(seed, id));
 		publish();
-		if (tmux && ownerToken) timer = observeLocator(publisher, id, ownerToken, tmux, ctx);
+		if (tmux && ownerToken) void observeLocator(publisher, id, ownerToken, tmux, ctx);
 	});
 	pi.on("tool_execution_start", (event) => {
 		collector?.start(event.toolCallId, event.toolName, event.parentToolCallId);

package/src/widget-ancestors.ts

@@ -4,20 +4,30 @@ import { type Identity, readIdentity } from "./identity.ts";
 import { locateSession, recordedName } from "./results.ts";
 import { matchesSessionOwner, sessionIsOwned } from "./session-owner.ts";
 import type { PaneLocator, TmuxClient } from "./tmux.ts";
-import { readTree, type TreeEntry } from "./tree-registry.ts";
+import { readTreeDisplay, type TreeEntry } from "./tree-registry.ts";
 import { LiveActivityReader, type LiveLocator } from "./widget-live.ts";
 import { WidgetTitleMirrors } from "./widget-title.ts";
 import { WidgetTitleFiles } from "./widget-title-file.ts";
 import { listWindows } from "./windows.ts";
 
-export type AncestorRow = { key: string; sessionId: string; identity: string; parent: boolean; title?: string };
+export type WidgetIdentity = { identity: string; agent?: string };
+export type Breadcrumb = {
+	key: string;
+	parentSessionId: string;
+	crumbs: WidgetIdentity[];
+	self: WidgetIdentity;
+	parentTitle?: string;
+};
 type Ancestor = { sessionId: string; identity?: Identity };
 
 /** Durable parent ids only. A broken/cyclic chain refuses rather than inventing ancestry. */
 export function ancestorSessions(ctx: ExtensionContext): Ancestor[] {
 	const session: string = ctx.sessionManager.getSessionId();
 	const own: Identity | undefined = readIdentity(session);
-	if (!own) return [];
+	return own ? ancestorChain(session, own) : [];
+}
+
+function ancestorChain(session: string, own: Identity): Ancestor[] {
 	const found: Ancestor[] = [];
 	const seen: Set<string> = new Set([session]);
 	let child: Identity = own;
@@ -44,7 +54,7 @@ export function ancestorSessions(ctx: ExtensionContext): Ancestor[] {
 	throw new Error("ancestor identity chain does not reach root");
 }
 
-export class AncestorView {
+export class BreadcrumbView {
 	private readonly titles: WidgetTitleFiles = new WidgetTitleFiles();
 	private readonly mirrors: WidgetTitleMirrors = new WidgetTitleMirrors();
 
@@ -53,33 +63,40 @@ export class AncestorView {
 		this.mirrors.clear();
 	}
 
-	async read(ctx: ExtensionContext, reader: LiveActivityReader): Promise<AncestorRow[]> {
-		const ancestors: Ancestor[] = ancestorSessions(ctx);
+	async read(ctx: ExtensionContext, reader: LiveActivityReader): Promise<Breadcrumb | undefined> {
+		const session = ctx.sessionManager.getSessionId();
+		const own = readIdentity(session);
+		if (!own) return;
+		const ancestors = ancestorChain(session, own);
 		let entries: TreeEntry[] = [];
 		try {
-			if (ancestors.length) entries = readTree(ancestors[0].sessionId, 20).entries;
+			entries = readTreeDisplay(ancestors[0].sessionId).entries;
 		} catch {
 			/* labels optional */
 		}
-		return Promise.all(
-			ancestors.map(async (ancestor: Ancestor, index: number): Promise<AncestorRow> => {
-				const entry: TreeEntry | undefined = entries.findLast((item) => item.sessionId === ancestor.sessionId);
-				const live: LiveLocator | undefined = await reader.locator(ancestor.sessionId);
-				const path: string | undefined =
-					live?.sessionFile ?? (entry?.launch ? locateSession(entry.launch, undefined) : undefined);
-				const name: string | undefined =
-					this.titles.read(path, ancestor.sessionId)?.name ?? this.mirrors.read(ancestor.sessionId);
-				let label = "root";
-				if (ancestor.identity) label = entry?.launch ? recordedName(entry.launch) : ancestor.identity.agent;
-				return {
-					key: `ancestor:${ancestor.sessionId}`,
-					sessionId: ancestor.sessionId,
-					identity: label,
-					parent: index === ancestors.length - 1,
-					title: name,
-				};
-			}),
-		);
+		const crumbs = ancestors.map((ancestor): WidgetIdentity => {
+			const entry = entries.findLast((item) => item.sessionId === ancestor.sessionId);
+			const label = entry?.launch ? recordedName(entry.launch) : ancestor.identity?.agent;
+			return {
+				identity: ancestor.identity ? (label ?? ancestor.identity.agent) : "root",
+				agent: ancestor.identity?.agent,
+			};
+		});
+		const parent = ancestors[ancestors.length - 1];
+		const entry = entries.findLast((item) => item.sessionId === parent.sessionId);
+		const live = await reader.locator(parent.sessionId);
+		const path = live?.sessionFile ?? (entry?.launch ? locateSession(entry.launch, undefined) : undefined);
+		const self = entries.findLast((item) => item.sessionId === session);
+		return {
+			key: `ancestor:${parent.sessionId}`,
+			parentSessionId: parent.sessionId,
+			crumbs,
+			self: {
+				identity: self?.launch ? recordedName(self.launch) : own.agent,
+				agent: own.agent,
+			},
+			parentTitle: this.titles.read(path, parent.sessionId)?.name ?? this.mirrors.read(parent.sessionId),
+		};
 	}
 }
 
@@ -95,20 +112,13 @@ function sameTarget(a: LiveLocator, b: LiveLocator): boolean {
 }
 
 /** Positive own-server + exact target-pane + id/name listing, not a launch snapshot. */
-export async function verifyLiveWindow(tmux: TmuxClient, live: LiveLocator): Promise<boolean> {
+export async function verifyLiveWindow(tmux: TmuxClient, live: LiveLocator): Promise<PaneLocator | undefined> {
 	const own: PaneLocator | undefined = await tmux.inspectPane?.();
-	if (!own || !sameServer(own, live.locator)) return false;
+	if (!own || !sameServer(own, live.locator)) return undefined;
 	const pane: PaneLocator | undefined = await tmux.inspectPane?.(live.locator.paneId);
-	if (
-		!pane ||
-		pane.exited ||
-		!sameServer(pane, live.locator) ||
-		pane.windowId !== live.locator.windowId ||
-		pane.windowName !== live.locator.windowName
-	)
-		return false;
+	if (!pane || pane.exited || !sameServer(pane, live.locator)) return undefined;
 	const windows = await listWindows(tmux);
-	return !!windows?.some((window) => window.id === pane.windowId && window.name === pane.windowName);
+	return windows?.some((window) => window.id === pane.windowId && window.name === pane.windowName) ? pane : undefined;
 }
 
 export async function switchAncestor(
@@ -122,21 +132,23 @@ export async function switchAncestor(
 	if (!ancestorSessions(ctx).some((ancestor) => ancestor.sessionId === sessionId))
 		throw new Error("target is not a current ancestor");
 	const live: LiveLocator | undefined = await reader.locator(sessionId);
-	if (!live || !(await verifyLiveWindow(tmux, live))) throw new Error("no verified live window for this ancestor");
+	const pane = live ? await verifyLiveWindow(tmux, live) : undefined;
+	if (!live || !pane) throw new Error("no verified live window for this ancestor");
 	assertActive();
 	const own = await tmux.ownSession();
 	const client: string | undefined = own ? await tmux.clientFor(own.name) : undefined;
 	if (!client) throw new Error("no tmux client attached to this session");
 	const current: LiveLocator | undefined = await reader.locator(sessionId);
 	assertActive();
-	if (!current || !sameTarget(live, current) || !(await verifyLiveWindow(tmux, current)))
+	const verified = current ? await verifyLiveWindow(tmux, current) : undefined;
+	if (!current || !sameTarget(live, current) || !verified || JSON.stringify(pane) !== JSON.stringify(verified))
 		throw new Error("ancestor window changed or is unavailable");
 	assertActive();
 	if (!ancestorSessions(ctx).some((ancestor) => ancestor.sessionId === sessionId))
 		throw new Error("ancestor identity changed");
 	if (!matchesSessionOwner(sessionId, current.pid, current.ownerToken) || !sessionIsOwned(sessionId))
 		throw new Error("ancestor owner changed or is unavailable");
-	await tmux.switchTo(client, current.locator.windowId);
+	await tmux.switchTo(client, verified.windowId);
 	assertActive();
-	ctx.ui.notify(`delegate: switched to ancestor ${sessionId} (${current.locator.windowId})`, "info");
+	ctx.ui.notify(`delegate: switched to ancestor ${sessionId} (${verified.windowId})`, "info");
 }

package/src/widget-current.ts

@@ -1,40 +1,41 @@
 // Optional live-window overrides for known local children, never semantic rewrites.
 import { isStarted, type Results, type StartedRecorded, sessionIdOf } from "./results.ts";
-import type { PaneLocator, TmuxClient, TmuxWindow } from "./tmux.ts";
-import type { LiveActivityReader, LiveLocator } from "./widget-live.ts";
+import type { PaneListing } from "./tmux.ts";
+import type { LiveActivityReader } from "./widget-live.ts";
 
 export async function currentChildWindows(
 	results: Results,
-	tmux: TmuxClient,
-	windows: TmuxWindow[] | undefined,
+	listing: PaneListing | undefined,
 	reader: LiveActivityReader,
 ): Promise<Map<string, { windowId: string; windowName: string }>> {
-	const found: Map<string, { windowId: string; windowName: string }> = new Map();
-	if (!windows?.length || !tmux.inspectPane) return found;
-	const latest: Map<string, StartedRecorded> = new Map(
+	const found = new Map<string, { windowId: string; windowName: string }>();
+	if (!listing?.server || !listing.windows.length) return found;
+	const server = listing.server;
+	const latest = new Map<string, StartedRecorded>(
 		results
 			.list()
 			.filter(isStarted)
 			.map((record) => [sessionIdOf(record), record]),
 	);
-	const candidates: StartedRecorded[] = [...latest.values()].filter((record) => !record.closed);
-	if (!candidates.length) return found;
-	const own: PaneLocator | undefined = await tmux.inspectPane().catch(() => undefined);
-	if (!own) return found;
 	await Promise.all(
-		candidates.map(async (record): Promise<void> => {
-			const live: LiveLocator | undefined = await reader.locator(sessionIdOf(record));
+		[...latest.values()].map(async (record): Promise<void> => {
+			if (
+				record.closed ||
+				listing.windows.some(
+					(window) => window.id === record.windowId && window.name === record.windowName && !window.exited,
+				)
+			)
+				return;
+			const live = await reader.locator(sessionIdOf(record));
 			if (
 				!live ||
-				live.locator.socket !== own.socket ||
-				live.locator.serverPid !== own.serverPid ||
-				live.locator.serverStarted !== own.serverStarted
+				live.locator.socket !== server.socket ||
+				live.locator.serverPid !== server.serverPid ||
+				live.locator.serverStarted !== server.serverStarted
 			)
 				return;
-			const pane: PaneLocator | undefined = await tmux.inspectPane?.(live.locator.paneId).catch(() => undefined);
-			if (!pane || pane.exited || JSON.stringify(pane) !== JSON.stringify(live.locator)) return;
-			if (windows.some((window) => window.id === pane.windowId && window.name === pane.windowName))
-				found.set(record.id, { windowId: pane.windowId, windowName: pane.windowName });
+			const pane = listing.panes.get(live.locator.paneId);
+			if (pane && !pane.exited) found.set(record.id, { windowId: pane.windowId, windowName: pane.windowName });
 		}),
 	);
 	return found;

package/src/widget-data.ts

@@ -12,7 +12,12 @@ export type DelegateRow = {
 	key: string;
 	sessionId: string;
 	launchId: string;
+	parentKey?: string;
+	depth?: number;
+	descendantCount?: number;
+	expanded?: boolean;
 	identity: string;
+	agent?: string;
 	title: string | undefined;
 	state: string;
 	running: boolean;
@@ -21,7 +26,6 @@ export type DelegateRow = {
 	/** Transcript mtime is a last-active hint, not proof of tool activity. */
 	lastActive: number | undefined;
 	activity?: Activity;
-	summary?: string;
 };
 
 /** All eligible rows remain available; only this viewport incurs metadata I/O. */
@@ -82,6 +86,7 @@ export class DirectDelegateView {
 		sessionDir: string | undefined,
 		viewport: MetadataViewport = { offset: 0, limit: 3 },
 		currentWindows: ReadonlyMap<string, { windowId: string; windowName: string }> = new Map(),
+		visibleKeys?: ReadonlySet<string>,
 	): DelegateRow[] {
 		const running: Set<string> = new Set(results.running().map((record) => record.id));
 		const entries: Entry[] = [];
@@ -100,7 +105,8 @@ export class DirectDelegateView {
 			...entries.filter(({ row }) => !row.running),
 		];
 		return ordered.map(({ record, row }, index) => {
-			if (index >= viewport.offset && index < viewport.offset + viewport.limit) this.enrich(record, row, sessionDir);
+			if (visibleKeys ? visibleKeys.has(row.key) : index >= viewport.offset && index < viewport.offset + viewport.limit)
+				this.enrich(record, row, sessionDir);
 			return row;
 		});
 	}
@@ -111,7 +117,9 @@ export class DirectDelegateView {
 			key: sessionId,
 			sessionId,
 			launchId: record.id,
+			parentKey: record.identity?.parent,
 			identity: recordedName(record),
+			agent: record.agent,
 			title: undefined,
 			lastActive: undefined,
 			state: running ? "running" : (record.result?.status ?? (record.gone ? "missing" : "unknown")),
@@ -145,3 +153,28 @@ export class DirectDelegateView {
 		row.lastActive = disk?.modified;
 	}
 }
+
+export function delegateTree(rows: DelegateRow[], viewer: string, expanded: ReadonlySet<string>): DelegateRow[] {
+	const children = new Map<string, DelegateRow[]>();
+	const keys = new Set(rows.map((row) => row.key));
+	for (const row of rows) {
+		const parent = row.parentKey && keys.has(row.parentKey) ? row.parentKey : viewer;
+		const siblings = children.get(parent) ?? [];
+		siblings.push(row);
+		children.set(parent, siblings);
+	}
+	const count = (key: string): number =>
+		(children.get(key) ?? []).reduce((total, child) => total + 1 + count(child.key), 0);
+	const visible: DelegateRow[] = [];
+	const walk = (parent: string, depth: number): void => {
+		for (const row of children.get(parent) ?? []) {
+			row.depth = depth;
+			row.descendantCount = count(row.key);
+			row.expanded = expanded.has(row.key);
+			visible.push(row);
+			if (expanded.has(row.key)) walk(row.key, depth + 1);
+		}
+	};
+	walk(viewer, 0);
+	return visible;
+}

package/src/widget-focus.ts

@@ -29,10 +29,12 @@ type FocusOptions = {
 	selection: WidgetSelection;
 	changed(): void;
 	open(key: string): Promise<void>;
+	close(key: string): Promise<void>;
+	horizontal(direction: -1 | 1): void;
 	error(error: unknown): void;
 };
 
-/** Pseudo-focus: real Pi focus stays with the prompt until Pi mounts a dashboard/dialog. */
+/** Pseudo-focus leaves real Pi focus with the prompt or its confirmation dialog. */
 export class WidgetFocus {
 	private readonly options: FocusOptions;
 	private tui: unknown;
@@ -68,7 +70,7 @@ export class WidgetFocus {
 	suspend(suspended: boolean): void {
 		if (this.stopped) return;
 		this.suspended = suspended;
-		// Our own dashboard keeps selection; unrelated prompts relinquish pseudo-focus.
+		// Our own confirmation keeps selection; unrelated prompts relinquish pseudo-focus.
 		if (suspended && !this.busy) this.options.selection.leave();
 		this.options.changed();
 	}
@@ -88,8 +90,7 @@ export class WidgetFocus {
 
 	private input(data: string): { consume: true } | undefined {
 		if (this.stopped || isKeyRelease(data)) return;
-		// Async listing/action loops temporarily return focus to the prompt. Do not
-		// let dashboard Escape abort a run or action letters leak into that editor.
+		// Pending actions consume keys only while the exact empty prompt still owns focus.
 		if (this.busy) return this.pendingInput();
 		if (this.suspended || promptState(this.tui, this.options.ui) !== "empty") {
 			this.leave();
@@ -98,11 +99,7 @@ export class WidgetFocus {
 		const selection: WidgetSelection = this.options.selection;
 		if (!selection.active) {
 			if (!matchesKey(data, "down") || !selection.enter()) return;
-		} else if (matchesKey(data, "down")) selection.move(1);
-		else if (matchesKey(data, "up")) selection.move(-1);
-		else if (matchesKey(data, "escape")) selection.leave();
-		else if (matchesKey(data, "enter")) this.open();
-		else {
+		} else if (!this.navigate(data)) {
 			this.leave();
 			return;
 		}
@@ -110,17 +107,30 @@ export class WidgetFocus {
 		return { consume: true };
 	}
 
+	private navigate(data: string): boolean {
+		const selection = this.options.selection;
+		if (matchesKey(data, "down")) selection.move(1);
+		else if (matchesKey(data, "up")) selection.move(-1);
+		else if (matchesKey(data, "escape")) selection.leave();
+		else if (matchesKey(data, "left")) this.options.horizontal(-1);
+		else if (matchesKey(data, "right")) this.options.horizontal(1);
+		else if (matchesKey(data, "enter")) this.action("open");
+		else if (matchesKey(data, "x")) this.action("close");
+		else return false;
+		return true;
+	}
+
 	private pendingInput(): { consume: true } | undefined {
 		return promptState(this.tui, this.options.ui) === "empty" ? { consume: true } : undefined;
 	}
 
-	private open(): void {
+	private action(action: "open" | "close"): void {
 		const key: string | undefined = this.options.selection.selectedKey;
 		if (key === undefined) return;
 		this.busy = true; // Set before invoking async custom UI; repeated Enter cannot reenter.
 		void Promise.resolve()
 			.then(() => {
-				if (!this.stopped) return this.options.open(key);
+				if (!this.stopped) return this.options[action](key);
 			})
 			.catch((error: unknown) => {
 				if (!this.stopped) this.options.error(error);

package/src/widget-live.ts

@@ -6,8 +6,8 @@ import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { matchesSessionOwner } from "./session-owner.ts";
 import type { PaneLocator } from "./tmux.ts";
+import { processAlive } from "./tree-lock.ts";
 import { type Activity, activityText } from "./widget-activity.ts";
-import { type Liveness, processLiveness, processStart } from "./widget-live-process.ts";
 
 export const LIVE_LAUNCH_ENV = "PI_SQUIRE_LIVE_LAUNCH";
 export const LIVE_MAX_BYTES = 8192;
@@ -29,7 +29,6 @@ type Snapshot = {
 	launchId?: string;
 	generation: string;
 	pid: number;
-	processStart: string;
 	revision: number;
 	observedAt: number;
 	activity: Activity | null;
@@ -97,7 +96,6 @@ function validSnapshot(value: Partial<Snapshot>, sessionId: string, generation:
 		(value.launchId === undefined || validString(value.launchId)) &&
 		Number.isSafeInteger(value.pid) &&
 		(value.pid ?? 0) > 0 &&
-		validString(value.processStart) &&
 		Number.isSafeInteger(value.revision) &&
 		(value.revision ?? -1) >= 0 &&
 		typeof value.observedAt === "number" &&
@@ -131,13 +129,17 @@ function snapshotFile(name: string, file: boolean): boolean {
 	return file && /^[a-f0-9-]{36}\.json$/.test(name);
 }
 
-type Probe = (owner: { pid: number; processStart: string }) => Promise<Liveness>;
+type Liveness = "live" | "dead" | "unknown";
+type Probe = (owner: { pid: number }) => Promise<Liveness>;
 
 export class LiveActivityReader {
 	private readonly agentDir: string;
 	private readonly probe: Probe;
 
-	constructor(agentDir = getAgentDir(), probe: Probe = processLiveness) {
+	constructor(
+		agentDir = getAgentDir(),
+		probe: Probe = async ({ pid }: { pid: number }): Promise<Liveness> => (processAlive(pid) ? "live" : "dead"),
+	) {
 		this.agentDir = agentDir;
 		this.probe = probe;
 	}
@@ -209,7 +211,6 @@ export class LiveActivityReader {
 }
 
 type PublisherOptions = {
-	start?: () => Promise<string | undefined>;
 	rename?: typeof rename;
 };
 
@@ -221,7 +222,6 @@ export class LiveActivityPublisher {
 	private readonly dir: string;
 	private readonly path: string;
 	private readonly temporary: string;
-	private readonly start: Promise<string | undefined>;
 	private readonly replace: typeof rename;
 	private activity: Activity | null = null;
 	private locator: PaneLocator | undefined;
@@ -243,9 +243,6 @@ export class LiveActivityPublisher {
 		this.dir = liveSessionDir(sessionId);
 		this.path = join(this.dir, `${this.generation}.json`);
 		this.temporary = `${this.path}.tmp`;
-		this.start = (options.start ?? ((): Promise<string | undefined> => processStart(process.pid)))().catch(
-			() => undefined,
-		);
 		this.replace = options.rename ?? rename;
 	}
 
@@ -311,11 +308,6 @@ export class LiveActivityPublisher {
 	}
 
 	private async drain(): Promise<void> {
-		const start: string | undefined = await this.start;
-		if (!start || this.stopped) {
-			this.dirty = false;
-			return;
-		}
 		if (this.dirty && !this.stopped) {
 			this.dirty = false;
 			this.urgent = false;
@@ -326,7 +318,6 @@ export class LiveActivityPublisher {
 				launchId: this.launchId,
 				generation: this.generation,
 				pid: process.pid,
-				processStart: start,
 				revision: this.revision,
 				observedAt: this.observedAt,
 				activity: this.activity,