@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/tools/vibe.ts

@@ -1,6 +1,12 @@
 import type { Component } from "../tui";
 import { Text } from "../components/text";
-import { shimmerEnabled, shimmerText } from "../theme/shimmer";
+import { describeShimmer, shimmerEnabled, shimmerText } from "../theme/shimmer";
+import type { TspCardStatus, TspSpan, TspTone } from "@oh-my-pi/pi-wire";
+import { compact, elapsed, node, row, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, noteText, resultText, toolHead } from "./native-view";
 import type { Theme } from "../theme/theme";
 import { oneLineLabel } from "./task";
 import { renderStatusLine } from "../render/index";
@@ -14,7 +20,7 @@ import {
 	type ToolUIStatus,
 	truncateToWidth,
 } from "../render/render-utils";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolView, RenderResultOptions, ToolRenderer, ToolRenderResult } from "./renderer";
 /** Operation represented by a worker-session tool result. */
 export type VibeOp = "spawn" | "send" | "wait" | "kill" | "list";
 
@@ -294,9 +300,206 @@ function describeCall(op: VibeOp, args: VibeRenderArgs | undefined): string {
 	}
 }
 
+// =============================================================================
+// Native (TSP) Description — the terminal clocks spinners, shimmer and timers
+// =============================================================================
+
+/** Untruncated head detail for a vibe call (native twin of the ANSI call label). */
+function vibeNativeLabel(op: VibeOp, args: VibeRenderArgs | undefined): string {
+	switch (op) {
+		case "spawn":
+			return `spawn ${args?.cli ?? "?"}${args?.name ? ` · ${args.name}` : ""}`;
+		case "send":
+			return `send → ${args?.session ?? "?"}`;
+		case "wait":
+			return args?.sessions?.length ? `wait on ${args.sessions.join(", ")}` : "wait on running sessions";
+		case "kill":
+			return `kill ${args?.session ?? "?"}`;
+		case "list":
+			return "sessions";
+	}
+}
+
+/** The director's composed message as `>`-prefixed wrapped text, or undefined when empty. */
+function vibeComposer(message: string): NativeNode | undefined {
+	const trimmed = plainText(message).trim();
+	if (!trimmed) return undefined;
+	return text([span("> ", "accent"), span(trimmed, "toolOutput")], { wrap: "word", role: "omp.vibe.composer" });
+}
+
+function vibeScreenStatus(
+	screen: VibeScreenSnapshot,
+	settled: "completed" | "failed" | "cancelled" | undefined,
+): [TspCardStatus, TspTone] {
+	if (settled === "failed") return ["error", "error"];
+	if (settled === "cancelled") return ["cancelled", "warning"];
+	if (settled === "completed") return ["done", "success"];
+	switch (screen.state) {
+		case "running":
+			return ["running", "accent"];
+		case "starting":
+			return ["pending", "accent"];
+		case "idle":
+			return ["done", "success"];
+		case "dead":
+			return ["cancelled", "muted"];
+	}
+}
+
+/** One worker "TV" as a nested card: identity head, roster meta, live trace, output tail. */
+function describeVibeScreen(
+	screen: VibeScreenSnapshot,
+	settled: "completed" | "failed" | "cancelled" | undefined,
+	nowMs: number,
+): NativeNode {
+	const live = screen.state === "running" || screen.state === "starting";
+	const [status, tone] = vibeScreenStatus(screen, settled);
+	const head: TspSpan[] = [
+		live && shimmerEnabled()
+			? span(screen.id, "accent", { fx: "shimmer" })
+			: span(screen.id, live ? "accent" : "toolOutput"),
+		span(` ${settled ?? screen.state}`, "dim"),
+		span(` ${screen.turns}t${screen.queued > 0 ? `+${screen.queued}q` : ""}`, "muted"),
+	];
+	if (screen.model) head.push(span(` ${plainText(screen.model)}`, "muted"));
+	const body: NativeChild[] = [
+		row(
+			compact([
+				node("badge", { text: screen.cli, tone }),
+				screen.turnStartedAt !== undefined ? elapsed(nowMs - screen.turnStartedAt, !live) : undefined,
+			]),
+			{ gap: "sm" },
+		),
+	];
+	if (live) {
+		if (screen.turnMessage) {
+			body.push(text([span("> ", "accent"), span(plainText(screen.turnMessage), "dim")], { truncate: "end" }));
+		}
+		for (const line of screen.trace.slice(-TV_TRACE_EXPANDED)) {
+			body.push(text([span(plainText(line), "dim")], { truncate: "end" }));
+		}
+		const detail = screen.lastIntent ?? screen.currentToolArgs;
+		if (screen.currentTool) {
+			body.push(describeShimmer([{ text: plainText(`${screen.currentTool}${detail ? `: ${detail}` : ""}`) }]));
+		} else if (screen.lastIntent) {
+			body.push(text([span(plainText(screen.lastIntent), "muted")], { truncate: "end" }));
+		}
+		for (const line of screen.outputTail.slice(-TV_OUTPUT_EXPANDED)) {
+			if (line.trim().length > 0) body.push(text([span(plainText(line), "muted")], { truncate: "end" }));
+		}
+	} else if (screen.lastActivity) {
+		body.push(text([span(plainText(screen.lastActivity), "muted")], { truncate: "end" }));
+	}
+	if (settled) {
+		body.push(
+			text([
+				span(
+					`turn ${settled} — result delivered`,
+					settled === "completed" ? "success" : settled === "failed" ? "error" : "warning",
+				),
+			]),
+		);
+	}
+	return node(
+		"card",
+		{
+			role: "omp.vibe.screen",
+			status,
+			tone,
+			head,
+			collapsible: true,
+			preview: { lines: 1 + TV_TRACE_COLLAPSED + TV_OUTPUT_COLLAPSED + 1 },
+			inset: true,
+		},
+		body,
+		screen.id,
+	);
+}
+
+function describeVibeResult(
+	op: VibeOp,
+	result: ToolRenderResult<VibeToolDetails>,
+	args: VibeRenderArgs | undefined,
+): NativeToolView {
+	const details = result.details;
+	const label = vibeNativeLabel(op, args);
+	if (result.isError) return { ...errorView("Vibe", resultText(result) || "vibe failed", label), inline: true };
+	if (!details) {
+		const fallback = resultText(result).trim();
+		return { head: toolHead("Vibe", label), inline: true, body: fallback ? [noteText(fallback)] : [] };
+	}
+
+	if (op === "spawn" || op === "send") {
+		const message = op === "spawn" ? (args?.prompt ?? "") : (args?.message ?? "");
+		const head: TspSpan[] =
+			op === "spawn"
+				? [
+						...toolHead("Vibe", "spawn"),
+						span(" "),
+						span(details.spawned?.cli ?? args?.cli ?? "?", "accent strong"),
+						span(" "),
+						span(plainText(details.spawned?.id ?? args?.name ?? ""), "accent"),
+					]
+				: [...toolHead("Vibe", "send →"), span(" "), span(plainText(args?.session ?? "?"), "accent")];
+		const ack: TspSpan =
+			op === "spawn"
+				? span(`turn started${details.spawned ? ` (job ${details.spawned.jobId})` : ""}`, "success")
+				: details.send?.mode === "steered"
+					? span("steered into the running turn", "success")
+					: details.send?.mode === "queued"
+						? span("mid-turn — queued as the next turn", "warning")
+						: span(`turn started${details.send?.jobId ? ` (job ${details.send.jobId})` : ""}`, "success");
+		return {
+			head,
+			inline: true,
+			tone: details.send?.mode === "queued" ? "warning" : undefined,
+			body: compact([vibeComposer(message), text([ack], { wrap: "word" })]),
+			preview: { lines: 3 },
+		};
+	}
+
+	if (op === "kill") {
+		const note = details.killed?.cancelledTurn ? "in-flight turn cancelled" : undefined;
+		return { head: toolHead("Vibe", `kill ${details.killed?.id ?? args?.session ?? "?"}`, note), inline: true };
+	}
+
+	const screens = details.screens;
+	const hiddenKilled = details.hiddenKilled?.length ?? 0;
+	const killedMeta = hiddenKilled > 0 ? span(` · ${hiddenKilled} killed hidden`, "dim") : undefined;
+	if (screens.length === 0) {
+		const gist = hiddenKilled > 0 ? "no live sessions" : resultText(result).trim() || "no sessions";
+		const head = toolHead("Vibe", op, gist);
+		if (killedMeta) head.push(killedMeta);
+		return { head, tone: "warning", inline: true };
+	}
+	const settledById = new Map(details.wait?.settled.map(entry => [entry.id, entry.status] as const) ?? []);
+	const running = screens.filter(screen => screen.state === "running" || screen.state === "starting").length;
+	const title =
+		op === "wait"
+			? details.wait?.waiting === true
+				? "wait — watching the wall"
+				: "wait"
+			: `sessions (${screens.length})`;
+	const head: TspSpan[] = toolHead("Vibe", title);
+	if (running > 0) head.push(span(` · ${running} on air`, "accent"));
+	if (settledById.size > 0) head.push(span(` · ${settledById.size} settled`, "success"));
+	if (details.wait?.timedOut) head.push(span(" · timed out", "warning"));
+	if (killedMeta) head.push(killedMeta);
+	const nowMs = Date.now();
+	return {
+		head,
+		inline: true,
+		tone: details.wait?.timedOut ? "warning" : undefined,
+		body: screens.map(screen => describeVibeScreen(screen, settledById.get(screen.id), nowMs)),
+		preview: "auto",
+	};
+}
+
 /** Build the shared vibe renderer for one tool name. */
 export function createVibeToolRenderer(op: VibeOp) {
 	const composerOp = op === "spawn" || op === "send";
+	const callMemo = new OwnerMemo<NativeToolView | undefined>();
+	const resultMemo = new OwnerMemo<NativeToolView | undefined>();
 	return {
 		inline: true,
 		mergeCallAndResult: true,
@@ -429,5 +632,30 @@ export function createVibeToolRenderer(op: VibeOp) {
 				return lines;
 			});
 		},
+
+		describeCall(args: VibeRenderArgs): NativeToolView | undefined {
+			const message = op === "spawn" ? (args?.prompt ?? "") : op === "send" ? (args?.message ?? "") : "";
+			return callMemo.get(args, [vibeNativeLabel(op, args), message], () => {
+				const head = toolHead("Vibe", vibeNativeLabel(op, args));
+				if (!composerOp) return { head, inline: true };
+				return {
+					head,
+					inline: true,
+					body: compact([
+						vibeComposer(message),
+						node("spinner", { label: [span(op === "spawn" ? "booting CLI…" : "delivering…", "dim")] }),
+					]),
+					preview: { lines: 3 },
+				};
+			});
+		},
+
+		describeResult(
+			result: ToolRenderResult<VibeToolDetails>,
+			_options: RenderResultOptions,
+			args?: VibeRenderArgs,
+		): NativeToolView | undefined {
+			return resultMemo.get(result, [], () => describeVibeResult(op, result, args));
+		},
 	} satisfies ToolRenderer<VibeRenderArgs, VibeToolDetails>;
 }

package/src/tools/wait.ts

@@ -26,6 +26,13 @@ import {
 import type { StructuredSubagentOutput } from "./task";
 import type { RenderResultOptions, ToolRenderer, ToolActivitySummary } from "./renderer";
 import type { IrcDeliveryReceipt, IrcMessage } from "./irc";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { card as cardNode, compact, elapsed, md, node, row, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, resultText, toolHead } from "./native-view";
+import type { NativeToolView, ToolRenderResult } from "./renderer";
 
 /** Whether a wait snapshot contains only running jobs and no cancellations. */
 export function isWaitingPollDetails(details: unknown): boolean {
@@ -541,7 +548,7 @@ export function createIrcMessageCard(
 	if (card.replyTo) meta.push("reply");
 	const age = messageAge(card.timestamp);
 	if (age) meta.push(age);
-	return createCachedComponent(
+	const component = createCachedComponent(
 		getExpanded,
 		(width, expanded) => {
 			const lines = [renderStatusLine({ iconOverride: ircGlyph(uiTheme), title, meta }, uiTheme)];
@@ -552,8 +559,163 @@ export function createIrcMessageCard(
 		},
 		{ paddingX: 1 },
 	);
+	// Terminal-local collapse replaces `getExpanded`; the node never changes after creation.
+	const described = cardNode(
+		{
+			role: `omp.irc.${card.kind}`,
+			tone: "info",
+			head: [
+				span(plainText(title), "toolTitle strong"),
+				...meta.filter(part => part !== age).map(part => span(` ${part}`, "muted")),
+			],
+			collapsible: body.trim().length > 0,
+			preview: { lines: 3 },
+		},
+		compact([
+			card.timestamp
+				? row([elapsed(Date.now() - card.timestamp), text([span("ago", "dim")])], { gap: "xs" })
+				: undefined,
+			body.trim() ? md(body) : undefined,
+		]),
+	);
+	return Object.assign(component, { describe: () => described });
+}
+
+/** One job row: type badge, id + label, terminal-clocked duration (live while running), preview below. */
+function describeJob(job: JobSnapshot): NativeNode {
+	const running = job.status === "running";
+	const label = job.label.trim() !== job.id ? plainText(job.label.split(/\r?\n/)[0] ?? "") : "";
+	const spans: TspSpan[] = [
+		span(plainText(job.id), running ? "accent" : "toolOutput", running ? { fx: "shimmer" } : undefined),
+	];
+	if (label) spans.push(span(` ${label}`, "toolOutput"));
+	if (job.exitCode !== undefined) spans.push(span(` exit ${job.exitCode}`, job.exitCode === 0 ? "muted" : "error"));
+	const tone =
+		job.status === "completed"
+			? "success"
+			: job.status === "failed"
+				? "error"
+				: job.status === "cancelled"
+					? "warning"
+					: "accent";
+	const artifactError = job.meta?.artifactError ?? job.artifactError;
+	const preview = flattenStructuredPreview(
+		stripTaskResultEnvelope(
+			stripOutputNotice(job.errorText?.trim() || job.resultText?.trim() || "", job.meta).trim(),
+		),
+	);
+	return node(
+		"col",
+		{ role: "omp.wait.job", tone },
+		compact([
+			row(
+				[
+					node("badge", { text: job.type, tone }),
+					text(spans, { truncate: "end", grow: 1 }),
+					elapsed(job.durationMs, !running),
+				],
+				{ gap: "sm" },
+			),
+			artifactError && text([span(formatArtifactErrorNotice(artifactError), "warning")], { wrap: "word" }),
+			preview
+				? text([span(plainText(preview), job.errorText ? "error" : "dim")], {
+						wrap: "word",
+						lines: PREVIEW_LINES_EXPANDED,
+					})
+				: undefined,
+		]),
+		job.id,
+	);
 }
 
+function describeJobsResult(
+	result: ToolRenderResult<CoordinationDetails>,
+	isPartial: boolean,
+): NativeToolView | undefined {
+	let jobs = result.details?.jobs ?? [];
+	const agents = result.details?.agents ?? [];
+	if (jobs.length === 0 && agents.length === 0) {
+		return {
+			head: toolHead("Wait"),
+			tone: "warning",
+			body: [text([span(plainText(resultText(result) || "No jobs to process"), "dim")])],
+		};
+	}
+	if (!isPartial && agents.length === 0) {
+		jobs = jobs.filter(job => job.status !== "running");
+		if (jobs.length === 0) return undefined;
+	}
+	const counts = { completed: 0, failed: 0, cancelled: 0, running: 0 };
+	for (const job of jobs) counts[job.status]++;
+	const noun = jobs.length === 1 ? "job" : "jobs";
+	const title =
+		jobs.length === 0
+			? `${agents.length} running agent${agents.length === 1 ? "" : "s"} — no jobs`
+			: counts.running > 0
+				? counts.running === jobs.length
+					? `waiting on ${jobs.length} ${noun}`
+					: `waiting on ${counts.running} of ${jobs.length} ${noun}`
+				: `${jobs.length} ${noun} settled`;
+	const head: TspSpan[] = [span(title, "toolTitle strong")];
+	if (counts.completed > 0) head.push(span(` ${counts.completed} done`, "success"));
+	if (counts.failed > 0) head.push(span(` ${counts.failed} failed`, "error"));
+	if (counts.cancelled > 0) head.push(span(` ${counts.cancelled} cancelled`, "warning"));
+	const order: Record<JobSnapshot["status"], number> = { running: 0, failed: 1, cancelled: 2, completed: 3 };
+	const sorted = [...jobs].sort((a, b) => order[a.status] - order[b.status] || b.durationMs - a.durationMs);
+	const body: NativeNode[] = sorted.map(describeJob);
+	for (const agent of agents) {
+		const spans: TspSpan[] = [span(plainText(agent.id), "muted")];
+		if (agent.activity) spans.push(span(` ${plainText(agent.activity)}`, "toolOutput"));
+		if (agent.parentId) spans.push(span(` ← ${plainText(agent.parentId)}`, "dim"));
+		body.push(
+			node(
+				"row",
+				{ gap: "sm", role: "omp.wait.agent" },
+				[
+					node("badge", {
+						text: agent.live ? "agent" : "agent · no turn",
+						tone: agent.live ? "accent" : "warning",
+					}),
+					text(spans, { truncate: "end", grow: 1 }),
+					elapsed(agent.ageMs, !agent.live),
+				],
+				`agent:${agent.id}`,
+			),
+		);
+	}
+	return {
+		head,
+		tone: counts.failed > 0 ? "warning" : counts.running > 0 || agents.length > 0 ? "info" : "success",
+		body,
+	};
+}
+
+/** Received-message view: sender head, terminal-clocked age, markdown body. */
+function describeMessage(
+	from: string,
+	ts: number | undefined,
+	bodyText: string,
+	meta: readonly string[],
+): NativeToolView {
+	const head: TspSpan[] = [span(`IRC ← ${plainText(from)}`, "toolTitle strong")];
+	for (const part of meta) head.push(span(` ${part}`, "muted"));
+	return {
+		head,
+		tone: "info",
+		preview: { lines: BODY_LINES_COLLAPSED + 1 },
+		body: compact([
+			ts
+				? row([text([span("received", "dim")]), elapsed(Date.now() - ts), text([span("ago", "dim")])], {
+						gap: "xs",
+					})
+				: undefined,
+			bodyText.trim() ? md(bodyText) : undefined,
+		]),
+	};
+}
+
+const waitResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render either a received message or a background-job snapshot. */
 export const waitToolRenderer = {
 	inline: true,
@@ -562,6 +724,24 @@ export const waitToolRenderer = {
 		return { label: "Wait", detail: "Background work or peer message" };
 	},
 	renderCall: waitRenderCall,
+	describeCall(): NativeToolView {
+		return { head: toolHead("Wait"), inline: true };
+	},
+	describeResult(
+		result: ToolRenderResult<CoordinationDetails>,
+		options: RenderResultOptions,
+	): NativeToolView | undefined {
+		return waitResultMemo.get(result, [options.isPartial], () => {
+			if (result.isError) return errorView("Wait", resultText(result));
+			const details = result.details;
+			if (details?.interrupted) {
+				return { head: toolHead("Wait", "interrupted by message"), tone: "info", inline: true };
+			}
+			const waited = details?.waited;
+			if (!waited) return describeJobsResult(result, options.isPartial);
+			return describeMessage(waited.from, waited.ts, waited.body, waited.replyTo ? ["reply"] : []);
+		});
+	},
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: CoordinationDetails; isError?: boolean },
 		options: RenderResultOptions,

package/src/tools/web-search-types.ts

@@ -0,0 +1,99 @@
+/**
+ * Web search response types shared by the coding agent's search providers and
+ * the transcript renderer in {@link ./web-search}. Render-free, so provider code
+ * can import it without loading UI components.
+ */
+
+/**
+ * Display label for every search implementation: `web/*` engines and the
+ * chat-model groundings. Keys are the ids providers report in
+ * {@link SearchResponse.provider} and search errors.
+ */
+export const SEARCH_PROVIDER_LABELS = {
+	parallel: "Parallel",
+	perplexity: "Perplexity",
+	gemini: "Gemini",
+	anthropic: "Anthropic",
+	codex: "OpenAI Codex",
+	openai: "OpenAI API",
+	xai: "xAI",
+	openrouter: "OpenRouter",
+	zai: "Z.AI",
+	exa: "Exa",
+	tinyfish: "TinyFish",
+	jina: "Jina",
+	kagi: "Kagi",
+	tavily: "Tavily",
+	firecrawl: "Firecrawl",
+	brave: "Brave",
+	kimi: "Kimi",
+	synthetic: "Synthetic",
+	ollama: "Ollama",
+	searxng: "SearXNG",
+	startpage: "Startpage",
+	duckduckgo: "DuckDuckGo",
+	ecosia: "Ecosia",
+	google: "Google",
+	mojeek: "Mojeek",
+	public: "Public Web",
+} as const;
+
+/** Id of a search implementation; see {@link SEARCH_PROVIDER_LABELS}. */
+export type SearchProviderId = keyof typeof SEARCH_PROVIDER_LABELS;
+
+/** Label for a provider id; ids from older transcripts fall back to the raw id. */
+export function getSearchProviderLabel(id: SearchProviderId): string {
+	return SEARCH_PROVIDER_LABELS[id] ?? id;
+}
+
+/** Source returned by search (all providers) */
+export interface SearchSource {
+	title: string;
+	url: string;
+	snippet?: string;
+	/** ISO date string or relative ("2d ago") */
+	publishedDate?: string;
+	/** Age in seconds for consistent formatting */
+	ageSeconds?: number;
+	author?: string;
+}
+
+/** Citation with text reference (LLM-mediated providers) */
+export interface SearchCitation {
+	url: string;
+	title: string;
+	citedText?: string;
+}
+
+/** Usage metrics */
+export interface SearchUsage {
+	inputTokens?: number;
+	outputTokens?: number;
+	/** Anthropic: number of web search requests made */
+	searchRequests?: number;
+	/** Perplexity: combined token count */
+	totalTokens?: number;
+}
+
+/** Unified response across providers */
+export interface SearchResponse {
+	provider: SearchProviderId | "none";
+	/** Synthesized answer text (LLM-mediated providers) */
+	answer?: string;
+	/** Search result sources */
+	sources: SearchSource[];
+	/** Text citations with context */
+	citations?: SearchCitation[];
+	/** Intermediate search queries (anthropic) */
+	searchQueries?: string[];
+	/** Follow-up question suggestions (provider-dependent) */
+	relatedQuestions?: string[];
+	/** Token usage metrics */
+	usage?: SearchUsage;
+	/** Model used */
+	model?: string;
+	/** Request ID for debugging */
+	requestId?: string;
+	/** Authentication mode used by the provider (e.g. oauth, api-key) */
+	authMode?: string;
+}