pi-squire 0.14.0 → 0.16.0

package/src/widget.ts

@@ -0,0 +1,272 @@
+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 { joinActivities } from "./widget-activity-join.ts";
+import { type AncestorRow, AncestorView, switchAncestor } from "./widget-ancestors.ts";
+import { currentChildWindows } from "./widget-current.ts";
+import { type DelegateRow, DirectDelegateView, type MetadataViewport } 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";
+
+export const DELEGATE_WIDGET_KEY = "squire-delegates";
+export const WIDGET_REFRESH_MS = 1000;
+type OpenDashboard = (ctx: ExtensionContext, sessionId: 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 live = new LiveActivityReader();
+	private ancestors: AncestorRow[] = [];
+	private ancestryError = "";
+	private readonly ctx: ExtensionContext;
+	private readonly selection = new WidgetSelection();
+	private readonly focus: WidgetFocus;
+	private timer: ReturnType<typeof setInterval> | undefined;
+	private immediate: ReturnType<typeof setImmediate> | undefined;
+	private unsubscribe: (() => void) | undefined;
+	private stopped = false;
+	private reading = false;
+	private again = false;
+	private signature = "";
+	private warning = "";
+	private countVisible: boolean | undefined;
+	private factsRevision = 0;
+	private layoutRevision = 0;
+	private rows: DelegateRow[] = [];
+	private configuration: WidgetSettings = { ...DEFAULT_WIDGET_SETTINGS };
+
+	constructor(
+		results: Results,
+		tmux: TmuxClient,
+		ctx: ExtensionContext,
+		open: OpenDashboard,
+		assertActive: () => void,
+	) {
+		this.results = results;
+		this.tmux = tmux;
+		this.ctx = ctx;
+		this.focus = new WidgetFocus({
+			ui: ctx.ui,
+			selection: this.selection,
+			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);
+			},
+			error: (error: unknown): void =>
+				ctx.ui.notify(`delegate: ${error instanceof Error ? error.message : String(error)}`, "error"),
+		});
+	}
+
+	start(): void {
+		this.unsubscribe = this.results.subscribe(() => {
+			this.factsRevision++;
+			this.queue();
+		});
+		this.focus.start();
+		this.configureCount(this.settings().maxEntries === 0);
+		this.queue();
+		this.timer = setInterval(() => this.queue(), WIDGET_REFRESH_MS);
+		this.timer.unref();
+	}
+
+	suspend(suspended: boolean): void {
+		this.focus.suspend(suspended);
+	}
+
+	stop(): void {
+		if (this.stopped) return;
+		this.stopped = true;
+		if (this.timer) clearInterval(this.timer);
+		if (this.immediate) clearImmediate(this.immediate);
+		this.unsubscribe?.();
+		this.focus.stop();
+		this.view.clear();
+		this.ancestorView.clear();
+		this.ctx.ui.setWidget(DELEGATE_WIDGET_KEY, undefined);
+	}
+
+	private changed(): void {
+		if (this.stopped) return;
+		this.layoutRevision++;
+		this.show(this.rows, this.configuration);
+		this.queue();
+	}
+
+	private configureCount(visible: boolean): void {
+		if (this.countVisible === visible) return;
+		this.countVisible = visible;
+		this.results.setCountVisible(visible);
+	}
+
+	private settings(): WidgetSettings {
+		try {
+			const settings: WidgetSettings = widgetSettings();
+			this.warning = "";
+			return settings;
+		} catch (error) {
+			const warning: string = String(error);
+			if (warning !== this.warning) this.ctx.ui.notify(`delegate: ${warning}; using widget defaults.`, "warning");
+			this.warning = warning;
+			return { ...DEFAULT_WIDGET_SETTINGS };
+		}
+	}
+
+	private queue(): void {
+		if (this.stopped) return;
+		if (this.reading) {
+			this.again = true;
+			return;
+		}
+		if (this.immediate) return;
+		this.immediate = setImmediate(() => {
+			this.immediate = undefined;
+			void this.refresh();
+		});
+	}
+
+	private async readAncestors(): Promise<void> {
+		try {
+			this.ancestors = await this.ancestorView.read(this.ctx, this.live);
+			this.ancestryError = "";
+		} catch {
+			this.ancestors = [];
+			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 async refresh(): Promise<void> {
+		this.reading = true;
+		const revision: number = this.factsRevision;
+		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) : [];
+			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();
+			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 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);
+			// 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.show(rows, settings);
+		} catch {
+			// Optional metadata/UI failures cannot interrupt launch, poll or result processing.
+		} finally {
+			this.reading = false;
+			if (this.again) {
+				this.again = false;
+				this.queue();
+			}
+		}
+	}
+
+	private show(rows: DelegateRow[], settings: WidgetSettings): void {
+		this.rows = rows;
+		this.configuration = settings;
+		const options = {
+			offset: this.selection.offset,
+			selectedKey: this.selection.selectedKey,
+			focused: this.focus.focused,
+			ancestors: this.ancestors,
+			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)) {
+			this.ctx.ui.setWidget(DELEGATE_WIDGET_KEY, undefined);
+			return;
+		}
+		this.ctx.ui.setWidget(
+			DELEGATE_WIDGET_KEY,
+			(tui) => {
+				this.focus.attach(tui); // Pi 1.4.0 stable proxy follows renderer replacement.
+				return {
+					render: (width: number) =>
+						renderDelegateWidget(rows, settings.maxEntries, width, this.ctx.ui.theme, Date.now(), {
+							...options,
+							focused: this.focus.focused,
+						}),
+					invalidate: () => {},
+				};
+			},
+			{ placement: settings.placement },
+		);
+	}
+}
+
+/** Register after direct restore, preserving ownership/answer/settlement ordering. */
+export function registerDelegateWidget(
+	pi: ExtensionAPI,
+	results: Results,
+	tmux: TmuxClient,
+	open: OpenDashboard,
+	assertActive: () => void,
+): void {
+	let overview: Overview | undefined;
+	let publisher: ReturnType<typeof titlePublisher> | undefined;
+	const stop = (): void => {
+		overview?.stop();
+		overview = undefined;
+		publisher?.stop();
+		publisher = undefined;
+	};
+	pi.on("session_start", (_event, ctx) => {
+		stop();
+		publisher = titlePublisher(ctx.sessionManager.getSessionId());
+		publisher.publish(pi.getSessionName());
+		if (ctx.hasUI && ctx.mode === "tui") {
+			overview = new Overview(results, tmux, ctx, open, assertActive);
+			overview.start();
+		}
+	});
+	pi.on("ui_prompt_start", () => overview?.suspend(true));
+	pi.on("ui_prompt_end", () => overview?.suspend(false));
+	pi.on("session_info_changed", (event) => publisher?.publish(event.name));
+	pi.on("session_shutdown", stop);
+}

package/src/window-placement.ts

@@ -1,17 +1,42 @@
 // Call-time choice of where delegate windows open. `companion` (the default)
-// opens them in a session of their own, `<parent's session>-squire`; `current`
+// opens them in a shared project session; `current`
 // opens them in the parent's own session, as before. Read from
 // `<agent dir>/squire/settings.json` at every launch, like `worktreeRoot`.
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
+
+import { inspectGit } from "./git.ts";
 
 export type WindowPlacement = "companion" | "current";
 
+/** A preferred base, never a selected numbered companion or a tmux locator. */
+export function assertRootPlacement(value: unknown): asserts value is string {
+	if (typeof value !== "string" || !/^[A-Za-z0-9_](?:[A-Za-z0-9_-]*[A-Za-z0-9_])?-delegate-session$/.test(value))
+		throw new Error(
+			"invalid or missing rootPlacement in delegation identity; original root companion preference is required",
+		);
+}
+
+/** The owning root's project, never the delegate's chosen working directory. */
+export function placementProject(cwd: string): { companion: string; notices: string[] } {
+	const git = inspectGit(cwd);
+	const project = basename(git.kind === "git" ? git.identity.mainRoot : cwd);
+	const normalized = project.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+	return {
+		companion: `${normalized}-delegate-session`,
+		notices:
+			git.kind === "unknown"
+				? [
+						`Could not inspect the root project for companion placement: ${git.reason}. Using the root working-directory basename ${JSON.stringify(basename(cwd))}.`,
+					]
+				: [],
+	};
+}
+
 /**
  * The placement for this call. An unknown value refuses with the file named.
- * A file that cannot be read or parsed is left to the worktree settings,
- * which report it when a launch needs them: it does not stop the launches
- * that never read it, so those keep the default.
+ * This reader defaults malformed/unreadable files to companion; mandatory
+ * tree-cap admission separately refuses those files for every launch/resume.
  */
 export function windowPlacement(agentDir: string): WindowPlacement {
 	const file = join(agentDir, "squire", "settings.json");

package/src/workspace.ts

@@ -12,15 +12,14 @@
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-
 import {
 	type ExtensionContext,
 	hasTrustRequiringProjectResources,
 	ProjectTrustStore,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-
 import { askGit, type GitLaunch, inspectGit, PathSummarySchema } from "./git.ts";
+import { localTrust, type TrustDecision, type TrustResolver, trustChoices } from "./trust-prompt.ts";
 import type { ManagedWorkspace } from "./worktree.ts";
 
 export {
@@ -141,32 +140,6 @@ export function resolveDirectory(value: string, base: string): string {
 	return real;
 }
 
-/** The trust dialog's choices, as Pi's own selector offers them. */
-type Choice = { label: string; trusted: boolean; updates: { path: string; decision: boolean | null }[] };
-
-function choices(key: string): Choice[] {
-	const parent = dirname(key);
-	return [
-		{ label: "Trust", trusted: true, updates: [{ path: key, decision: true }] },
-		// The parent folder's approval clears the nearer key, which would otherwise outrank it.
-		...(parent === key
-			? []
-			: [
-					{
-						label: `Trust parent folder (${parent})`,
-						trusted: true,
-						updates: [
-							{ path: parent, decision: true },
-							{ path: key, decision: null },
-						],
-					},
-				]),
-		{ label: "Trust (this session only)", trusted: true, updates: [] },
-		{ label: "Do not trust", trusted: false, updates: [{ path: key, decision: false }] },
-		{ label: "Do not trust (this session only)", trusted: false, updates: [] },
-	];
-}
-
 /** The saved decision for `key` or its closest ancestor; a broken store refuses the launch. */
 function savedDecision(store: ProjectTrustStore, key: string): boolean | null {
 	try {
@@ -178,66 +151,47 @@ function savedDecision(store: ProjectTrustStore, key: string): boolean | null {
 	}
 }
 
-/** The end of the trust dialog queue: one question at a time in this parent, so an answer cannot reach another target. */
-let dialogs: Promise<unknown> = Promise.resolve();
-
 /** Why an aborted launch stopped. */
 const ABORTED = "the launch was aborted; nothing was launched";
 
-/** Run `ask` once every earlier question is settled; an abort while waiting rejects at once and skips `ask`. */
-function oneAtATime<T>(ask: () => Promise<T>, signal: AbortSignal | undefined): Promise<T> {
-	const run = (): Promise<T> => {
-		if (signal?.aborted === true) return Promise.reject(new Error(ABORTED));
-		return ask();
-	};
-	const turn = dialogs.then(run, run);
-	dialogs = turn.catch(() => undefined);
-	if (signal === undefined) return turn;
-	const aborted = new Promise<never>((_, reject) => {
-		signal.addEventListener("abort", () => reject(new Error(ABORTED)), { once: true });
-	});
-	return Promise.race([turn, aborted]);
-}
-
 /** Refuse to go on once the launch's operation is aborted. */
 function stopIfAborted(signal: AbortSignal | undefined): void {
 	if (signal?.aborted === true) throw new Error(ABORTED);
 }
 
-/** Ask the user whether the delegate trusts `cwd`'s project resources, saving only what they chose. */
+/** Apply only an answer returned to this still-live requesting operation. */
 async function askTrust(
-	ctx: ExtensionContext,
 	signal: AbortSignal | undefined,
 	store: ProjectTrustStore,
 	cwd: string,
 	key: string,
+	resolver: TrustResolver,
 ): Promise<boolean> {
-	// An answer given while this question waited may already settle it.
-	const saved = savedDecision(store, key);
-	if (saved !== null) return saved;
-	const options = choices(key);
-	const title = [
-		"A delegate is about to start in a directory with project resources Pi loads only when trusted.",
-		`Directory: ${cwd}`,
-		...(key === cwd ? [] : [`Main repository: ${key}`]),
-		`"Trust" and "Do not trust" save the decision for ${key}; "Trust parent folder" saves it for the folder named; "this session only" applies to this launch alone.`,
-	].join("\n");
-	const answer = await ctx.ui.select(
-		title,
-		options.map((option) => option.label),
-		{ signal },
-	);
-	stopIfAborted(signal);
-	const choice = options.find((option) => option.label === answer);
-	if (choice === undefined) throw new Error(`the trust question for ${cwd} was cancelled; nothing was launched`);
-	if (choice.updates.length > 0) {
-		try {
-			store.setMany(choice.updates);
-		} catch (err) {
-			throw new Error(`could not save the trust decision for ${key}: ${(err as Error).message}; nothing was launched`);
+	const decision: TrustDecision = await resolver(cwd, key, signal);
+	try {
+		stopIfAborted(signal);
+		decision.assertLive();
+		if ("saved" in decision.answer) {
+			if (savedDecision(store, key) !== decision.answer.saved)
+				throw new Error("the scoped project trust changed while waiting; delegate again");
+			return decision.answer.saved;
+		}
+		const label = decision.answer.label;
+		const choice = trustChoices(key).find((option) => option.label === label);
+		if (choice === undefined) throw new Error(`the trust question for ${cwd} was cancelled; nothing was launched`);
+		if (choice.updates.length > 0) {
+			try {
+				store.setMany(choice.updates);
+			} catch (err) {
+				throw new Error(
+					`could not save the trust decision for ${key}: ${(err as Error).message}; nothing was launched`,
+				);
+			}
 		}
+		return choice.trusted;
+	} finally {
+		decision.release();
 	}
-	return choice.trusted;
 }
 
 /**
@@ -252,6 +206,7 @@ async function targetTrust(
 	ctx: ExtensionContext,
 	agentDir: string,
 	signal: AbortSignal | undefined,
+	resolver?: TrustResolver,
 ): Promise<boolean> {
 	if (git.kind === "git") {
 		const parent = inspectGit(ctx.cwd);
@@ -264,12 +219,7 @@ async function targetTrust(
 	const saved = savedDecision(store, key);
 	if (saved !== null) return saved;
 	if (!hasTrustRequiringProjectResources(cwd)) return false;
-	if (!ctx.hasUI) {
-		throw new Error(
-			`cwd ${cwd} has project resources that need trust and no trust decision is saved for ${key}; open Pi in ${key}, answer its trust question, then delegate again`,
-		);
-	}
-	return oneAtATime(() => askTrust(ctx, signal, store, cwd, key), signal);
+	return askTrust(signal, store, cwd, key, resolver ?? localTrust(ctx, agentDir));
 }
 
 const PROTECTED = [
@@ -320,29 +270,26 @@ export type PlannedTrust = { trusted: boolean; revalidate(): void };
 
 async function askPlannedResourceTrust(
 	plan: WorktreePlan,
-	ctx: ExtensionContext,
 	store: ProjectTrustStore,
-	signal?: AbortSignal,
+	signal: AbortSignal | undefined,
+	resolver: TrustResolver,
 ): Promise<{ trusted: boolean; exposure?: { tree: string | undefined; ancestors: boolean } }> {
 	const tree = plannedTreeHasResources(plan.source.checkoutRoot, plan.baseCommit);
 	const ancestors = destinationHasAncestorSkills(plan.destination);
 	const exposure = { tree, ancestors };
 	if (tree === undefined && !ancestors) return { trusted: false, exposure };
-	if (!ctx.hasUI)
-		throw new Error(
-			`the planned worktree in ${plan.destination} exposes project resources and has no saved trust decision for ${plan.source.mainRoot}; open Pi and establish trust, then delegate again`,
-		);
-	const trusted = await oneAtATime(async () => {
+	const decide = async (): Promise<boolean> => {
 		const savedAtTurn = savedDecision(store, plan.source.mainRoot);
 		if (savedAtTurn !== null) return savedAtTurn;
-		const answer = await askTrust(ctx, signal, store, plan.destination, plan.source.mainRoot);
+		const answer = await askTrust(signal, store, plan.destination, plan.source.mainRoot, resolver);
 		if (
 			(tree !== undefined && plannedTreeHasResources(plan.source.checkoutRoot, plan.baseCommit) !== tree) ||
 			destinationHasAncestorSkills(plan.destination) !== ancestors
 		)
 			throw new Error("the planned resources changed while trust was being decided; delegate again");
 		return answer;
-	}, signal);
+	};
+	const trusted = await decide();
 	return { trusted, exposure };
 }
 
@@ -352,6 +299,7 @@ export async function trustPlannedWorktree(
 	ctx: ExtensionContext,
 	agentDir: string,
 	signal?: AbortSignal,
+	resolver?: TrustResolver,
 ): Promise<PlannedTrust> {
 	const parent = inspectGit(ctx.cwd);
 	const sameRepository = parent.kind === "git" && parent.identity.commonDir === plan.source.commonDir;
@@ -364,7 +312,7 @@ export async function trustPlannedWorktree(
 		const saved = savedDecision(store, plan.source.mainRoot);
 		if (saved !== null) trusted = saved;
 		else {
-			const answer = await askPlannedResourceTrust(plan, ctx, store, signal);
+			const answer = await askPlannedResourceTrust(plan, store, signal, resolver ?? localTrust(ctx, agentDir));
 			trusted = answer.trusted;
 			exposure = answer.exposure;
 		}
@@ -399,7 +347,7 @@ export async function trustPlannedWorktree(
  * `ctx.signal` aborts it too.
  */
 export async function prepareDirectory(
-	request: { cwd?: string; signal?: AbortSignal },
+	request: { cwd?: string; signal?: AbortSignal; trust?: TrustResolver },
 	ctx: ExtensionContext,
 	agentDir: string,
 ): Promise<{ workspace: DirectoryWorkspace; trusted: boolean }> {
@@ -414,7 +362,7 @@ export async function prepareDirectory(
 	stopIfAborted(signal);
 	const cwd = resolveDirectory(request.cwd, ctx.cwd);
 	const git = inspectGit(cwd);
-	const trusted = await targetTrust(cwd, git, ctx, agentDir, signal);
+	const trusted = await targetTrust(cwd, git, ctx, agentDir, signal, request.trust);
 	stopIfAborted(signal);
 	return { workspace: { mode: "existing", cwd, git }, trusted };
 }