@quandev104/pi-style 0.1.5 → 0.1.7

package/extension-src/pi-style/features/tools/boxed/turn-summary.ts

@@ -0,0 +1,368 @@
+// Turn tool summary registry (ADR 0007).
+//
+// When a turn completes, its finalized tool blocks collapse into a single
+// summary line (`➔ Read 2 files, ran 4 shell commands · 3.1s`) rendered by the
+// turn's leader (its first non-error tool call); every other non-error tool
+// item of the turn renders zero lines. Error results stay visible, interrupted
+// turns never collapse, and Pi's global tool-output toggle (Ctrl+O) expands
+// everything again (`options.expanded` is read, never written).
+//
+// Design notes:
+// - The registry is populated from **session content**, never from runtime
+//   event flags: the live path registers the final assistant message +
+//   toolResults at `turn_end`; the restore path rebuilds the registry from
+//   `sessionManager.getEntries()` at session start / `session_tree`, so
+//   scroll-back and session resume render identically.
+// - A turn is "ended" only when every tool call of its message has a matching
+//   tool result AND (live) turn_end fired / (restore) the message is
+//   finalized (`stopReason`) or a later user/assistant message exists.
+// - Elapsed per member is frozen from the renderer wall-clock state
+//   (STARTED_AT/ENDED_AT) at the first post-turn result pass; the summary
+//   totals the members' frozen elapsed. No render-time I/O.
+// - No new Pi-core patch identity: the dispatcher (boxed/index.ts) decides
+//   collapse before the per-tool renderers run, so every certified renderer
+//   surface stays untouched when the turn is not collapsed.
+
+import type { Component } from "@earendil-works/pi-tui";
+import type { BoxTheme } from "../../../shared/box.js";
+import { safeTruncateToWidth } from "../../../shared/render-budget.js";
+import { pluralForm } from "./output-tree.js";
+
+export interface TurnMemberInfo {
+	readonly toolCallId: string;
+	readonly toolName: string;
+	/** Whether a tool result was registered for this call (run completeness). */
+	readonly hasResult: boolean;
+	isError: boolean;
+	/** Frozen wall-clock elapsed (ms), recorded from the renderer context state. */
+	elapsedMs?: number;
+}
+
+export interface TurnState {
+	/** First non-error member; renders the summary line. Empty when every member errored. */
+	leaderId: string;
+	ended: boolean;
+	members: readonly TurnMemberInfo[];
+}
+
+interface TurnEntry {
+	readonly turn: TurnState;
+	readonly member: TurnMemberInfo;
+}
+
+const memberByCallId = new Map<string, TurnEntry>();
+
+/** Per-member component invalidate callbacks captured during render passes. */
+const invalidateByCallId = new Map<string, () => void>();
+
+/** Reset all turn state (session start/shutdown). */
+export function resetTurnRegistry(): void {
+	memberByCallId.clear();
+	invalidateByCallId.clear();
+}
+
+interface ToolCallLike {
+	readonly type?: unknown;
+	readonly id?: unknown;
+	readonly name?: unknown;
+}
+
+function toolCallsOf(message: unknown): ToolCallLike[] {
+	if (!message || typeof message !== "object") return [];
+	const content = (message as { readonly content?: unknown }).content;
+	if (!Array.isArray(content)) return [];
+	const calls: ToolCallLike[] = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const candidate = item as ToolCallLike;
+		if (candidate.type === "toolCall") calls.push(candidate);
+	}
+	return calls;
+}
+
+function registerTurn(
+	calls: readonly ToolCallLike[],
+	isErrorById: ReadonlyMap<string, boolean>,
+	ended: boolean,
+): TurnState | undefined {
+	if (calls.length === 0) return undefined;
+	const complete = calls.every((call) => typeof call.id === "string" && isErrorById.has(call.id));
+	const members: TurnMemberInfo[] = calls.map((call) => {
+		const toolCallId = String(call.id ?? "");
+		return {
+			toolCallId,
+			toolName: typeof call.name === "string" ? call.name : "tool",
+			hasResult: isErrorById.has(toolCallId),
+			isError: isErrorById.get(toolCallId) === true,
+		};
+	});
+	const leader = members.find((member) => !member.isError);
+	const turn: TurnState = {
+		leaderId: leader?.toolCallId ?? "",
+		ended: ended && complete,
+		members: Object.freeze(members),
+	};
+	for (const member of members) memberByCallId.set(member.toolCallId, { turn, member });
+	return turn;
+}
+
+export interface TurnResultLike {
+	readonly toolCallId: string;
+	readonly isError?: boolean;
+}
+
+/**
+ * One summary group = one agent run (user request → `agent_end`). Pi emits
+ * `turn_end` per assistant message, so tool batches of the same request are
+ * appended to the same run and collapse into ONE summary line at `agent_end`.
+ */
+let currentRun: TurnState | undefined;
+
+/** Live path: start a fresh run group (`agent_start`). */
+export function beginAgentRun(): void {
+	currentRun = undefined;
+}
+
+/**
+ * Live path: append the finalized assistant message's tool calls and results
+ * to the current run (`turn_end` event). The run stays expanded until
+ * `finishAgentRun`; a batch interrupted mid-tool never collapses.
+ */
+export function registerTurnFromMessage(message: unknown, toolResults: readonly TurnResultLike[]): void {
+	const calls = toolCallsOf(message);
+	if (calls.length === 0) return;
+	const isErrorById = new Map<string, boolean>();
+	for (const result of toolResults) {
+		if (typeof result?.toolCallId !== "string") continue;
+		isErrorById.set(result.toolCallId, result.isError === true);
+	}
+	const newMembers: TurnMemberInfo[] = calls.map((call) => {
+		const toolCallId = String(call.id ?? "");
+		return {
+			toolCallId,
+			toolName: typeof call.name === "string" ? call.name : "tool",
+			hasResult: isErrorById.has(toolCallId),
+			isError: isErrorById.get(toolCallId) === true,
+		};
+	});
+	const leader = newMembers.find((member) => !member.isError);
+	if (!currentRun) {
+		currentRun = {
+			leaderId: leader?.toolCallId ?? "",
+			ended: false,
+			members: Object.freeze(newMembers),
+		};
+	} else {
+		if (currentRun.leaderId === "" && leader) currentRun.leaderId = leader.toolCallId;
+		currentRun.members = Object.freeze([...currentRun.members, ...newMembers]);
+	}
+	for (const member of newMembers) memberByCallId.set(member.toolCallId, { turn: currentRun, member });
+}
+
+/**
+ * Live path: finalize the current run (`agent_end`). Returns the run so the
+ * caller can invalidate its blocks; undefined when the run had no tool calls
+ * or is interrupted (a call without a result stays expanded).
+ */
+export function finishAgentRun(): TurnState | undefined {
+	const run = currentRun;
+	currentRun = undefined;
+	if (!run) return undefined;
+	// A member without a result means the run was interrupted before every call
+	// settled; such a run never collapses.
+	if (run.members.every((member) => member.hasResult)) run.ended = true;
+	return run.ended ? run : undefined;
+}
+
+interface TurnEntryLike {
+	readonly type?: unknown;
+	readonly message?: {
+		readonly role?: unknown;
+		readonly content?: unknown;
+		readonly stopReason?: unknown;
+		readonly toolCallId?: unknown;
+		readonly isError?: unknown;
+	};
+}
+
+/**
+ * Restore path: rebuild the registry from session entries (session start /
+ * `session_tree`). Consecutive assistant messages between user messages form
+ * one run; a run is ended when every tool call has a result AND a later user
+ * message exists (historical) or its last assistant message is finalized
+ * (`stopReason`). The currently streaming run stays expanded.
+ */
+export function rebuildTurnRegistryFromEntries(entries: readonly TurnEntryLike[] | undefined): void {
+	memberByCallId.clear();
+	if (!Array.isArray(entries)) return;
+	const isErrorById = new Map<string, boolean>();
+	const resultById = new Set<string>();
+	const runs: Array<{
+		calls: ToolCallLike[];
+		lastStopReason: string | undefined;
+		followedByUser: boolean;
+	}> = [];
+	let current: (typeof runs)[number] | undefined;
+	const closeRun = () => {
+		if (current && current.calls.length > 0) runs.push(current);
+		current = undefined;
+	};
+	entries.forEach((entry) => {
+		if (entry?.type !== "message") return;
+		const message = entry.message;
+		if (message?.role === "toolResult" && typeof message.toolCallId === "string") {
+			resultById.add(message.toolCallId);
+			isErrorById.set(message.toolCallId, message.isError === true);
+		} else if (message?.role === "assistant") {
+			if (!current) current = { calls: [], lastStopReason: undefined, followedByUser: false };
+			const calls = toolCallsOf(message);
+			current.calls.push(...calls);
+			if (typeof message.stopReason === "string" && message.stopReason !== "")
+				current.lastStopReason = message.stopReason;
+		} else if (message?.role === "user") {
+			if (current) {
+				current.followedByUser = true;
+				closeRun();
+			} else {
+				// A user message with no preceding open run is a plain boundary.
+				closeRun();
+			}
+		}
+	});
+	closeRun();
+	for (const run of runs) {
+		const complete = run.calls.every((call) => typeof call.id === "string" && resultById.has(call.id));
+		const ended = complete && (run.followedByUser || run.lastStopReason !== undefined);
+		registerTurn(run.calls, isErrorById, ended);
+	}
+}
+
+/** Registry lookup for the render dispatcher. */
+export function getTurnEntry(toolCallId: string): TurnEntry | undefined {
+	return memberByCallId.get(toolCallId);
+}
+
+/**
+ * Capture a member's component invalidate callback during a render pass. Pi
+ * only re-invokes the tool renderer selectors from updateDisplay(); calling
+ * the captured callback after turn_end rebuilds the block with the collapsed
+ * summary. Idempotent per toolCallId (latest component wins).
+ */
+export function noteTurnMemberRender(toolCallId: string, invalidate: () => void): void {
+	if (typeof invalidate !== "function") return;
+	invalidateByCallId.set(toolCallId, invalidate);
+}
+
+/**
+ * Force the just-finished turn's tool blocks to re-render (updateDisplay).
+ * Components that never rendered (headless/print) have no captured callback.
+ */
+export function invalidateTurnMembers(turn: TurnState): void {
+	for (const member of turn.members) {
+		const invalidate = invalidateByCallId.get(member.toolCallId);
+		if (!invalidate) continue;
+		try {
+			invalidate();
+		} catch {
+			// A detached component must not break the turn-end path.
+			invalidateByCallId.delete(member.toolCallId);
+		}
+	}
+}
+
+/**
+ * Freeze a member's wall-clock elapsed into the registry (idempotent; the
+ * value is frozen by the renderer state once the terminal result rendered).
+ */
+export function noteTurnMemberElapsed(toolCallId: string, elapsedMs: number | undefined): void {
+	if (elapsedMs === undefined) return;
+	const entry = memberByCallId.get(toolCallId);
+	if (!entry || entry.member.elapsedMs !== undefined) return;
+	entry.member.elapsedMs = elapsedMs;
+}
+
+/** Per-tool summary phrasing: `Read 2 files` / `ran 4 shell commands`. */
+const TURN_SUMMARY_STYLE: Readonly<Record<string, { readonly verb: string; readonly unit: string }>> = Object.freeze({
+	read: { verb: "Read", unit: "file" },
+	bash: { verb: "ran", unit: "shell command" },
+	ls: { verb: "Listed", unit: "path" },
+	find: { verb: "Found", unit: "file" },
+	grep: { verb: "Grepped", unit: "pattern" },
+	edit: { verb: "Edited", unit: "file" },
+	write: { verb: "Wrote", unit: "file" },
+	quick_edit: { verb: "Edited", unit: "file" },
+	substitute_edit: { verb: "Edited", unit: "file" },
+	target_edit: { verb: "Edited", unit: "file" },
+});
+
+export interface TurnSummaryParts {
+	/** `Read 2 files`, `ran 4 shell commands`, ... in first-use order. */
+	readonly parts: readonly string[];
+	readonly failedCount: number;
+	/** Sum of members' frozen elapsed; undefined when nothing was recorded. */
+	readonly elapsedMs: number | undefined;
+}
+
+/** Aggregate a turn's non-error members into summary parts (pure). */
+export function turnSummaryParts(turn: TurnState): TurnSummaryParts {
+	const counts = new Map<string, number>();
+	const order: string[] = [];
+	let failedCount = 0;
+	let elapsedMs: number | undefined;
+	for (const member of turn.members) {
+		if (member.isError) {
+			failedCount++;
+			continue;
+		}
+		if (member.elapsedMs !== undefined) elapsedMs = (elapsedMs ?? 0) + member.elapsedMs;
+		const existing = counts.get(member.toolName);
+		if (existing === undefined) {
+			counts.set(member.toolName, 1);
+			order.push(member.toolName);
+		} else counts.set(member.toolName, existing + 1);
+	}
+	const parts = order.map((toolName) => {
+		const count = counts.get(toolName) ?? 0;
+		const style = TURN_SUMMARY_STYLE[toolName] ?? { verb: "ran", unit: `${toolName} call` };
+		return `${style.verb} ${count} ${pluralForm(style.unit, count)}`;
+	});
+	return { parts, failedCount, elapsedMs };
+}
+
+function formatTurnSummaryLine(theme: BoxTheme, turn: TurnState): string {
+	const summary = turnSummaryParts(turn);
+	// The summary is deliberately quiet: the whole line renders dim so completed
+	// tool work recedes behind the assistant's answer. Only the failed marker
+	// stays error-colored (errors must remain visible).
+	const parts = summary.parts.join(", ");
+	let line = `${theme.fg("dim", `➔ ${parts}`)}`;
+	if (summary.failedCount > 0)
+		line += theme.fg("error", ` · ${summary.failedCount} ${pluralForm("failed", summary.failedCount)}`);
+	if (summary.elapsedMs !== undefined) line += theme.fg("dim", ` · ${(summary.elapsedMs / 1000).toFixed(2)}s`);
+	return line;
+}
+
+/** Leader call component: renders the live turn summary line on every pass. */
+export function renderTurnSummaryCall(theme: BoxTheme, turn: TurnState): Component {
+	return {
+		invalidate() {},
+		render(width: number): string[] {
+			return [safeTruncateToWidth(formatTurnSummaryLine(theme, turn), Math.max(1, width), "…")];
+		},
+	};
+}
+
+/**
+ * Empty result component for the turn-summary leader. The summary lives in the
+ * call component; the result adds nothing. Deliberately NOT the shared
+ * EMPTY_BATCH_COMPONENT singleton, so the decoration's hideBatchMember
+ * (identity-compared) never hides the leader.
+ */
+export function emptyTurnResult(): Component {
+	return {
+		invalidate() {},
+		render() {
+			return [];
+		},
+	};
+}

package/extension-src/pi-style/features/tools/index.ts

@@ -113,6 +113,19 @@ const DEFAULT_SNAPSHOT: ToolDecorationSnapshot = Object.freeze({
 });
 let ownerGeneration = 0;
 const piStyleWrappers = new WeakSet<RenderFunction>();
+
+/**
+ * The real Tui instance captured from decorated tool components (`instance.ui`),
+ * used to request a repaint after the turn registry flips a turn to collapsed
+ * (pi only re-paints after its own events; the renderer selectors re-run on
+ * updateDisplay, but the screen refresh still needs a requestRender).
+ */
+let capturedToolUi: { requestRender?: (force?: boolean) => void } | undefined;
+
+/** Request a screen repaint through the captured tool Tui (no-op headless). */
+export function requestToolPresentationRender(): void {
+	capturedToolUi?.requestRender?.();
+}
 let toolTestHooks: { defineProperty?: typeof Reflect.defineProperty; deleteProperty?: typeof Reflect.deleteProperty } =
 	{};
 export function __setToolDecorationTestHooks(hooks: typeof toolTestHooks): () => void {
@@ -392,12 +405,14 @@ export function createToolDecorationOwner(snapshot: Partial<ToolDecorationSnapsh
 			} else if (outcome === "later-owner") state.active.delete(record);
 			else state.failed++;
 		}
+		capturedToolUi = undefined;
 		const archive = state.active.size === 0 ? finalize(state) : undefined;
 		return { restored: state.restored, failed: state.failed, diagnostics: new Map(state.diagnostics), archive };
 	};
 	return Object.freeze({
 		decorateToolRendererSelection(subtype: RendererSubtype, original: unknown, instance: object, args: unknown[]) {
 			if (typeof original !== "function") return undefined;
+			capturedToolUi = (instance as { ui?: { requestRender?: (force?: boolean) => void } }).ui ?? capturedToolUi;
 			const renderer = Reflect.apply(original, instance, args);
 			if (state.snapshot.style === "compact-box") {
 				const toolName = (instance as { toolName?: unknown }).toolName;

package/extension-src/pi-style/pi/compatibility-coordinator.ts

@@ -6,6 +6,7 @@ import {
 	detectPiVersion,
 	disposePiCompatibilityProbe,
 	probePiCompatibility,
+	SUPPORTED_VERSION_RANGE,
 } from "./compatibility-probe.js";
 
 export interface CompatibilityCoordinator {
@@ -60,8 +61,10 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 					report?.unsupported.filter((item) =>
 						feature === "messages" ? item.subtype.includes("message") : item.subtype.includes("tool"),
 					) ?? [];
-				const failed = records.some((item) => /identity|failed|unsupported shape/i.test(item.reason));
-				const fallback = records.some((item) => /fallback|authorization|disabled/i.test(item.reason));
+				// Identity drift degrades only the affected surface to native (graceful);
+				// a feature is only "failed" when an install/shape error occurred.
+				const failed = records.some((item) => /failed|rejected|rolled back|shape is not/i.test(item.reason));
+				const fallback = records.some((item) => /fallback|authorization|disabled|identity/i.test(item.reason));
 				const authorized = Boolean(authorization?.core && surfaceAuthorized);
 				const installedRecord = report?.recordSnapshots.some(
 					(item) => item.feature === feature && !item.disposed && (subtype === undefined || item.subtype === subtype),
@@ -69,7 +72,7 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 				return {
 					configured,
 					authorized,
-					installed: Boolean(installedRecord && !failed && authorized && configured),
+					installed: Boolean(installedRecord && authorized && configured),
 					conflicted: records.some((item) => item.reason.includes("owner")),
 					failed,
 					cleanupPending,
@@ -81,12 +84,13 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 				configured: messagesConfigured || toolsConfigured,
 				authorized: authorization?.core ?? false,
 				installed: report !== undefined,
-				conflicted: report?.unsupported.some((item) => item.reason.includes("identity")) ?? false,
-				failed: report?.unsupported.some((item) => item.reason.includes("failed")) ?? false,
+				conflicted: report?.unsupported.some((item) => item.reason.includes("owner")) ?? false,
+				failed: report?.unsupported.some((item) => /failed|rejected|rolled back/i.test(item.reason)) ?? false,
 				cleanupPending,
-				nativeFallbacks: report?.unsupported.filter((item) => item.reason.includes("fallback")).length ?? 0,
+				nativeFallbacks: report?.unsupported.filter((item) => /fallback|identity/i.test(item.reason)).length ?? 0,
 				piVersion: version.version ?? report?.piVersion ?? "unknown",
-				versionRange: report?.versionRange ?? ">=0.83.0 <0.84.0",
+				versionRange: report?.versionRange ?? SUPPORTED_VERSION_RANGE,
+				supportedVersions: report?.supportedVersions ?? [],
 				assistantMessage: surface(
 					"messages",
 					config.enabled && config.messages.enabled && config.messages.assistantPrefix,
@@ -105,11 +109,13 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 			const productDenied = productGate === "deny";
 			if (cleanupPending && !report) cleanupPending = false;
 			if (cleanupPending || !tui || !config.enabled || !authorization?.core || productDenied) return undefined;
-			const certifiedHost = detectPiVersion().version === "0.83.0";
+			// Certification is per-surface identity (fingerprint) based, never pinned to
+			// a Pi version: authorization only needs the session flags + config. Version
+			// drift that preserves identities keeps working; changed identities degrade
+			// per-surface inside the probe.
 			const assistantEnabled =
 				authorization.assistant &&
 				isTierCAuthorized({
-					certifiedHost,
 					coreFlag: authorization.core,
 					surfaceFlag: true,
 					surface: "assistantMessage",
@@ -118,7 +124,6 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 			const specialBlocksEnabled =
 				authorization.specialBlocks &&
 				isTierCAuthorized({
-					certifiedHost,
 					coreFlag: authorization.core,
 					surfaceFlag: true,
 					surface: "specialBlocks",
@@ -133,7 +138,6 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 					config.messages.enabled &&
 					config.messages.hideThinkingLabel &&
 					isTierCAuthorized({
-						certifiedHost,
 						coreFlag: authorization.core,
 						surfaceFlag: true,
 						surface: "messages",
@@ -142,7 +146,7 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 			);
 			const toolsEnabled =
 				authorization.tools &&
-				isTierCAuthorized({ certifiedHost, coreFlag: authorization.core, surfaceFlag: true, surface: "tools", config });
+				isTierCAuthorized({ coreFlag: authorization.core, surfaceFlag: true, surface: "tools", config });
 			if (!messagesEnabled && !toolsEnabled) return undefined;
 			const detected = detectPiVersion();
 			report = probePiCompatibility(detected.version, {
@@ -164,6 +168,7 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 					assistantPrefix: authorization.ascii ? "[assistant] " : "│ ",
 					assistantEnabled,
 					collapseHiddenThinking: thinkingCollapseEnabled,
+					hideInterimText: config.messages.hideInterimText && messagesEnabled,
 				},
 				toolSnapshot: {
 					callMarker: authorization.ascii ? "[tool] " : "[tool] ",