@aeondave/pi-persona 1.17.1 → 1.17.4

package/src/ui/model-picker.ts

@@ -5,12 +5,32 @@
  * hundreds of models) and the viewport *follows the selection* — the highlighted
  * row is always on screen, so picking never jumps off the top.
  *
- * The pure parts (filter / viewport window / ordering) are exported and unit-tested;
- * this file's component is the thin pi-tui glue (focus + keyboard + framing).
+ * Machine-facing filtering/ordering remain separate from human fuzzy search.
+ * Only caller-supplied options are eligible; metadata never adds choices.
  */
 
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Container, getKeybindings, Spacer, Text, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import {
+	Container, CURSOR_MARKER, type Focusable, fuzzyFilter, getKeybindings, Input,
+	renderFakeCursor, setKeybindings, type TUI, truncateToWidth, visibleWidth,
+} from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "./presentation.ts";
+
+/** Structural subset of host snapshots; no registry lookup or availability policy here. */
+export interface ModelPickerMetadata {
+	provider: string;
+	id: string;
+	name?: string;
+	contextWindow?: number;
+	reasoning?: boolean;
+	input?: readonly string[];
+}
+
+export interface ModelPickerConfig {
+	currentRef?: string;
+	models?: readonly ModelPickerMetadata[];
+	keybindings?: KeybindingsManager;
+}
 
 const VIEWPORT = 12; // rows shown at once (the rest scrolls)
 
@@ -38,24 +58,48 @@ export function orderModelRefs(refs: string[], sessionProvider?: string): string
 	return [...refs].sort((a, b) => Number(!isSession(a)) - Number(!isSession(b)) || a.localeCompare(b));
 }
 
-/** Is this keystroke a single printable character (a filter keystroke)? */
-function isPrintable(key: string): boolean {
-	if (key.length !== 1) return false;
-	const c = key.charCodeAt(0);
-	return c >= 0x20 && c !== 0x7f;
+/** One safe display line; never use this to rewrite a returned model ref. */
+function displayText(value: string): string {
+	return sanitizeTerminalText(value)
+		.replace(/[\n\r\t\u2028\u2029]/g, " ")
+		.replace(/[\u202a-\u202e\u2066-\u2069]/g, "");
+}
+
+function metadataText(model: ModelPickerMetadata | undefined): string {
+	if (!model) return "";
+	const parts: string[] = [];
+	const context = model.contextWindow;
+	if (context !== undefined && Number.isSafeInteger(context) && context > 0) {
+		const size = context >= 1_000_000 ? `${Math.round(context / 100_000) / 10}m`
+			: context >= 1000 ? `${Math.round(context / 100) / 10}k` : String(context);
+		parts.push(`${size} ctx`);
+	}
+	if (model.reasoning === true) parts.push("reasoning");
+	if (model.input?.includes("image")) parts.push("vision");
+	// Functional metadata gets scarce columns before a potentially long/duplicated display name.
+	if (model.name && model.name !== model.id) parts.push(truncateToWidth(displayText(model.name), 32));
+	return parts.length ? ` · ${parts.join(" · ")}` : "";
 }
 
-export class ModelPicker extends Container {
+export class ModelPicker extends Container implements Focusable {
 	private theme: Theme;
 	private title: string;
 	private options: string[];
 	private sessionProvider: string | undefined;
+	private currentRef: string | undefined;
 	private done: (ref: string | undefined) => void;
 	private tui: TUI;
-	private query = "";
+	private input: Input;
+	private keybindings: ReturnType<typeof getKeybindings>;
+	private models = new Map<string, ModelPickerMetadata>();
+	private list: string[];
 	private selected = 0;
 	private scroll = 0;
-	private lastWidth = 100;
+	private pastePending = false;
+	private pasteTail = "";
+
+	get focused(): boolean { return this.input.focused; }
+	set focused(value: boolean) { this.input.focused = value; }
 
 	constructor(
 		tui: TUI,
@@ -64,97 +108,130 @@ export class ModelPicker extends Container {
 		options: string[],
 		sessionProvider: string | undefined,
 		done: (ref: string | undefined) => void,
+		config: ModelPickerConfig = {},
 	) {
 		super();
 		this.tui = tui;
 		this.theme = theme;
-		this.title = title;
-		this.options = options;
+		this.title = displayText(title);
+		this.options = [...options];
+		this.list = this.options;
 		this.sessionProvider = sessionProvider;
+		this.currentRef = config.currentRef;
 		this.done = done;
-		this.rebuild();
-	}
-
-	private refresh(): void {
-		this.rebuild();
-		this.tui.requestRender();
-	}
-
-	private filtered(): string[] {
-		return filterModels(this.options, this.query);
-	}
-
-	override render(width: number): string[] {
-		this.lastWidth = width;
-		const inner = this.inner();
-		const b = (s: string): string => this.theme.fg("accent", s);
-		const framed = super.render(inner).map((line) => {
-			const pad = " ".repeat(Math.max(0, inner - visibleWidth(line)));
-			return `${b("│")} ${line}${pad} ${b("│")}`;
+		this.keybindings = config.keybindings ?? getKeybindings();
+		for (const model of config.models ?? []) this.models.set(`${model.provider}/${model.id}`, model);
+		this.selected = Math.max(0, this.list.indexOf(config.currentRef ?? ""));
+		this.input = new Input({
+			prompt: "",
+			placeholder: "Search name, id or provider",
+			placeholderStyle: (text) => this.theme.fg("dim", text),
 		});
-		return [b(`┌${"─".repeat(inner + 2)}┐`), ...framed, b(`└${"─".repeat(inner + 2)}┘`)];
+		this.addChild(this.input);
 	}
 
-	private inner(): number {
-		return Math.max(24, Math.min(this.lastWidth - 4, 100));
+	private search(): void {
+		const previous = this.list[this.selected];
+		const query = this.input.getValue().trim();
+		this.list = fuzzyFilter(this.options, query, (ref) =>
+			displayText(`${ref} ${this.models.get(ref)?.name ?? ""}`));
+		// Full qualified refs beat name/token scores, without changing the caller's order at rest.
+		if (query) {
+			const literal = this.list.indexOf(query);
+			const exact = literal >= 0 ? literal : this.list.findIndex((ref) => ref.toLowerCase() === query.toLowerCase());
+			if (exact >= 0) {
+				if (exact > 0) this.list.unshift(...this.list.splice(exact, 1));
+				this.selected = 0; // typing an exact ref must not confirm a surviving fuzzy sibling
+				return;
+			}
+		}
+		this.selected = previous === undefined ? 0 : Math.max(0, this.list.indexOf(previous));
 	}
 
-	private rebuild(): void {
-		this.clear();
+	override render(width: number): string[] {
+		const outer = Math.max(0, Math.min(104, Math.floor(width)));
+		if (outer === 0) return [];
+		const framed = outer >= 8;
+		const inner = framed ? outer - 4 : outer;
 		const t = this.theme;
-		const list = this.filtered();
-		if (this.selected >= list.length) this.selected = Math.max(0, list.length - 1);
-		this.scroll = visibleWindow(this.selected, VIEWPORT, list.length, this.scroll);
-		const w = this.inner() - 1;
-
-		this.addChild(new Text(t.fg("accent", t.bold(this.title)), 1, 0));
-		const counter = t.fg("dim", `type to filter · ${list.length}/${this.options.length}`);
-		const q = this.query ? t.fg("accent", `  «${this.query}»`) : "";
-		this.addChild(new Text(`${counter}${q}`, 1, 0));
-		this.addChild(new Spacer(1));
-
-		if (list.length === 0) {
-			this.addChild(new Text(t.fg("dim", "(no model matches — backspace to widen)"), 1, 0));
+		const fit = (line: string): string => truncateToWidth(line, inner, "…");
+		let inputLine = this.input.render(inner)[0] ?? "";
+		// Native Input can overrun a one-column viewport with a wide cursor grapheme.
+		if (visibleWidth(inputLine) > inner) {
+			inputLine = `${this.focused ? CURSOR_MARKER : ""}${renderFakeCursor(" ")}`;
+		}
+		const lines = [
+			t.fg("accent", t.bold(fit(this.title))),
+			t.fg("dim", fit(`${this.list.length}/${this.options.length} · fuzzy search`)),
+			inputLine,
+			"",
+		];
+		this.scroll = visibleWindow(this.selected, VIEWPORT, this.list.length, this.scroll);
+		if (!this.list.length) {
+			lines.push(t.fg("dim", fit("(no model matches — edit search to widen)")));
 		} else {
-			const end = Math.min(list.length, this.scroll + VIEWPORT);
-			if (this.scroll > 0) this.addChild(new Text(t.fg("dim", `▲ ${this.scroll} above`), 1, 0));
+			const end = Math.min(this.list.length, this.scroll + VIEWPORT);
+			if (this.scroll > 0) lines.push(t.fg("dim", fit(`▲ ${this.scroll} above`)));
 			for (let i = this.scroll; i < end; i++) {
-				const opt = list[i] as string;
-				const star = this.sessionProvider && opt.startsWith(`${this.sessionProvider}/`) ? "★ " : "  ";
-				const text = truncateToWidth(`${star}${opt}`, w);
-				const row = i === this.selected ? t.fg("accent", `▸ ${text}`) : `  ${text}`;
-				this.addChild(new Text(row, 1, 0));
+				const ref = this.list[i]!;
+				const current = ref === this.currentRef ? "✓" : " ";
+				const star = this.sessionProvider && ref.startsWith(`${this.sessionProvider}/`) ? "★" : " ";
+				// Ref comes first; friendly name and bounded, explicit metadata spend only spare columns.
+				const row = fit(`${i === this.selected ? "▸" : " "} ${current}${star} ${displayText(ref)}${metadataText(this.models.get(ref))}`);
+				lines.push(i === this.selected ? t.fg("accent", row) : row);
 			}
-			if (end < list.length) this.addChild(new Text(t.fg("dim", `▼ ${list.length - end} below`), 1, 0));
+			if (end < this.list.length) lines.push(t.fg("dim", fit(`▼ ${this.list.length - end} below`)));
 		}
-
-		this.addChild(new Spacer(1));
-		this.addChild(new Text(t.fg("dim", "↑↓ move   ·   ⏎ select   ·   esc keep default"), 1, 0));
+		const keys = (action: Parameters<typeof this.keybindings.getKeys>[0]): string => this.keybindings.getKeys(action).join("/");
+		lines.push("", t.fg("dim", fit("✓ current · ★ session provider")), t.fg("dim", fit(
+			`${keys("tui.select.up")}/${keys("tui.select.down")} move · ${keys("tui.select.confirm")} select · ${keys("tui.select.cancel")} keep default`,
+		)));
+		if (!framed) return lines;
+		const b = (text: string): string => t.fg("accent", text);
+		return [
+			b(`┌${"─".repeat(inner + 2)}┐`),
+			...lines.map((line) => `${b("│")} ${line}${" ".repeat(Math.max(0, inner - visibleWidth(line)))} ${b("│")}`),
+			b(`└${"─".repeat(inner + 2)}┘`),
+		];
 	}
 
 	handleInput(keyData: string): void {
-		const kb = getKeybindings();
-		const list = this.filtered();
-		if (kb.matches(keyData, "tui.select.up")) {
+		const kb = this.keybindings;
+		// While Input buffers a bracketed paste, even a standalone Enter/Escape
+		// chunk is text, not a picker action. Retain only enough tail to detect
+		// an end marker split across chunks; Input owns the actual paste buffer.
+		const pasteData = this.pasteTail + keyData;
+		const editingPaste = this.pastePending || keyData.includes("\x1b[200~");
+		this.pastePending = editingPaste && !pasteData.includes("\x1b[201~");
+		this.pasteTail = this.pastePending ? pasteData.slice(-5) : "";
+		if (!editingPaste && kb.matches(keyData, "tui.select.up")) {
 			this.selected = Math.max(0, this.selected - 1);
-			this.refresh();
-		} else if (kb.matches(keyData, "tui.select.down")) {
-			this.selected = Math.min(Math.max(0, list.length - 1), this.selected + 1);
-			this.refresh();
-		} else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n" || keyData === "\r") {
-			this.done(list[this.selected]);
-		} else if (kb.matches(keyData, "tui.select.cancel")) {
+		} else if (!editingPaste && kb.matches(keyData, "tui.select.down")) {
+			this.selected = Math.min(Math.max(0, this.list.length - 1), this.selected + 1);
+		} else if (!editingPaste && kb.matches(keyData, "tui.select.confirm")) {
+			const ref = this.list[this.selected];
+			if (ref !== undefined) this.done(ref);
+			return;
+		} else if (!editingPaste && kb.matches(keyData, "tui.select.cancel")) {
 			this.done(undefined);
-		} else if (keyData === "\x7f" || keyData === "\b") {
-			if (this.query) {
-				this.query = this.query.slice(0, -1);
-				this.selected = 0;
-				this.refresh();
+			return;
+		} else {
+			const before = this.input.getValue();
+			// Input has no per-instance keybindings API (Pi 1.4). Scope its global
+			// lookup to this synchronous call and restore it even if handling throws.
+			const global = getKeybindings();
+			try {
+				if (global !== kb) setKeybindings(kb);
+				this.input.handleInput(keyData);
+			} finally {
+				if (global !== kb) setKeybindings(global);
 			}
-		} else if (isPrintable(keyData)) {
-			this.query += keyData;
-			this.selected = 0;
-			this.refresh();
+			const value = this.input.getValue();
+			const safe = displayText(value);
+			if (safe !== value) this.input.setValue(safe);
+			if (before !== safe) this.search();
 		}
+		this.invalidate();
+		this.tui.requestRender();
 	}
 }

package/src/ui/orchestration-launch.ts

@@ -0,0 +1,49 @@
+/** Persisted orchestration launch requests. Rendering never consults live persona or model settings. */
+import { resolveLegThinking } from "../core/leg-thinking.ts";
+import type { ThinkingLevel } from "../core/types.ts";
+import type { ModelParticipant, ModelSource } from "../persona/model-participants.ts";
+import { compactInlineText, sanitizeTerminalText } from "./presentation.ts";
+
+export interface OrchestrationLaunchParticipant {
+	key: string;
+	label: string;
+	agent: string;
+	model?: string;
+	modelSource: ModelSource;
+	thinkingRequested?: ThinkingLevel;
+	setupPending: boolean;
+	param?: string;
+	phase?: string;
+}
+
+export interface OrchestrationLaunchSnapshot {
+	participants: OrchestrationLaunchParticipant[];
+	unavailable?: true;
+}
+
+export function snapshotOrchestrationParticipants(
+	participants: readonly ModelParticipant[],
+	opts: { agentThinking(agent: string): ThinkingLevel | undefined; childThinking: unknown; pendingKeys: ReadonlySet<string> },
+): OrchestrationLaunchSnapshot {
+	return { participants: participants.map((p) => {
+		const agentThinking = opts.agentThinking(p.agent);
+		const thinkingRequested = resolveLegThinking(p, agentThinking ? { thinking: agentThinking } : {}, opts.childThinking);
+		return { key: p.key, label: p.label, agent: p.agent, modelSource: p.source, setupPending: !p.assigned && opts.pendingKeys.has(p.key),
+			...(p.model ? { model: p.model } : {}), ...(thinkingRequested ? { thinkingRequested } : {}), ...(p.param ? { param: p.param } : {}) };
+	}) };
+}
+
+/** Three individually bounded rows collapsed; expansion retains every participant and full model ref. */
+export function orchestrationLaunchLines(snapshot: OrchestrationLaunchSnapshot | undefined, expanded: boolean): string[] {
+	if (!snapshot || snapshot.unavailable) return ["Launch metadata unavailable"];
+	const rows = expanded ? snapshot.participants : snapshot.participants.slice(0, 3);
+	const lines = rows.map((p) => {
+		const clean = (value: string, maxChars: number): string => expanded ? sanitizeTerminalText(value) : compactInlineText(value, { maxChars });
+		const label = clean(`${p.phase ? `${p.phase} / ` : ""}${p.label}${p.param ? ` [${p.param}]` : ""}`, 48);
+		const model = p.model ? clean(p.model, 64) : "unknown";
+		const modelText = p.setupPending ? `model pending (current default ${model}; setup may change)` : `requested model ${model}`;
+		return `  ${label} · ${modelText} · requested effort ${p.thinkingRequested ?? "unknown"}`;
+	});
+	if (!expanded && snapshot.participants.length > rows.length) lines.push(`  +${snapshot.participants.length - rows.length} more · expand for launch details`);
+	return lines;
+}

package/src/ui/persona-settings.ts

@@ -225,8 +225,14 @@ export class PersonaSettingsPanel implements Component {
 		const title = this.theme.fg("accent", this.theme.bold("Persona settings"));
 		const file = fitLine(this.theme.fg("dim", `Configuration file: ${compactInlineText(this.data.file, { maxChars: 240 })}`), pageWidth);
 		const remembered = fitLine(this.theme.fg("dim", `Remembered persona: ${this.data.lastPersona ? compactInlineText(this.data.lastPersona, { maxChars: 120 }) : "none"}`), pageWidth);
+		// Show the configured primary binding; listing every alias would hide close/edit on narrow screens.
+		const keys = (action: "tui.select.up" | "tui.select.down" | "tui.select.confirm" | "tui.select.cancel"): string =>
+			this.keybindings.getKeys(action).slice(0, 1).map((key) => key === "escape" ? "esc" : key).join("/") || "unbound";
+		const move = `${keys("tui.select.up")}/${keys("tui.select.down")}`;
+		const confirm = keys("tui.select.confirm");
+		const cancel = keys("tui.select.cancel");
 		const filter = this.searchMode
-			? this.theme.fg("accent", `Filter (type, backspace, enter): ${compactInlineText(this.query, { maxChars: 120 })}▌`)
+			? this.theme.fg("accent", `Filter (type, backspace, ${confirm}): ${compactInlineText(this.query, { maxChars: 120 })}▌`)
 			: this.query
 				? this.theme.fg("dim", `Filter: ${compactInlineText(this.query, { maxChars: 120 })}`)
 				: this.theme.fg("dim", "Filter: press / to search");
@@ -234,8 +240,8 @@ export class PersonaSettingsPanel implements Component {
 		const footer = [
 			...(this.data.notice ? [fitLine(this.theme.fg("warning", compactInlineText(this.data.notice, { maxChars: 200 })), pageWidth)] : []),
 			...(pageWidth < 76
-				? ["↑↓ move  enter edit  r reset", "/ filter  m models  d info  esc close"]
-				: ["↑↓ move  enter edit  r reset  / filter  m models  d diagnostics  esc close"])
+				? [`${move} move  ${confirm} edit  r reset`, `/ filter  m models  d info  ${cancel} close`]
+				: [`${move} move  ${confirm} edit  r reset  / filter  m models  d diagnostics  ${cancel} close`])
 				.map((hint) => fitLine(this.theme.fg("dim", hint), pageWidth)),
 		];
 		const bodyHeight = Math.max(1, terminalRows - header.length - footer.length);

package/src/ui/presentation.ts

@@ -168,3 +168,27 @@ export function compactVisibleText(
 		originalChars: input.length,
 	};
 }
+
+/**
+ * The prompt an operator reads before releasing a flow checkpoint: which gate, what runs next,
+ * and enough of the gated phase's output to decide. The prompt is modal, so it cannot point at an
+ * "expand" key; it states how much it left out instead.
+ */
+export function gateReviewText(gate: {
+	flow: string;
+	phase: string;
+	/** The phases the approval releases. */
+	next: ReadonlyArray<{ id: string; strategy: string }>;
+	output: string;
+}): string {
+	const name = (value: string): string => compactInlineText(value, { maxChars: 64 });
+	const body = compactVisibleText(gate.output, { maxLines: 12, maxLineChars: 100 });
+	return [
+		`Checkpoint "${name(gate.phase)}" of flow "${name(gate.flow)}" — approve and continue?`,
+		...(gate.next.length > 0 ? [`then: ${gate.next.map((p) => `${name(p.id)} (${name(p.strategy)})`).join(", ")}`] : []),
+		// Everything below is the child's text: a fixed rule keeps it from passing as more prompt.
+		"--- gated output (untrusted) ---",
+		body.text,
+		...(body.truncated ? [`(+${Math.max(0, gate.output.length - body.text.length)} characters not shown)`] : []),
+	].join("\n");
+}

package/src/ui/report-body.ts

@@ -0,0 +1,63 @@
+/** UI-only prose projection. Never rewrites stored/model-facing text or unwraps trust fences. */
+import { getMarkdownTheme, type Theme, type ThemeBg } from "@earendil-works/pi-coding-agent";
+import { Markdown, Text, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "./presentation.ts";
+
+interface ReportBodyOptions {
+	/** Trusted chrome stays literal Text, outside the Markdown body. Evaluated at paint time. */
+	header?: (width: number) => string;
+	/** Custom session cards only. Normal tools already have the host's shell. */
+	background?: ThemeBg;
+	padding?: number;
+}
+
+class ReportBody implements Component {
+	private readonly markdownTheme = getMarkdownTheme();
+	private readonly markdown: Markdown;
+	readonly source: string;
+	private theme: Theme;
+	private options: ReportBodyOptions;
+	constructor(source: string, theme: Theme, options: ReportBodyOptions) {
+		this.source = source;
+		this.theme = theme;
+		this.options = options;
+		// No defaultTextStyle: Pi caches its default style prefix independently of invalidate().
+		// Apply the fallback foreground/background outside Markdown so theme changes stay fresh.
+		this.markdown = new Markdown(source, 0, 0, this.markdownTheme);
+	}
+	update(theme: Theme, options: ReportBodyOptions): void {
+		this.theme = theme;
+		this.options = options;
+		this.invalidate();
+	}
+	invalidate(): void {
+		Object.assign(this.markdownTheme, getMarkdownTheme());
+		// Native Markdown retains its source-token cache while clearing themed/layout output.
+		this.markdown.invalidate();
+	}
+	render(width: number): string[] {
+		if (width <= 0) return [];
+		const padding = Math.min(Math.max(0, Math.floor(this.options.padding ?? 0)), Math.max(0, Math.floor((width - 1) / 2)));
+		const innerWidth = Math.max(1, width - 2 * padding);
+		const header = this.options.header?.(innerWidth);
+		const lines = [
+			...(header ? new Text(header, 0, 0).render(innerWidth) : []),
+			...this.markdown.render(innerWidth).map((line) => this.theme.fg("toolOutput", line)),
+		];
+		const background = this.options.background;
+		return new Text(lines.join("\n"), padding, 0, background ? (text) => this.theme.bg(background, text) : undefined)
+			.render(width).map((line) => truncateToWidth(line, width));
+	}
+}
+
+/** Keep one native Markdown instance per report. Width changes reflow natively; invalidate() refreshes
+ * theme/layout, not source tokens. Tool callbacks can also reuse Pi's lastComponent across redraws.
+ * No global transcript/content cache: old reports are reclaimed with their host components. */
+export function createReportBody(text: string, theme: Theme, options: ReportBodyOptions = {}, previous?: Component): Component {
+	const source = sanitizeTerminalText(text);
+	if (previous instanceof ReportBody && previous.source === source) {
+		previous.update(theme, options);
+		return previous;
+	}
+	return new ReportBody(source, theme, options);
+}