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

package/src/tools/task.ts

@@ -29,6 +29,7 @@ import {
 	formatMoreItems,
 	formatNumber,
 	isFeedModelBadgeEnabled,
+	pluralize,
 	previewLine,
 	previewWindowRows,
 	replaceTabs,
@@ -43,6 +44,15 @@ import { formatOutputInline, renderJsonTreeLines } from "./json-tree";
 import { repairDoubleEncodedJsonString } from "./task-repair-args";
 import { getSubprocessToolRenderer } from "./subprocess";
 import { assembleYieldResult, type YieldSectionShapes } from "./task-yield-assembly";
+import type { TspAgentProps, TspTone } from "@oh-my-pi/pi-wire";
+import { compact, kv, md, node, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorText, noteText, resultText } from "./native-view";
+import { describeJsonTree } from "./json-tree";
+import { taskSummary } from "../overlays/agent-hub-renderer";
+import type { NativeToolView, ToolRenderResult } from "./renderer";
 
 /** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
 interface TaskRenderContext {
@@ -1681,11 +1691,403 @@ function renderNestedTaskTree(
 	return lines;
 }
 
+// =============================================================================
+// Native (TSP) description: one `agent` node per subagent (§7.6)
+// =============================================================================
+
+/** Theme token for a thinking level's model-chip dot. */
+function thinkingToken(level: ConfiguredThinkingLevel | undefined): string | undefined {
+	switch (level) {
+		case "minimal":
+			return "thinkingMinimal";
+		case "low":
+			return "thinkingLow";
+		case "medium":
+			return "thinkingMedium";
+		case "high":
+			return "thinkingHigh";
+		case "xhigh":
+		case "max":
+			return "thinkingXhigh";
+		default:
+			return undefined;
+	}
+}
+
+/** The shared batch context as one quiet line above the agents. */
+function describeContext(raw: unknown): NativeNode | undefined {
+	const source = typeof raw === "string" ? sanitizeText(repairDoubleEncodedJsonString(raw)) : "";
+	const line = source.replace(/\s+/g, " ").trim();
+	return line ? text([span(line, "muted")], { wrap: "word", lines: 2, role: "omp.tool.context" }) : undefined;
+}
+
+/** The full assignment, markdown, as the first expanded child of an agent. */
+function describeAssignment(raw: string | undefined): NativeNode | undefined {
+	const source = raw ? sanitizeText(repairDoubleEncodedJsonString(raw)).trim() : "";
+	return source ? md(source, { role: "omp.task.assignment" }) : undefined;
+}
+
+/** Context-window stats: the fill fraction and its `19K / 200K` label. */
+function contextStats(
+	tokens: number | undefined,
+	window: number | undefined,
+): { context?: number; contextLabel?: string } {
+	if (!tokens || tokens <= 0) return {};
+	if (!window || window <= 0) return { contextLabel: formatNumber(tokens) };
+	return {
+		context: Math.min(1, tokens / window),
+		contextLabel: `${formatNumber(tokens)} / ${formatNumber(window)}`,
+	};
+}
+
+/** Agent badges: `background` for async jobs, `isolated` worktrees. */
+function agentBadges(background: boolean, isolated: boolean | undefined): TspAgentProps["badges"] {
+	const badges: { text: string; tone?: TspTone }[] = [];
+	if (background) badges.push({ text: "background" });
+	if (isolated) badges.push({ text: "isolated" });
+	return badges.length > 0 ? badges : undefined;
+}
+
+interface AgentDescribeState {
+	readonly seen: WeakSet<object>;
+	readonly nowMs: number;
+	readonly expanded: boolean;
+	readonly background: boolean;
+}
+
+/** Settled and in-flight child snapshots a subagent carries, as nested agent nodes. */
+function describeNestedTasks(
+	source: { extractedToolData?: Record<string, unknown[]>; inflightTaskDetails?: TaskToolDetails },
+	state: AgentDescribeState,
+	depth: number,
+): NativeNode[] {
+	const nested: TaskToolDetails[] = [];
+	const settled = source.extractedToolData?.task;
+	if (Array.isArray(settled)) for (const entry of settled) if (isTaskToolDetails(entry)) nested.push(entry);
+	if (source.inflightTaskDetails) nested.push(source.inflightTaskDetails);
+	const out: NativeNode[] = [];
+	for (const details of nested) {
+		if (state.seen.has(details)) {
+			out.push(noteText("↻ nested task cycle", "dim"));
+			continue;
+		}
+		if (depth >= MAX_NESTED_TASK_RENDER_DEPTH) {
+			out.push(noteText("… nested task depth limit reached", "dim"));
+			continue;
+		}
+		state.seen.add(details);
+		out.push(...describeAgents(details, state, depth + 1));
+		state.seen.delete(details);
+	}
+	return out;
+}
+
+function agentNode(p: TspAgentProps, children: readonly (NativeNode | undefined)[], key: string): NativeNode {
+	return node("agent", p, compact(children), key);
+}
+
+function describeProgressAgent(progress: AgentProgress, state: AgentDescribeState, depth: number): NativeNode {
+	const { nowMs } = state;
+	const running = progress.status === "running";
+	const status: TspAgentProps["status"] =
+		progress.status === "completed" ? "done" : progress.status === "failed" ? "failed" : progress.status;
+	const tool =
+		running && progress.currentTool
+			? {
+					name: plainText(progress.currentTool),
+					intent: plainText(progress.lastIntent ?? progress.currentToolArgs ?? "") || undefined,
+					age: progress.currentToolStartMs ? Math.max(0, nowMs - progress.currentToolStartMs) : undefined,
+				}
+			: null;
+	const retry =
+		running && progress.retryState
+			? {
+					attempt: progress.retryState.attempt,
+					max: progress.retryState.maxAttempts,
+					age: Math.max(0, nowMs - progress.retryState.startedAtMs),
+					delay: progress.retryState.delayMs,
+					error: plainText(progress.retryState.errorMessage),
+				}
+			: null;
+	return agentNode(
+		{
+			name: formatTaskId(progress.id),
+			agent: progress.agent || undefined,
+			task: taskSummary(progress.description || progress.assignment || progress.task) || undefined,
+			status,
+			model: progress.resolvedModelIdentity ?? progress.resolvedModel,
+			thinking: thinkingToken(progress.resolvedThinkingLevel),
+			tool,
+			stats: {
+				tools: progress.toolCount || undefined,
+				requests: progress.requests || undefined,
+				tokens: progress.tokens || undefined,
+				...contextStats(progress.contextTokens, progress.contextWindow),
+				cost: progress.cost > 0 ? progress.cost : undefined,
+				...(running ? { age: progress.durationMs } : { took: progress.durationMs }),
+			},
+			retry,
+			badges: agentBadges(state.background, undefined),
+			depth: depth > 0 ? depth : undefined,
+			collapsible: true,
+			collapsed: !state.expanded,
+		},
+		[
+			describeAssignment(progress.assignment ?? progress.task),
+			progress.resolvedModelRoute ? noteText(progress.resolvedModelRoute, "dim") : undefined,
+			!running && progress.retryFailure
+				? text(
+						[
+							span(
+								`auto-retry gave up after ${progress.retryFailure.attempt} ${pluralize("attempt", progress.retryFailure.attempt)}: ${plainText(progress.retryFailure.errorMessage)}`,
+								"error",
+							),
+						],
+						{ wrap: "word", role: "omp.tool.error" },
+					)
+				: undefined,
+			...describeNestedTasks(progress, state, depth),
+		],
+		progress.id,
+	);
+}
+
+function describeResultAgent(result: SingleResult, state: AgentDescribeState, depth: number): NativeNode {
+	const { warning, rest } = extractMissingYieldWarning(result.output);
+	const aborted = result.aborted ?? false;
+	const mergeFailed = !aborted && result.exitCode === 0 && !!result.error;
+	const success = !aborted && result.exitCode === 0 && !result.error;
+	const status: TspAgentProps["status"] = aborted ? "aborted" : success || mergeFailed ? "done" : "failed";
+	const structured = result.structuredOutput?.data;
+	const output = sanitizeText(stripGeneratedOutputNotice(rest)).trim();
+	const errorLine = (message: string, token = "error"): NativeNode =>
+		text([span(plainText(message), token)], { wrap: "word", role: "omp.tool.error" });
+	const badges: { text: string; tone?: TspTone }[] = [...(agentBadges(state.background, result.isolated) ?? [])];
+	if (mergeFailed) badges.push({ text: "merge failed", tone: "warning" });
+	else if (warning && success) badges.push({ text: "warning", tone: "warning" });
+	if (result.truncated) badges.push({ text: "truncated", tone: "warning" });
+	const cost = result.usage?.cost.total ?? 0;
+	return agentNode(
+		{
+			name: formatTaskId(result.id),
+			agent: result.agent || undefined,
+			task: taskSummary(result.description || result.assignment || result.task) || undefined,
+			status,
+			model: result.resolvedModelIdentity ?? result.resolvedModel,
+			thinking: thinkingToken(result.resolvedThinkingLevel),
+			tool: null,
+			stats: {
+				requests: result.requests || undefined,
+				tokens: result.tokens || undefined,
+				...contextStats(result.contextTokens, result.contextWindow),
+				cost: cost > 0 ? cost : undefined,
+				took: result.durationMs,
+			},
+			retry: null,
+			badges: badges.length > 0 ? badges : undefined,
+			depth: depth > 0 ? depth : undefined,
+			collapsible: true,
+			collapsed: !state.expanded,
+		},
+		[
+			describeAssignment(result.assignment ?? result.task),
+			result.resolvedModelRoute ? noteText(result.resolvedModelRoute, "dim") : undefined,
+			aborted && result.abortReason ? errorLine(result.abortReason) : undefined,
+			warning ? errorLine(warning, "warning") : undefined,
+			result.error ? errorLine(result.error) : undefined,
+			result.retryFailure ? errorLine(`auto-retry gave up: ${result.retryFailure.errorMessage}`) : undefined,
+			structured !== undefined
+				? describeJsonTree(structured)
+				: output
+					? md(output, { role: "omp.task.output" })
+					: undefined,
+			result.stderr.trim() && !success ? node("ansi", { text: result.stderr, preview: { lines: 6 } }) : undefined,
+			kv([
+				[
+					"Patch",
+					result.patchPath && result.hasRootChanges !== false && success
+						? shortenPath(result.patchPath)
+						: undefined,
+				],
+				["Branch", result.branchName && success ? plainText(result.branchName) : undefined],
+			]),
+			...describeNestedTasks(result, state, depth),
+		],
+		result.id,
+	);
+}
+
+/** Agent nodes for one snapshot: settled results, then progress rows that have no result yet. */
+function describeAgents(details: TaskToolDetails, state: AgentDescribeState, depth: number): NativeNode[] {
+	const results = details.results ?? [];
+	const agents = orderResultsForDisplay(results).map(res => describeResultAgent(res, state, depth));
+	for (const progress of orderProgressForDisplay(details.progress ?? [])) {
+		if (!results.some(res => res.id === progress.id)) agents.push(describeProgressAgent(progress, state, depth));
+	}
+	return agents;
+}
+
+function agentCountLabel(count: number): string {
+	return `${count} ${pluralize("agent", count)}`;
+}
+
+/** Streaming call: the context line, then a pending agent per requested spawn. */
+function describeTaskCall(args: TaskParams | undefined): NativeToolView {
+	const agents: NativeNode[] = [];
+	const pending = (name: string, agent: unknown, brief: unknown, isolated: unknown, key: string): NativeNode =>
+		agentNode(
+			{
+				name,
+				agent: typeof agent === "string" && agent.trim() ? agent.trim() : undefined,
+				task: typeof brief === "string" ? taskSummary(brief) || undefined : undefined,
+				status: "pending",
+				badges: agentBadges(false, isolated === true),
+			},
+			[],
+			key,
+		);
+	const flatName = typeof args?.name === "string" ? args.name.trim() : "";
+	if (flatName || taskFirstLine(args?.task)) {
+		agents.push(
+			pending(
+				flatName ? formatTaskId(flatName) : "agent",
+				args?.agent,
+				args?.task,
+				args?.isolated,
+				flatName || "agent",
+			),
+		);
+	}
+	if (Array.isArray(args?.tasks)) {
+		args.tasks.forEach((entry, index) => {
+			const name = typeof entry?.name === "string" ? entry.name.trim() : "";
+			agents.push(
+				pending(
+					name ? formatTaskId(name) : `#${index + 1}`,
+					entry?.agent,
+					entry?.task,
+					entry?.isolated,
+					name || `#${index + 1}`,
+				),
+			);
+		});
+	}
+	const target = agents.length > 1 ? agentCountLabel(agents.length) : formatAgentHeaderLabel(args);
+	return {
+		tool: { title: "Task", target, targetKind: target ? "text" : undefined },
+		body: compact([describeContext(args?.context), ...agents]),
+	};
+}
+
+function describeTaskResult(
+	result: ToolRenderResult<TaskToolDetails>,
+	options: TaskRenderOptions,
+	args: TaskParams | undefined,
+): NativeToolView {
+	const details = result.details;
+	const context = describeContext(args?.context);
+	const agentLabel = formatAgentHeaderLabel(args);
+	if (!details) {
+		const fallback = resultText(result).trim();
+		if (result.isError) {
+			return {
+				tool: { title: "Task", target: agentLabel, targetKind: "text" },
+				tone: "error",
+				body: compact([context, errorText(fallback || "Task failed")]),
+			};
+		}
+		return {
+			tool: { title: "Task", target: agentLabel, targetKind: agentLabel ? "text" : undefined },
+			body: compact([context, fallback ? noteText(fallback, "dim") : undefined]),
+		};
+	}
+	// Ages are sampled once per snapshot; the terminal advances them.
+	const background = details.async !== undefined;
+	const agents = describeAgents(
+		details,
+		{
+			seen: new WeakSet<object>(),
+			nowMs: options.renderContext?.nowMs ?? Date.now(),
+			expanded: options.expanded,
+			background,
+		},
+		0,
+	);
+	const count = agents.length;
+	let failed = 0;
+	let aborted = 0;
+	let succeeded = 0;
+	let requests = 0;
+	for (const res of details.results ?? []) {
+		requests += res.requests ?? 0;
+		if (res.aborted) aborted++;
+		else if (res.exitCode !== 0) failed++;
+		else if (!res.error) succeeded++;
+	}
+	const summary: string[] = [];
+	if ((details.results ?? []).length > 0) {
+		if (succeeded) summary.push(`${succeeded} succeeded`);
+		if (failed) summary.push(`${failed} failed`);
+		if (aborted) summary.push(`${aborted} aborted`);
+		if (requests) summary.push(`${formatNumber(requests)} req`);
+		summary.push(formatDuration(details.totalDurationMs));
+	}
+	const fallback = resultText(result);
+	const lines = fallback.split("\n");
+	const notice = lines.findIndex(
+		line =>
+			line.includes("<system-notification>") ||
+			line.startsWith("Applied patches:") ||
+			line.startsWith("No changes to apply."),
+	);
+	const trailer =
+		notice >= 0
+			? lines
+					.slice(notice)
+					.filter(line => line.trim())
+					.join("\n")
+			: "";
+	const target = count > 0 ? agentCountLabel(count) : agentLabel;
+	return {
+		tool: {
+			title: "Task",
+			target,
+			targetKind: target ? "text" : undefined,
+			meta: summary.length > 0 ? [summary.join(" · ")] : undefined,
+			badges: background ? [{ text: "background" }] : undefined,
+		},
+		tone: aborted + failed > 0 ? "error" : undefined,
+		preview: "none",
+		body: compact([
+			context,
+			...agents,
+			count === 0 ? noteText(fallback.trim() || "No results", "dim") : undefined,
+			trailer ? text([span(plainText(trailer), "muted")], { wrap: "word", role: "omp.tool.stats" }) : undefined,
+		]),
+	};
+}
+
+const taskCallMemo = new OwnerMemo<NativeToolView | undefined>();
+const taskResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Renders task calls and their live or settled agent results. */
-export const taskToolRenderer = { renderCall, renderResult, mergeCallAndResult: true } satisfies ToolRenderer<
-	TaskParams,
-	TaskToolDetails
->;
+export const taskToolRenderer = {
+	renderCall,
+	renderResult,
+	describeCall(args: TaskParams, options: RenderResultOptions): NativeToolView | undefined {
+		return taskCallMemo.get(args, [options.argsComplete], () => describeTaskCall(args));
+	},
+	describeResult(
+		result: ToolRenderResult<TaskToolDetails>,
+		options: TaskRenderOptions,
+		args?: TaskParams,
+	): NativeToolView | undefined {
+		return taskResultMemo.get(result, [options.renderContext?.nowMs, options.expanded], () =>
+			describeTaskResult(result, options, args),
+		);
+	},
+	mergeCallAndResult: true,
+} satisfies ToolRenderer<TaskParams, TaskToolDetails>;
 
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";

package/src/tools/think.ts

@@ -1,14 +1,18 @@
-import type { ToolRenderer } from "./renderer";
+import type { NativeToolView, ToolRenderer } from "./renderer";
 
 import { type Component, Markdown } from "../index";
 import type { RenderResultOptions } from "./renderer";
 import { getMarkdownTheme, type Theme } from "../theme/theme";
+import { md } from "../native/describe";
+import { OwnerMemo } from "../native/memo";
 
 /** Streamed private scratchpad text. */
 export type ThinkRenderArgs = {
 	thoughts?: string;
 };
 
+const thinkCallMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render private scratchpad text without a result block. */
 export const thinkToolRenderer = {
 	inline: true,
@@ -25,4 +29,18 @@ export const thinkToolRenderer = {
 	renderResult(): undefined {
 		return undefined;
 	},
+	describeCall(args: ThinkRenderArgs, options: RenderResultOptions): NativeToolView {
+		const thoughts =
+			typeof args === "object" && args !== null && typeof args.thoughts === "string" ? args.thoughts : "";
+		const streaming = options.argsComplete === false;
+		return (
+			thinkCallMemo.get(args, [streaming, thoughts], () => ({
+				inline: true,
+				body: thoughts ? [md(thoughts, { role: "omp.think", tone: "muted", stream: streaming })] : [],
+			})) ?? { inline: true }
+		);
+	},
+	describeResult(): undefined {
+		return undefined;
+	},
 } satisfies ToolRenderer<ThinkRenderArgs, unknown>;

package/src/tools/todo.ts

@@ -11,6 +11,11 @@ import { renderStatusLine, renderTreeList } from "../render";
 import { framedToolCard } from "../render/tool-card";
 
 import { formatErrorDetail, formatMoreItems, PREVIEW_LIMITS, pluralize, replaceTabs } from "../render/render-utils";
+import type { TspChecklistItem, TspChecklistPhase } from "@oh-my-pi/pi-wire";
+import { node } from "../native/describe";
+import { OwnerMemo } from "../native/memo";
+import { errorText, noteText, resultText } from "./native-view";
+import type { NativeToolView, ToolRenderResult } from "./renderer";
 
 // =============================================================================
 // Types
@@ -428,6 +433,74 @@ export function setActiveTodoDescriptionsProvider(provider: () => readonly strin
 	activeTodoDescriptionsProvider = provider;
 }
 
+/** omp todo status → checklist item status (§7.5). */
+const CHECKLIST_STATUS: Record<TodoStatus, TspChecklistItem["status"]> = {
+	pending: "pending",
+	in_progress: "active",
+	completed: "done",
+	abandoned: "dropped",
+	blocked: "blocked",
+};
+
+/** Checklist item for one todo; a pending todo an in-flight subagent executes reads as active. */
+function checklistItem(task: TodoItem, id: string, matched = false): TspChecklistItem {
+	const status = task.status === "pending" && matched ? "active" : CHECKLIST_STATUS[task.status];
+	const note = task.status === "blocked" && task.blocker ? forDisplay(task.blocker) : undefined;
+	return note === undefined
+		? { id, text: forDisplay(task.content), status }
+		: { id, text: forDisplay(task.content), status, note };
+}
+
+/**
+ * Checklist phases for native terminals: plain phase titles (no roman
+ * numerals — the terminal numbers nothing), completed phases folded.
+ */
+export function todoChecklistPhases(
+	phases: readonly { name: string; tasks: readonly TodoItem[] }[],
+	isMatched: (task: TodoItem) => boolean = () => false,
+): TspChecklistPhase[] {
+	return phases.map((phase, p) => ({
+		id: `p${p}`,
+		title: forDisplay(phase.name),
+		items: phase.tasks.map((task, t) => checklistItem(task, `p${p}.${t}`, isMatched(task))),
+		collapsed: phase.tasks.length > 0 && phase.tasks.every(isClosedTodo),
+	}));
+}
+
+const todoResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
+/**
+ * Native todo result: head `Todo closed/total`, body one `checklist` node.
+ * Renderers get no describe context, so the checklist is always emitted;
+ * terminals that do not list the kind draw its unknown-kind fallback (§3).
+ */
+function describeTodoResult(
+	result: ToolRenderResult<TodoToolDetails>,
+	options: RenderResultOptions,
+): NativeToolView | undefined {
+	if (result.isError) {
+		return {
+			tool: { title: "Todo" },
+			tone: "error",
+			body: [errorText(resultText(result) || "Todo operation failed")],
+		};
+	}
+	const phases = (result.details?.phases ?? []).filter(phase => phase.tasks.length > 0);
+	const total = phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+	if (total === 0) {
+		return { tool: { title: "Todo" }, body: [noteText(forDisplay(resultText(result) || "No todos"))] };
+	}
+	const closed = phases.reduce((sum, phase) => sum + phase.tasks.filter(isClosedTodo).length, 0);
+	const activeDescs = options.expanded ? [] : activeTodoDescriptionsProvider();
+	const isMatched = (task: TodoItem): boolean =>
+		activeDescs.length > 0 && todoMatchesAnyDescription(task.content, activeDescs);
+	return {
+		tool: { title: "Todo", target: `${closed}/${total}`, targetKind: "text" },
+		body: [node("checklist", { mode: "full", phases: todoChecklistPhases(phases, isMatched) }, [], "checklist")],
+		preview: "none",
+	};
+}
+
 /** Render todo operations and phased task snapshots. */
 export const todoToolRenderer = {
 	renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
@@ -576,5 +649,21 @@ export const todoToolRenderer = {
 			};
 		});
 	},
+	describeCall(args: TodoRenderArgs): NativeToolView {
+		const ops = normalizeTodoArg(args).map(e => {
+			const parts = [forDisplay(e.op ?? "update")];
+			if (e.task) parts.push(forDisplay(e.task));
+			if (e.phase) parts.push(forDisplay(e.phase));
+			if (Array.isArray(e.items) && e.items.length)
+				parts.push(`${e.items.length} ${pluralize("item", e.items.length)}`);
+			return parts.join(" ");
+		});
+		return { tool: { title: "Todo", target: ops.length === 0 ? "update" : ops.join(", "), targetKind: "text" } };
+	},
+
+	describeResult(result: ToolRenderResult<TodoToolDetails>, options: RenderResultOptions): NativeToolView | undefined {
+		return todoResultMemo.get(result, [options.expanded], () => describeTodoResult(result, options));
+	},
+
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<TodoRenderArgs, TodoToolDetails>;