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

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/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/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/proc-render.ts

@@ -0,0 +1,294 @@
+import type { Component } from "../tui";
+import { createCachedComponent, Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../render";
+import {
+	cappedHeadLines,
+	formatBadge,
+	formatDuration,
+	formatErrorDetail,
+	formatStatusIcon,
+	PREVIEW_LIMITS,
+	TRUNCATE_LENGTHS,
+	replaceTabs,
+	type ToolUIColor,
+} from "../render/render-utils";
+import type { Theme } from "../theme/theme";
+import type { RenderResultOptions } from "./renderer";
+import type { AgentActivitySnapshot, CoordinationDetails, JobSnapshot } from "./wait";
+import type { IrcDeliveryReceipt } from "./irc";
+import type { DaemonSnapshot } from "./daemon";
+import { styleTerminalRow } from "./terminal-output";
+
+export interface ProcReadDetails {
+	jobs?: JobSnapshot[];
+	agents?: AgentActivitySnapshot[];
+	daemons?: DaemonSnapshot[];
+	job?: JobSnapshot;
+	daemon?: DaemonSnapshot;
+	log?: string;
+	terminalRows?: string[];
+}
+
+export type ProcWriteDetails =
+	| CoordinationDetails
+	| { action: "stop" | "stdin" | "mode"; daemon: DaemonSnapshot; input?: string; mode?: string };
+
+/** Process operation selected by a write URL, independent of its content. */
+export type ProcWriteAction = "stdin" | "mode" | "kill";
+
+interface ToolResult {
+	content: Array<{ type: string; text?: string }>;
+	isError?: boolean;
+}
+
+function firstText(result: ToolResult): string {
+	return result.content.find(item => item.type === "text")?.text ?? "";
+}
+
+function safe(value: string): string {
+	return replaceTabs(value).replace(/\r/g, "");
+}
+
+function card(lines: (width: number, expanded: boolean) => string[], options: RenderResultOptions): Component {
+	return createCachedComponent(
+		() => Boolean(options.expanded),
+		(width, expanded) =>
+			lines(width, expanded)
+				.flatMap(line => line.split("\n"))
+				.map(line => truncateToWidth(safe(line), width, Ellipsis.Unicode)),
+		{ paddingX: 1 },
+	);
+}
+
+function preview(body: string, expanded: boolean, theme: Theme, tone: "dim" | "toolOutput" = "dim"): string[] {
+	if (!body.trim()) return [];
+	const limit = expanded ? PREVIEW_LIMITS.EXPANDED_LINES : PREVIEW_LIMITS.COLLAPSED_LINES;
+	const shown = cappedHeadLines(
+		body.split("\n").filter(line => line.trim()),
+		limit,
+	);
+	const quote = theme.fg("dim", theme.md.quoteBorder);
+	const lines = shown.lines.map(
+		line =>
+			`  ${quote} ${theme.fg(tone, truncateToWidth(safe(line.trim()), TRUNCATE_LENGTHS.LINE, Ellipsis.Unicode))}`,
+	);
+	if (shown.hidden) lines.push(`  ${quote} ${theme.fg("dim", `… +${shown.hidden} more lines`)}`);
+	return lines;
+}
+
+function receiptColor(outcome: IrcDeliveryReceipt["outcome"]): ToolUIColor {
+	return outcome === "failed" ? "error" : outcome === "revived" ? "warning" : "success";
+}
+
+export function renderAgentWrite(
+	to: string,
+	body: string,
+	result: ToolResult | undefined,
+	details: CoordinationDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card((width, expanded) => {
+		const recipient = safe(details?.to || to || "…");
+		const title = `IRC ${theme.nav.selected} ${recipient}`;
+		const receipts = details?.receipts ?? [];
+		const delivered = receipts.filter(receipt => receipt.outcome !== "failed").length;
+		const failed = receipts.length - delivered;
+		const error = result?.isError || (failed > 0 && delivered === 0);
+		const meta: string[] = [];
+		if (recipient === "all") meta.push("broadcast");
+		if (receipts.length === 1) meta.push(theme.fg(receiptColor(receipts[0]!.outcome), receipts[0]!.outcome));
+		else if (receipts.length > 1) {
+			if (delivered) meta.push(theme.fg("success", `${delivered} delivered`));
+			if (failed) meta.push(theme.fg("error", `${failed} failed`));
+		}
+		const header = renderStatusLine(
+			result === undefined
+				? { icon: "pending", title, meta }
+				: error
+					? { icon: "error", title, meta }
+					: { iconOverride: theme.styledSymbol("tool.irc", "accent"), title, meta },
+			theme,
+		);
+		if (result?.isError && receipts.length === 0)
+			return [header, formatErrorDetail(firstText(result) || "Message delivery failed.", theme)];
+		const lines = [header, ...preview(body, expanded, theme)];
+		if (result && receipts.length === 0)
+			lines.push(theme.fg("muted", firstText(result) || "No live peers to broadcast to."));
+		if (receipts.length > 1 || failed > 0) {
+			lines.push(
+				...renderTreeList(
+					{
+						items: receipts,
+						expanded,
+						maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+						itemType: "recipient",
+						renderItem: receipt =>
+							`${theme.fg("toolOutput", safe(receipt.to))} ${formatBadge(receipt.outcome, receiptColor(receipt.outcome), theme)}${receipt.error ? ` ${theme.fg("error", `${theme.format.dash} ${safe(receipt.error)}`)}` : ""}`,
+					},
+					theme,
+				),
+			);
+		}
+		return lines.map(line => truncateToWidth(line, width, Ellipsis.Unicode));
+	}, options);
+}
+
+function daemonMeta(daemon: DaemonSnapshot, theme: Theme): string[] {
+	const stateColor =
+		daemon.state === "ready" || daemon.state === "running"
+			? "success"
+			: daemon.state === "failed"
+				? "error"
+				: "warning";
+	const meta = [theme.fg(stateColor, daemon.state)];
+	if (daemon.pid !== undefined) meta.push(`pid ${daemon.pid}`);
+	meta.push(
+		`${daemon.exitedAt === undefined ? "up" : "ran"} ${formatDuration(Math.max(0, (daemon.exitedAt ?? Date.now()) - daemon.startedAt))}`,
+	);
+	if (daemon.detached) meta.push("detached");
+	else if (daemon.persist) meta.push("persistent");
+	return meta;
+}
+
+function jobRow(job: JobSnapshot, theme: Theme): string {
+	const icon = formatStatusIcon(
+		job.status === "cancelled"
+			? "aborted"
+			: job.status === "failed"
+				? "error"
+				: job.status === "running"
+					? "running"
+					: "done",
+		theme,
+	);
+	return `${icon} ${formatBadge(job.type, job.status === "failed" ? "error" : job.status === "cancelled" ? "warning" : "accent", theme)} ${theme.fg("toolOutput", safe(job.id))} ${theme.fg("dim", safe(job.label))} ${theme.fg("dim", formatDuration(job.durationMs))}`;
+}
+
+/** Render live and completed process writes with the URL-selected operation. */
+export function renderProcWrite(
+	id: string,
+	action: ProcWriteAction,
+	content: string | undefined,
+	result: ToolResult | undefined,
+	details: ProcWriteDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card((_width, expanded) => {
+		const title = `Proc ${action} ${safe(id || "…")}`;
+		const daemon = details && "daemon" in details ? details.daemon : undefined;
+		const header = renderStatusLine(
+			{
+				icon:
+					result === undefined ? "pending" : result.isError ? "error" : action === "kill" ? "aborted" : "success",
+				title,
+				meta: daemon ? daemonMeta(daemon, theme) : action === "mode" && content ? [safe(content)] : [],
+			},
+			theme,
+		);
+		if (result?.isError) return [header, formatErrorDetail(firstText(result) || "Process operation failed.", theme)];
+		const lines = [header];
+		if (content && action === "stdin") lines.push(...preview(content, expanded, theme));
+		if (details && "op" in details && details.op === "cancel") {
+			const jobs = details.jobs ?? [];
+			const outcomes = details.cancelled ?? [];
+			lines.push(
+				...renderTreeList(
+					{
+						items: outcomes,
+						expanded,
+						maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+						itemType: "job",
+						renderItem: outcome => {
+							const job = jobs.find(item => item.id === outcome.id);
+							return `${job ? `${jobRow(job, theme)} ` : `${theme.fg("toolOutput", safe(outcome.id))} `}${formatBadge(outcome.status, outcome.status === "cancelled" ? "warning" : "error", theme)}`;
+						},
+					},
+					theme,
+				),
+			);
+		}
+		return lines;
+	}, options);
+}
+
+export function renderProcRead(
+	id: string,
+	result: ToolResult | undefined,
+	details: ProcReadDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card((_width, expanded) => {
+		const title = id ? `Proc ${safe(id)}` : "Proc jobs & services";
+		const daemon = details?.daemon;
+		const header = renderStatusLine(
+			{
+				icon: result === undefined ? "pending" : result.isError ? "error" : "info",
+				title,
+				meta: daemon ? daemonMeta(daemon, theme) : [],
+			},
+			theme,
+		);
+		if (result?.isError) return [header, formatErrorDetail(firstText(result) || "Process read failed.", theme)];
+		if (!result) return [header];
+		if (details?.job)
+			return [
+				header,
+				jobRow(details.job, theme),
+				...preview(
+					details.log ?? details.job.errorText ?? details.job.resultText ?? "",
+					expanded,
+					theme,
+					"toolOutput",
+				),
+			];
+		if (daemon) {
+			const output = details.terminalRows ?? (details.log ?? "").split("\n").filter(Boolean);
+			const limit = expanded ? PREVIEW_LIMITS.EXPANDED_LINES : PREVIEW_LIMITS.COLLAPSED_LINES;
+			const visible = output
+				.slice(-limit)
+				.map(
+					line =>
+						`  ${styleTerminalRow(truncateToWidth(safe(line), TRUNCATE_LENGTHS.LINE, Ellipsis.Unicode), theme.fg("toolOutput", ""))}`,
+				);
+			if (output.length > limit) visible.unshift(theme.fg("dim", `  … ${output.length - limit} earlier lines`));
+			return [header, ...visible];
+		}
+		if (id && !details?.jobs && !details?.daemons && !details?.agents) {
+			return [header, ...preview(firstText(result), expanded, theme, "toolOutput")];
+		}
+		const jobs = details?.jobs ?? [];
+		const services = details?.daemons ?? [];
+		const agents = details?.agents ?? [];
+		const meta = [
+			`${jobs.length} jobs`,
+			`${services.length} services`,
+			...(agents.length ? [`${agents.length} agents`] : []),
+		];
+		const listHeader = renderStatusLine({ icon: "info", title, meta }, theme);
+		const items = [
+			...jobs.map(job => ({ label: jobRow(job, theme) })),
+			...services.map(service => ({
+				label: `${formatBadge("service", "accent", theme)} ${theme.fg("toolOutput", safe(service.name))} ${formatBadge(service.state, service.state === "failed" ? "error" : service.state === "ready" || service.state === "running" ? "success" : "warning", theme)} ${daemonMeta(service, theme).slice(1).join(theme.sep.dot)}`,
+			})),
+			...agents.map(agent => ({
+				label: `${formatBadge("agent", agent.live ? "accent" : "warning", theme)} ${theme.fg("toolOutput", safe(agent.id))} ${theme.fg("dim", formatDuration(agent.ageMs))}`,
+			})),
+		];
+		return [
+			listHeader,
+			...renderTreeList(
+				{
+					items,
+					expanded,
+					maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+					itemType: "process",
+					renderItem: item => item.label,
+				},
+				theme,
+			),
+			...(items.length ? [] : [theme.fg("dim", "No background jobs or services.")]),
+		];
+	}, options);
+}