@oh-my-pi/pi-tui 18.2.11 → 18.3.1

package/src/theme/mermaid-cache.ts

@@ -1,5 +1,5 @@
 import type { MermaidRenderOptions } from "@oh-my-pi/pi-natives";
-import { renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils/mermaid-ascii";
+import * as mermaidAscii from "@oh-my-pi/pi-utils/mermaid-ascii";
 
 /**
  * Options controlling how fenced Mermaid source is resolved to terminal ASCII.
@@ -8,12 +8,10 @@ import { renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils/mermaid-ascii";
  */
 export interface MermaidResolveOptions extends MermaidRenderOptions {
 	/**
-	 * Maximum display width (terminal columns) the diagram should occupy. A
-	 * layout that overflows this width is re-rendered in the perpendicular
-	 * orientation — a wide horizontal chain collapses to a tall vertical column
-	 * (which the terminal can scroll), and a wide vertical fan-out collapses to a
-	 * tall horizontal column. Omit to keep the source's own layout regardless of
-	 * width.
+	 * Maximum display width (terminal columns) the diagram should occupy.
+	 * Flowcharts are also rendered top-down and left-to-right. A resize picks
+	 * the shortest variant that fits; if none fit, the narrowest, which the
+	 * caller may still clip. Omit to keep the source's own layout.
 	 */
 	maxWidth?: number;
 }
@@ -23,16 +21,29 @@ export interface MermaidResolveOptions extends MermaidRenderOptions {
 // the cached renders, so a terminal resize re-decides without re-rendering.
 const cache = new Map<string, string | null>();
 
-/** Widest rendered row in display columns (ANSI- and CJK-aware). */
+/** Display columns, ignoring ANSI so themed diagrams are measured as drawn. */
+const DISPLAY_WIDTH = { countAnsiEscapeCodes: false } as const;
+
 function asciiDisplayWidth(ascii: string): number {
 	let max = 0;
 	for (const line of ascii.split("\n")) {
-		const width = Bun.stringWidth(line);
+		const width = Bun.stringWidth(line, DISPLAY_WIDTH);
 		if (width > max) max = width;
 	}
 	return max;
 }
 
+interface LayoutCandidate {
+	ascii: string;
+	width: number;
+	height: number;
+	authored: boolean;
+}
+
+function measureLayout(ascii: string, authored: boolean): LayoutCandidate {
+	return { ascii, width: asciiDisplayWidth(ascii), height: ascii.split("\n").length, authored };
+}
+
 function renderVariant(
 	source: string,
 	baseOptions: MermaidRenderOptions,
@@ -43,11 +54,39 @@ function renderVariant(
 	const cached = cache.get(key);
 	if (cached !== undefined) return cached;
 
-	const ascii = renderMermaidAsciiSafe(source, direction ? { ...baseOptions, direction } : baseOptions);
+	const ascii = mermaidAscii.renderMermaidAsciiSafe(source, direction ? { ...baseOptions, direction } : baseOptions);
 	cache.set(key, ascii);
 	return ascii;
 }
 
+const FORCED_DIRECTIONS = ["TD", "LR"] as const;
+type ForcedDirection = (typeof FORCED_DIRECTIONS)[number];
+
+/**
+ * Forced TD/LR renders that can differ from the authored one. Sequence, class,
+ * ER, and xychart ignore direction, so they get none; header match mirrors
+ * native `detect_diagram_kind`, including its JavaScript `\w` boundary
+ * (`[A-Za-z0-9_]`). A `graph`/`flowchart` header already authored in one of
+ * the forced layouts (`TD`/`TB` lay out as TD, `LR`/`RL` as LR) skips that
+ * variant: the native override replaces the header direction, so the render
+ * would be byte-identical to the authored one.
+ */
+function forcedDirections(source: string): readonly ForcedDirection[] {
+	const header = (source.split("\n", 1)[0] ?? "").trim().toLowerCase();
+	for (const prefix of ["xychart-beta", "xychart"] as const) {
+		if (!header.startsWith(prefix)) continue;
+		const next = header.charCodeAt(prefix.length);
+		const wordChar =
+			(next >= 48 && next <= 57) || (next >= 65 && next <= 90) || (next >= 97 && next <= 122) || next === 95;
+		if (!wordChar) return [];
+	}
+	if (header === "sequencediagram" || header === "classdiagram" || header === "erdiagram") return [];
+	const authored = /^(?:graph|flowchart)\s+(td|tb|lr|rl)$/.exec(header)?.[1];
+	if (authored === "td" || authored === "tb") return ["LR"];
+	if (authored === "lr" || authored === "rl") return ["TD"];
+	return FORCED_DIRECTIONS;
+}
+
 /**
  * Resolve mermaid ASCII from fenced block source text.
  * Returns null when rendering fails, while memoizing failures to avoid repeated work.
@@ -65,24 +104,43 @@ export function resolveMermaidAscii(source: string, options?: MermaidResolveOpti
 	if (base === null) return null;
 	if (maxWidth === undefined) return base;
 
-	let best = base;
-	let bestWidth = asciiDisplayWidth(base);
-	if (bestWidth <= maxWidth) return base;
-
-	// The as-authored layout overflows. Render both forced orientations and keep
-	// the narrowest (clipping at the call site handles any residual overflow).
-	// Re-rendering the already-authored orientation is a cache hit, so this stays
-	// cheap, and one of the two will be the perpendicular fit.
-	for (const direction of ["TD", "LR"] as const) {
+	// Width selection is against cached renders, so a later resize re-decides
+	// without drawing again. Only forced layouts that can differ from the
+	// authored one are rendered (see `forcedDirections`).
+	const candidates = [measureLayout(base, true)];
+	for (const direction of forcedDirections(normalizedSource)) {
 		const variant = renderVariant(normalizedSource, baseOptions, baseKey, direction);
-		if (variant === null) continue;
-		const variantWidth = asciiDisplayWidth(variant);
-		if (variantWidth < bestWidth) {
-			best = variant;
-			bestWidth = variantWidth;
+		if (variant !== null) candidates.push(measureLayout(variant, false));
+	}
+
+	const fitting = candidates.filter(candidate => candidate.width <= maxWidth);
+	const pool = fitting.length > 0 ? fitting : candidates;
+	let best = pool[0]!;
+	for (let i = 1; i < pool.length; i++) {
+		const next = pool[i]!;
+		if (fitting.length > 0) {
+			if (next.height !== best.height) {
+				if (next.height < best.height) best = next;
+				continue;
+			}
+			if (next.authored !== best.authored) {
+				if (next.authored) best = next;
+				continue;
+			}
+			if (next.width < best.width) best = next;
+			continue;
+		}
+		if (next.width !== best.width) {
+			if (next.width < best.width) best = next;
+			continue;
+		}
+		if (next.height !== best.height) {
+			if (next.height < best.height) best = next;
+			continue;
 		}
+		if (next.authored) best = next;
 	}
-	return best;
+	return best.ascii;
 }
 
 /**

package/src/tools/bash.ts

@@ -41,6 +41,13 @@ export interface BashToolDetails {
 	timedOut?: boolean;
 	/** Live ACP update only; completed results refer to released terminals. */
 	terminalId?: string;
+	service?: {
+		name: string;
+		state: string;
+		ready: boolean;
+		timedOut: boolean;
+		pid?: number;
+	};
 	async?: {
 		state: "running" | "completed" | "failed";
 		jobId: string;
@@ -362,6 +369,12 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 					if (details?.async?.state === "running") {
 						statsParts.push(`Backgrounded: ${details.async.jobId}`);
 					}
+					if (details?.service) {
+						const service = details.service;
+						statsParts.push(`Service: ${service.name}`, `State: ${service.state}`);
+						statsParts.push(`Ready: ${service.ready ? "yes" : service.timedOut ? "timed out" : "no"}`);
+						if (service.pid !== undefined) statsParts.push(`PID: ${service.pid}`);
+					}
 					if (wallTimeMs !== undefined) {
 						statsParts.push(`Wall: ${formatWallTimeSeconds(wallTimeMs)}s`);
 					}
@@ -460,7 +473,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 
 /** Renders bash command previews and output. */
 export const bashToolRenderer = createShellRenderer<BashRenderArgs>({
-	resolveTitle: () => "Bash",
+	resolveTitle: args => (args?.name ? `Bash · ${String(args.name)}` : "Bash"),
 	resolveCommand: args => args?.command,
 	resolveCwd: args => args?.cwd,
 	resolveEnv: args => args?.env,

package/src/tools/cfg-render.ts

@@ -0,0 +1,117 @@
+/**
+ * Transcript renderers for `cfg://` settings reads and writes.
+ *
+ * Reads show the YAML-ish settings listing the model received, highlighted as
+ * YAML. Writes show the `previous → value` change, its scope (session or
+ * saved), and whether the user approved it.
+ */
+import type { Component } from "../tui";
+import { renderStatusLine } from "../render";
+import {
+	cappedHeadLines,
+	formatBadge,
+	formatErrorDetail,
+	formatMoreItems,
+	PREVIEW_LIMITS,
+} from "../render/render-utils";
+import { highlightCode, type Theme } from "../theme/theme";
+import { parseCfgUrl } from "./cfg-url";
+import type { RenderResultOptions } from "./renderer";
+import { card, type CardToolResult, firstText, safe } from "./result-card";
+
+/** Summary of a `cfg://` read, attached to read tool details. */
+export interface CfgReadDetails {
+	/** Dotted setting path or namespace that was read; empty for the whole tree. */
+	path: string;
+	/** Settings in the listing. */
+	count: number;
+	/** Listed settings whose effective value differs from the schema default. */
+	modified: number;
+}
+
+/** How a `cfg://` write ended. */
+export type CfgWriteOutcome = "applied" | "declined" | "unchanged";
+
+/** A `cfg://` write, attached to write tool details. Values are display-formatted (credentials redacted). */
+export interface CfgWriteDetails {
+	path: string;
+	/** Persisted to config.yml rather than scoped to the session. */
+	save: boolean;
+	previous: string;
+	value: string;
+	outcome: CfgWriteOutcome;
+	/** Effective value after saving when a higher-precedence layer still shadows the saved one. */
+	effective?: string;
+}
+
+/** Render `read cfg://…`: pending header, or the highlighted listing with counts. */
+export function renderCfgRead(
+	url: string,
+	result: CardToolResult | undefined,
+	details: CfgReadDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card((_width, expanded) => {
+		const meta: string[] = [];
+		if (details) {
+			meta.push(details.count === 1 ? "1 setting" : `${details.count} settings`);
+			if (details.modified) meta.push(`${details.modified} modified`);
+		}
+		const header = renderStatusLine(
+			{
+				icon: result === undefined ? "pending" : result.isError ? "error" : "info",
+				title: "Config",
+				description: (details?.path ?? parseCfgUrl(url)?.segments.join(".")) || "all settings",
+				meta,
+			},
+			theme,
+		);
+		if (!result) return [header];
+		if (result.isError) return [header, formatErrorDetail(firstText(result) || "Settings read failed.", theme)];
+		const body = firstText(result).trimEnd().split("\n");
+		const shown = cappedHeadLines(body, expanded ? body.length : PREVIEW_LIMITS.COLLAPSED_ITEMS);
+		const lines = [header, ...highlightCode(safe(shown.lines.join("\n")), "yaml", theme).map(line => `  ${line}`)];
+		if (shown.hidden) lines.push(theme.fg("dim", `  ${formatMoreItems(shown.hidden, "line")}`));
+		return lines;
+	}, options);
+}
+
+/** Render `write cfg://…[/save]`: the proposed value while pending, then the approved/declined change. */
+export function renderCfgWrite(
+	url: string,
+	content: string | undefined,
+	result: CardToolResult | undefined,
+	details: CfgWriteDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card(() => {
+		const target = parseCfgUrl(url);
+		const save = details?.save ?? target?.save ?? false;
+		const icon =
+			result === undefined
+				? "pending"
+				: result.isError
+					? "error"
+					: details?.outcome === "declined"
+						? "warning"
+						: "success";
+		const badges = [formatBadge(save ? "persist" : "session", save ? "accent" : "muted", theme)];
+		if (details?.outcome === "declined") badges.push(formatBadge("declined", "warning", theme));
+		if (details?.outcome === "unchanged") badges.push(formatBadge("unchanged", "muted", theme));
+		const header = `${renderStatusLine({ icon, title: "Config", description: details?.path ?? target?.segments.join(".") }, theme)} ${badges.join(" ")}`;
+		if (result?.isError) return [header, formatErrorDetail(firstText(result) || "Settings write failed.", theme)];
+		const arrow = theme.fg("dim", "→");
+		const next = theme.fg("toolOutput", details?.value ?? content?.trim() ?? "…");
+		const lines = [
+			header,
+			details ? `  ${theme.fg("dim", details.previous)} ${arrow} ${next}` : `  ${arrow} ${next}`,
+		];
+		if (details?.effective !== undefined)
+			lines.push(
+				theme.fg("warning", `  still ${details.effective}: a higher-precedence layer overrides the saved value`),
+			);
+		return lines;
+	}, options);
+}

package/src/tools/cfg-url.ts

@@ -0,0 +1,30 @@
+/** Canonical prefix for settings URLs. */
+export const CFG_URL_PREFIX = "cfg://";
+
+/** Trailing write segment that persists a `cfg://` change instead of scoping it to the session. */
+export const CFG_SAVE_SEGMENT = "save";
+
+/** Setting addressed by a `cfg://` URL. */
+export interface CfgTarget {
+	/** Setting path segments; empty for the root. `/` and `.` both separate segments. */
+	segments: string[];
+	/** Whether the URL ends in the `/save` suffix, which is removed from {@link segments}. */
+	save: boolean;
+}
+
+/**
+ * Parse a `cfg://` URL (`cfg://advisor/enabled`, `cfg://advisor.enabled/save`).
+ * Returns `null` for other schemes; query and fragment are ignored.
+ */
+export function parseCfgUrl(input: string): CfgTarget | null {
+	const trimmed = input.trim();
+	if (!trimmed.toLowerCase().startsWith(CFG_URL_PREFIX)) return null;
+	const segments = trimmed
+		.slice(CFG_URL_PREFIX.length)
+		.replace(/[?#].*$/s, "")
+		.split(/[/.]/)
+		.filter(Boolean);
+	const save = segments.length > 1 && segments.at(-1) === CFG_SAVE_SEGMENT;
+	if (save) segments.pop();
+	return { segments, save };
+}

package/src/tools/daemon.ts

@@ -0,0 +1,51 @@
+/** Launch-broker daemon types shared by services, `proc://`, and `omp ps`. */
+
+/** Stable lifecycle states exposed by the launch broker. */
+export type DaemonState = "starting" | "running" | "ready" | "restarting" | "stopping" | "exited" | "failed";
+
+/** Restart behavior applied after an unexpected daemon exit. */
+export type DaemonRestartPolicy = "no" | "on-failure" | "always";
+
+/** Readiness conditions; every configured condition must pass. */
+export interface DaemonReadySpec {
+	log?: string;
+	port?: number;
+	host?: string;
+	timeoutMs: number;
+}
+
+/** Immutable launch specification retained for restart and inspection. */
+export interface DaemonSpec {
+	name: string;
+	application: string;
+	args: string[];
+	env: Record<string, string>;
+	cwd: string;
+	pty: boolean;
+	ready?: DaemonReadySpec;
+	restart: DaemonRestartPolicy;
+	persist: boolean;
+	detached: boolean;
+}
+
+/** Serializable daemon state visible to every client in one broker scope. */
+export interface DaemonSnapshot {
+	name: string;
+	id: string;
+	state: DaemonState;
+	pid?: number;
+	createdAt: number;
+	startedAt: number;
+	readyAt?: number;
+	exitedAt?: number;
+	exitCode?: number;
+	exitReason?: string;
+	restartCount: number;
+	outputBytes: number;
+	owner?: string;
+	readyMatch?: string;
+	/** Readiness conditions still unmet while `state` is `starting`; absent once ready or without a ready spec. */
+	readyPending?: ("log" | "port")[];
+	persist: boolean;
+	detached: boolean;
+}

package/src/tools/find.ts

@@ -28,6 +28,7 @@ import type { Theme, ThemeColor } from "../theme/theme";
 import type { Component } from "../tui";
 import type { OutputMeta } from "./output-meta";
 import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import { splitUrlScheme } from "./url-scheme-host";
 
 /** A verified line range with its yes-probability and a one-line preview. */
 export interface FindRange {
@@ -39,7 +40,7 @@ export interface FindRange {
 
 /** A file whose verified passages cleared the threshold; `ranges` are merged positive spans, strongest first. */
 export interface FindHit {
-	/** Display path relative to {@link FindToolDetails.cwd}, or an `omp://` doc URL for docs scopes. */
+	/** Display path relative to {@link FindToolDetails.cwd}, or an internal URL under URL scopes. */
 	rel: string;
 	/** Filename judgment, when the name batch answered. */
 	nameScore?: number;
@@ -85,7 +86,7 @@ export interface FindToolDetails {
 	elapsedMs: number;
 	/** Session cwd; hit paths are relative to it. */
 	cwd: string;
-	/** Display form of the searched directory when narrower than cwd. */
+	/** Display form of the searched directory or file when narrower than cwd. */
 	scopePath?: string;
 	meta?: OutputMeta;
 }
@@ -124,11 +125,11 @@ function gauge(p: number, theme: Theme): string {
 }
 
 function renderHit(hit: FindHit, rangeLimit: number, cwd: string | undefined, theme: Theme): string[] {
-	// `omp://` hits are virtual docs, not files under `cwd`: link the URL
-	// itself instead of joining it onto a filesystem base.
-	const isOmpHit = /^omp:\/\//i.test(hit.rel);
+	// `scheme://` hits (e.g. virtual docs) are not files under `cwd`: link the
+	// URL itself instead of joining it onto a filesystem base.
+	const isUrlHit = splitUrlScheme(hit.rel) !== undefined;
 	const link = (text: string, line?: number): string => {
-		if (isOmpHit) return uriHyperlink(line === undefined ? hit.rel : `${hit.rel}:${line}`, text);
+		if (isUrlHit) return uriHyperlink(line === undefined ? hit.rel : `${hit.rel}:${line}`, text);
 		const absPath = cwd === undefined ? undefined : path.join(cwd, hit.rel);
 		return absPath === undefined ? text : fileHyperlink(absPath, text, { line });
 	};

package/src/tools/index.ts

@@ -15,7 +15,7 @@ import { githubToolRenderer } from "./github";
 import { globToolRenderer } from "./glob";
 import { goalToolRenderer } from "./goal";
 import { grepToolRenderer } from "./grep";
-import { hubToolRenderer } from "./hub";
+import { waitToolRenderer } from "./wait";
 import { lspToolRenderer } from "./lsp";
 import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory";
 import { readToolRenderer } from "./read";
@@ -45,7 +45,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	glob: globToolRenderer,
 	grep: grepToolRenderer,
 	lsp: lspToolRenderer,
-	hub: hubToolRenderer,
+	wait: waitToolRenderer,
 	read: readToolRenderer,
 	// Keyed by xd:// resolution-device names: the write dispatch delegates here
 	// by dispatch tool, and historical `resolve` tool transcripts still render

package/src/tools/irc.ts

@@ -0,0 +1,33 @@
+/** Peer-message types and roster constants shared by messaging, `wait`, and child prompts. */
+
+/** Maximum live peer rows embedded in child prompts. */
+export const DEFAULT_PEER_ROSTER_LIMIT = 32;
+
+/** Serializable peer message retained in coordination result snapshots. */
+export interface IrcMessage {
+	id: string;
+	/** Sender agent id. */
+	from: string;
+	/** Recipient agent id (resolved; "all" is expanded by the tool, not stored). */
+	to: string;
+	body: string;
+	ts: number;
+	/** Message id being answered. */
+	replyTo?: string;
+	/**
+	 * Automated wake-turn relay of a woken subagent's stop output (task executor
+	 * `relayWakeTurnOutput`). Relays are answers, never wake sources: the
+	 * recipient's own wake-turn relay must skip them or two idle peers
+	 * ping-pong forever.
+	 */
+	wakeRelay?: boolean;
+}
+
+/** Delivery outcome for one peer recipient. */
+export interface IrcDeliveryReceipt {
+	to: string;
+	outcome: "injected" | "woken" | "revived" | "failed";
+	error?: string;
+}
+/** Status ordering for peer rosters in child prompts. */
+export const LIST_STATUS_ORDER: Record<string, number> = { running: 0, idle: 1, parked: 2 };

package/src/tools/line-ranges.ts

@@ -15,6 +15,11 @@ const LINE_RANGE_CHUNK_RE = new RegExp(`^${LINE_RANGE_CHUNK_SOURCE}$`, "i");
 
 /** Parse a single `N`, `N-M`, `N-`, `N+K`, or `..`-aliased (`N..M`, `N..`) chunk. Throws via {@link ToolError} on invalid bounds. */
 export function parseLineRangeChunk(sel: string): LineRange | null {
+	return parseChunk(sel, false);
+}
+
+/** `pinBare` makes a separator-less `N` the single line `N` instead of "from `N` onward". */
+function parseChunk(sel: string, pinBare: boolean): LineRange | null {
 	const lineMatch = LINE_RANGE_CHUNK_RE.exec(sel);
 	if (!lineMatch) return null;
 	const rawStart = Number.parseInt(lineMatch[1]!, 10);
@@ -31,27 +36,32 @@ export function parseLineRangeChunk(sel: string): LineRange | null {
 		}
 		rawEnd = rawStart + rhs - 1;
 	} else if (sep === "-") {
-		// `301-` is shorthand for "from 301 onward" — equivalent to bare `301`.
+		// `301-` is shorthand for "from 301 onward" — equivalent to a lone bare `301`.
 		if (rhs !== undefined) {
 			if (rhs < rawStart) {
 				throw new ToolError(`Invalid range ${rawStart}-${rhs}: end must be >= start.`);
 			}
 			rawEnd = rhs;
 		}
+	} else if (pinBare) {
+		rawEnd = rawStart;
 	}
 	return { startLine: rawStart, endLine: rawEnd };
 }
 
 /**
- * Parse a comma-separated list of line ranges (e.g. `5-16,960-973`). Returns
+ * Parse a comma-separated list of line ranges (e.g. `5-16,960-973` or `19,59`). Returns
  * the ranges in ascending order with overlapping/adjacent ranges merged so
  * downstream consumers can stream the file in a single forward pass per range.
  */
 export function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null {
 	const chunks = sel.split(",");
+	// A lone `:50` means "from line 50". Inside a comma list, a bare number is
+	// that one line; otherwise `:19,59` collapses to "from 19 through EOF".
+	const pinBare = chunks.length > 1;
 	const parsed: LineRange[] = [];
 	for (const chunk of chunks) {
-		const range = parseLineRangeChunk(chunk);
+		const range = parseChunk(chunk, pinBare);
 		if (!range) return null;
 		parsed.push(range);
 	}

package/src/tools/output-meta.ts

@@ -72,6 +72,8 @@ export interface OutputMeta {
 	/** Capture failure of this output itself; aggregate reports keep source failures on their entries. */
 	artifactError?: OutputArtifactError;
 	source?: SourceMeta;
+	/** The output is a bounded page of session artifact storage its `source` re-reads with line selectors; spill-to-artifact skips it. */
+	pagedSource?: true;
 	diagnostics?: DiagnosticMeta;
 	limits?: LimitsMeta;
 }