@quandev104/pi-style 0.1.2 → 0.1.4

package/extension-src/pi-style/features/tools/boxed/session-config.ts

@@ -8,6 +8,10 @@ export interface ToolsRenderConfig {
 	maxExpandedLines: number;
 	dimOutput: boolean;
 	showElapsed: boolean;
+	/** Open-tree glyph for the done batch header (nerd `\u{F111}` / unicode `●`). */
+	batchOpenGlyph: string;
+	/** Nerd Font mode is active: file-type icons render in output trees. */
+	nerdFonts: boolean;
 }
 
 let sessionToolsConfig: ToolsRenderConfig = {
@@ -15,6 +19,8 @@ let sessionToolsConfig: ToolsRenderConfig = {
 	maxExpandedLines: 50,
 	dimOutput: false,
 	showElapsed: true,
+	batchOpenGlyph: "●",
+	nerdFonts: false,
 };
 
 export function setToolsRenderConfig(config: Partial<ToolsRenderConfig>): void {
@@ -27,19 +33,79 @@ export function getToolsRenderConfig(): ToolsRenderConfig {
 
 // Wall-clock elapsed tracking through the renderer context state (no tool
 // re-registration, so result.details has no execution timing).
+//
+// Elapsed is computed live from the recorded start on every read, so a running
+// tool keeps growing its displayed time. The value only freezes once the
+// execution end is recorded (terminal result), which keeps the completed footer
+// stable across later re-renders (expand toggles, terminal resizes).
 
 const STARTED_AT_KEY = "__piStyleStartedAt";
-const ELAPSED_MS_KEY = "__piStyleElapsedMs";
+const ENDED_AT_KEY = "__piStyleEndedAt";
+const RESULT_SEEN_KEY = "__piStyleResultSeen";
+const TICKER_KEY = "__piStyleElapsedTicker";
 
 export function recordExecutionStarted(state: Record<string, unknown> | undefined, executionStarted: boolean): void {
 	if (!executionStarted || !state || typeof state !== "object") return;
 	if (typeof state[STARTED_AT_KEY] !== "number") state[STARTED_AT_KEY] = performance.now();
 }
 
+/** Freeze the elapsed at the first terminal render (idempotent). */
+export function recordExecutionEnded(state: Record<string, unknown> | undefined): void {
+	if (!state || typeof state !== "object") return;
+	if (typeof state[ENDED_AT_KEY] !== "number") state[ENDED_AT_KEY] = performance.now();
+}
+
 export function getStateElapsedMs(state: Record<string, unknown> | undefined): number | undefined {
 	if (!state || typeof state !== "object") return undefined;
-	if (typeof state[ELAPSED_MS_KEY] !== "number" && typeof state[STARTED_AT_KEY] === "number") {
-		state[ELAPSED_MS_KEY] = performance.now() - state[STARTED_AT_KEY];
+	const started = state[STARTED_AT_KEY];
+	if (typeof started !== "number") return undefined;
+	const ended = state[ENDED_AT_KEY];
+	if (typeof ended === "number") return Math.max(0, ended - started);
+	return Math.max(0, performance.now() - started);
+}
+
+/** Whether a result renderer already produced a continuation for this call. */
+export function isResultSeen(state: Record<string, unknown> | undefined): boolean {
+	return Boolean(state && typeof state === "object" && state[RESULT_SEEN_KEY] === true);
+}
+
+/** Record that a result renderer ran for this call (streaming or final). */
+export function markResultSeen(state: Record<string, unknown> | undefined): void {
+	if (!state || typeof state !== "object") return;
+	state[RESULT_SEEN_KEY] = true;
+}
+
+type TickerHandle = ReturnType<typeof setInterval>;
+
+/** States that currently own a 1s elapsed-render interval, for session cleanup. */
+const tickerStates = new Set<Record<string, unknown>>();
+
+/**
+ * While a tool is running, re-render once per second so live elapsed labels
+ * tick without any output events. Idempotent per state.
+ */
+export function startElapsedTicker(state: Record<string, unknown> | undefined, invalidate: () => void): void {
+	if (!state || typeof state !== "object") return;
+	if (state[TICKER_KEY] !== undefined) return;
+	state[TICKER_KEY] = setInterval(() => invalidate(), 1000) as unknown as TickerHandle;
+	tickerStates.add(state);
+}
+
+/** Stop a running tool's elapsed ticker (terminal result, error, session end). */
+export function stopElapsedTicker(state: Record<string, unknown> | undefined): void {
+	if (!state || typeof state !== "object") return;
+	const handle = state[TICKER_KEY] as TickerHandle | undefined;
+	if (handle !== undefined) clearInterval(handle);
+	delete state[TICKER_KEY];
+	tickerStates.delete(state);
+}
+
+/** Stop every elapsed ticker (session start/shutdown). */
+export function stopAllElapsedTickers(): void {
+	for (const state of tickerStates) {
+		const handle = state[TICKER_KEY] as TickerHandle | undefined;
+		if (handle !== undefined) clearInterval(handle);
+		delete state[TICKER_KEY];
 	}
-	return typeof state[ELAPSED_MS_KEY] === "number" ? state[ELAPSED_MS_KEY] : undefined;
+	tickerStates.clear();
 }

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

@@ -13,12 +13,21 @@ import {
 	resolveRelativePath,
 	shortenPath,
 } from "../../../shared/box.js";
-import { getStateElapsedMs, recordExecutionStarted } from "./session-config.js";
+import {
+	getStateElapsedMs,
+	isResultSeen,
+	markResultSeen,
+	recordExecutionEnded,
+	recordExecutionStarted,
+	startElapsedTicker,
+	stopElapsedTicker,
+} from "./session-config.js";
 
 /** Renderer context delivered by Pi's ToolExecutionComponent (getRenderContext). */
 export interface BoxedToolContext {
 	readonly args: Record<string, unknown>;
 	readonly toolCallId: string;
+	readonly invalidate: () => void;
 	readonly state: Record<string, unknown>;
 	readonly cwd: string;
 	readonly executionStarted: boolean;
@@ -88,6 +97,7 @@ export function compactCall(
 		isError: Boolean(options.context.isError),
 		isPartial: Boolean(options.context.isPartial),
 		isPending: pendingFlag(options.context),
+		running: Boolean(options.context.executionStarted),
 	});
 }
 
@@ -96,6 +106,36 @@ export function noteExecutionStart(context: BoxedToolContext): void {
 	recordExecutionStarted(context.state, context.executionStarted);
 }
 
+/**
+ * Keep running/ended execution state in sync from a call renderer pass. While
+ * the tool runs, a 1s re-render ticker keeps live elapsed labels current; once
+ * the call renders in its terminal form the elapsed freezes.
+ */
+export function noteBoxedCallState(context: BoxedToolContext): void {
+	if (!context.executionStarted) return;
+	if (context.isPartial) startElapsedTicker(context.state, context.invalidate);
+	else {
+		recordExecutionEnded(context.state);
+		stopElapsedTicker(context.state);
+	}
+}
+
+/**
+ * Record a result renderer pass and keep the ticker/ended state in sync.
+ * Returns whether this is the first result pass for the call, so renderers can
+ * render nothing while the pending/running call card stands alone.
+ */
+export function noteBoxedResultPhase(context: BoxedToolContext, isPartial: boolean): boolean {
+	const firstResultPass = !isResultSeen(context.state);
+	markResultSeen(context.state);
+	if (isPartial) startElapsedTicker(context.state, context.invalidate);
+	else {
+		recordExecutionEnded(context.state);
+		stopElapsedTicker(context.state);
+	}
+	return firstResultPass;
+}
+
 export function stateElapsedMs(context: BoxedToolContext): number | undefined {
 	return getStateElapsedMs(context.state);
 }

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

@@ -1,8 +1,26 @@
 // Boxed write tool renderer
 // (renderCall/renderResult only).
+//
+// The write call renders a compact preview box: the file path in the top
+// border, the written content as numbered lines in the body (cat -n style),
+// and the metrics footer in the bottom border. The footer lives in the shared
+// renderer state — the result renderer stores it (elapsed + words), the call
+// component reads it at paint time and closes the box. The preview is capped
+// at the collapsed line budget with a `Ctrl+O for more` hint on the bottom
+// border when truncated; expanded shows the expanded budget. Errors keep the
+// plain open call box so the boxed error result never duplicates a box.
 
+import type { Component } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../../../shared/ansi.js";
-import { boxedToolWidthKey, getTextOutput, renderBoxedToolResult, stripTrailingNotice } from "../../../shared/box.js";
+import {
+	type BoxTheme,
+	boxedToolWidthKey,
+	getTextOutput,
+	renderBoxedToolResult,
+	renderCompactBoxedToolCall,
+	replaceTabs,
+} from "../../../shared/box.js";
+import { getToolsRenderConfig } from "./session-config.js";
 import {
 	type BoxedToolDefinition,
 	clearFooterState,
@@ -13,36 +31,94 @@ import {
 	resultFooterLines,
 } from "./shared.js";
 
-function parseWriteSummary(output: string): string | undefined {
-	const normalized = stripTrailingNotice(stripAnsi(output ?? "")).trim();
-	if (!normalized) return undefined;
+/** Right-side bottom-border hint shown when the compact preview is truncated. */
+const WRITE_EXPAND_HINT = "Ctrl+O for more";
 
-	const byteMatch = normalized.match(/\bwrote\s+(\d+)\s+bytes?\b/i);
-	if (byteMatch) {
-		const bytes = Number(byteMatch[1]);
-		if (Number.isFinite(bytes)) {
-			return `↳ Wrote ${bytes} ${bytes === 1 ? "byte" : "bytes"}.`;
-		}
-	}
+/** Partial-pass result: the compact call keeps its `◌ Running` card. */
+const EMPTY_WRITE_RESULT: Component = Object.freeze({
+	invalidate() {},
+	render() {
+		return [];
+	},
+});
 
-	const lineMatch = normalized.match(/\bwrote\s+(\d+)\s+lines?\b/i);
-	if (lineMatch) {
-		const count = Number(lineMatch[1]);
-		if (Number.isFinite(count)) {
-			return `↳ Wrote ${count} ${count === 1 ? "line" : "lines"}.`;
-		}
-	}
+type NumberedLine = { number: string; content: string };
+
+/**
+ * Numbered preview lines for the written content, `cat -n` style: every split
+ * line keeps its number (including a trailing empty line produced by a final
+ * newline), right-aligned to the widest line number.
+ */
+function numberedPreviewLines(content: string): NumberedLine[] {
+	const normalized = replaceTabs(String(content ?? "")).replace(/\r/g, "");
+	if (!normalized) return [];
+	const lines = normalized.split("\n");
+	const gutterWidth = Math.max(1, String(lines.length).length);
+	return lines.map((line, index) => ({
+		number: String(index + 1).padStart(gutterWidth),
+		content: line,
+	}));
+}
 
-	return undefined;
+/** One boxed preview row: dim gutter + toolOutput content. */
+function formatNumberedLine(theme: BoxTheme, line: NumberedLine): string {
+	return `${theme.fg("borderMuted", `${line.number} `)}${theme.fg("toolOutput", line.content)}`;
+}
+
+/** Compact write box: path header, numbered content preview, metrics footer. */
+function renderWritePreviewBox(
+	theme: BoxTheme,
+	detailLine: string,
+	content: string,
+	options: {
+		state?: Record<string, unknown>;
+		isError: boolean;
+		isPending: boolean;
+		running?: boolean;
+		expanded: boolean;
+	},
+): Component {
+	const preview = numberedPreviewLines(content);
+	const config = getToolsRenderConfig();
+	const budget = options.expanded ? config.maxExpandedLines : config.maxCollapsedLines;
+	const truncated = preview.length > budget;
+
+	return renderCompactBoxedToolCall(theme, "Write", detailLine, {
+		...(options.state ? { state: options.state } : {}),
+		isError: options.isError,
+		isPending: options.isPending,
+		running: Boolean(options.running),
+		bodyLines: () => {
+			if (preview.length === 0) return [];
+			const shown = preview.slice(0, budget).map((line) => formatNumberedLine(theme, line));
+			if (!truncated) return shown;
+			const omitted = preview.length - budget;
+			const note = options.expanded ? `… ${omitted} more lines omitted by render budget` : `… ${omitted} more lines`;
+			return [...shown, theme.fg("muted", note)];
+		},
+		...(options.expanded || options.isPending || !truncated ? {} : { bottomRightLabel: WRITE_EXPAND_HINT }),
+	});
 }
 
 export const writeTool: BoxedToolDefinition = {
 	call(args, theme, context) {
 		noteExecutionStart(context);
 		const detail = displayPath(String(args?.path ?? args?.file_path ?? ""), context);
-		return compactCall(theme, "Write", `${theme.fg("dim", "Path: ")}${detail}`, {
-			detailKey: detail,
-			context,
+		const detailLine = `${theme.fg("dim", "Path: ")}${detail}`;
+		// On error keep the plain open box: the result renderer continues it with
+		// the boxed error body, so call and result never duplicate a box.
+		if (context.isError) {
+			return compactCall(theme, "Write", detailLine, {
+				detailKey: detail,
+				context,
+			});
+		}
+		return renderWritePreviewBox(theme, detailLine, String(args?.content ?? ""), {
+			state: context.state,
+			isError: Boolean(context.isError),
+			isPending: Boolean(context.isPartial),
+			running: Boolean(context.executionStarted),
+			expanded: Boolean(context.expanded),
 		});
 	},
 	result(result, options, theme, context) {
@@ -59,31 +135,13 @@ export const writeTool: BoxedToolDefinition = {
 			});
 		}
 
-		if (!options.expanded) return compactFooterWithState(theme, result, context);
-
-		const content = String(context?.args?.content ?? "");
-		const lineCount = content ? content.split("\n").length : 0;
-		if (lineCount > 0) {
-			const summary = `↳ Wrote ${lineCount} ${lineCount === 1 ? "line" : "lines"}.`;
-			return renderBoxedToolResult(theme, () => [theme.fg("dim", summary)], {
-				widthKey,
-				footerLines: resultFooterLines(theme, result, context),
-			});
-		}
-
-		const summary = parseWriteSummary(output);
-		if (summary) {
-			return renderBoxedToolResult(theme, () => [theme.fg("dim", summary)], {
-				widthKey,
-				footerLines: resultFooterLines(theme, result, context),
-			});
-		}
+		// While the result is still streaming, don't stamp a metrics footer into
+		// the shared state: the compact call keeps its `◌ Running` card and only
+		// closes with `elapsed · words` once the tool settles.
+		if (options.isPartial) return EMPTY_WRITE_RESULT;
 
-		const normalized = stripTrailingNotice(stripAnsi(output)).trim();
-		const fallback = normalized ? `↳ ${normalized}` : "↳ Wrote file.";
-		return renderBoxedToolResult(theme, () => [theme.fg("dim", fallback)], {
-			widthKey,
-			footerLines: resultFooterLines(theme, result, context),
-		});
+		// Success (compact and expanded): the preview box closes with the metrics
+		// footer stored into the shared renderer state; the result adds nothing.
+		return compactFooterWithState(theme, result, context);
 	},
 };

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

@@ -1,6 +1,19 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
+import { EMPTY_BATCH_COMPONENT } from "./boxed/batch.js";
 import { renderBoxedToolCall, renderBoxedToolResult } from "./boxed/index.js";
 
+/**
+ * Batch members render zero lines. Pi's ToolExecutionComponent always adds a
+ * built-in Spacer child (one blank line) and only sets hideComponent when
+ * hasContent is false — but adding an empty renderer still marks hasContent
+ * true. Mark the instance hidden so members contribute zero lines (no stray
+ * blank margin after the batch panel). updateDisplay resets hideComponent on
+ * every pass; the wrapper re-applies it on each dispatch.
+ */
+function hideBatchMember(instance: object): void {
+	(instance as { hideComponent?: boolean }).hideComponent = true;
+}
+
 /**
  * Neutralize the native ToolExecutionComponent status background for boxed
  * rendering: Pi's updateDisplay sets contentBox/selfRenderContainer bgFn to
@@ -434,6 +447,7 @@ export function createToolDecorationOwner(snapshot: Partial<ToolDecorationSnapsh
 									);
 								})();
 					neutralizeToolContainerBackground(instance);
+					if (component === EMPTY_BATCH_COMPONENT) hideBatchMember(instance);
 					return component;
 				};
 			}

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

@@ -11,7 +11,6 @@ import {
 export interface CompatibilityCoordinator {
 	captureAuthorization(
 		coreFlag: boolean,
-		userFlag: boolean,
 		assistantFlag: boolean,
 		specialBlocksFlag: boolean,
 		toolsFlag: boolean,
@@ -33,7 +32,6 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 	let authorization:
 		| {
 				core: boolean;
-				user: boolean;
 				assistant: boolean;
 				specialBlocks: boolean;
 				tools: boolean;
@@ -44,15 +42,13 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 		get report() {
 			return report;
 		},
-		captureAuthorization(core, user, assistant, specialBlocks, tools, ascii) {
-			authorization = { core, user, assistant, specialBlocks, tools, ascii };
+		captureAuthorization(core, assistant, specialBlocks, tools, ascii) {
+			authorization = { core, assistant, specialBlocks, tools, ascii };
 		},
 		state(config) {
 			const version = detectPiVersion();
 			const messagesConfigured =
-				config.enabled &&
-				config.messages.enabled &&
-				(config.messages.userPrefix || config.messages.assistantPrefix || config.messages.specialBlocks);
+				config.enabled && config.messages.enabled && (config.messages.assistantPrefix || config.messages.specialBlocks);
 			const toolsConfigured = config.enabled && config.tools.enabled;
 			const surface = (
 				feature: "messages" | "tools",
@@ -91,12 +87,6 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 				nativeFallbacks: report?.unsupported.filter((item) => item.reason.includes("fallback")).length ?? 0,
 				piVersion: version.version ?? report?.piVersion ?? "unknown",
 				versionRange: report?.versionRange ?? ">=0.83.0 <0.84.0",
-				userMessage: surface(
-					"messages",
-					config.enabled && config.messages.enabled && config.messages.userPrefix,
-					Boolean(authorization?.user),
-					"native-user-message",
-				),
 				assistantMessage: surface(
 					"messages",
 					config.enabled && config.messages.enabled && config.messages.assistantPrefix,
@@ -116,15 +106,6 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 			if (cleanupPending && !report) cleanupPending = false;
 			if (cleanupPending || !tui || !config.enabled || !authorization?.core || productDenied) return undefined;
 			const certifiedHost = detectPiVersion().version === "0.83.0";
-			const userEnabled =
-				authorization.user &&
-				isTierCAuthorized({
-					certifiedHost,
-					coreFlag: authorization.core,
-					surfaceFlag: true,
-					surface: "userMessage",
-					config,
-				});
 			const assistantEnabled =
 				authorization.assistant &&
 				isTierCAuthorized({
@@ -143,7 +124,7 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 					surface: "specialBlocks",
 					config,
 				});
-			const messagesEnabled = (userEnabled || assistantEnabled || specialBlocksEnabled) && config.messages.enabled;
+			const messagesEnabled = (assistantEnabled || specialBlocksEnabled) && config.messages.enabled;
 			const toolsEnabled =
 				authorization.tools &&
 				isTierCAuthorized({ certifiedHost, coreFlag: authorization.core, surfaceFlag: true, surface: "tools", config });
@@ -155,7 +136,6 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 					messages: {
 						...config.messages,
 						enabled: messagesEnabled,
-						userPrefix: userEnabled,
 						assistantPrefix: assistantEnabled,
 						specialBlocks: messagesEnabled && config.messages.specialBlocks && specialBlocksEnabled,
 					},
@@ -165,9 +145,7 @@ export function createCompatibilityCoordinator(dispose = disposePiCompatibilityP
 					},
 				},
 				messageSnapshot: {
-					userPrefix: authorization.ascii ? "[user] " : "❯ ",
 					assistantPrefix: authorization.ascii ? "[assistant] " : "│ ",
-					userEnabled,
 					assistantEnabled,
 				},
 				toolSnapshot: {

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

@@ -8,7 +8,6 @@ import {
 	CustomMessageComponent,
 	SkillInvocationMessageComponent,
 	ToolExecutionComponent,
-	UserMessageComponent,
 } from "@earendil-works/pi-coding-agent";
 import { decorateMessageRender, type MessageDecorationSnapshot } from "../features/messages/index.js";
 import { renderSpecialMessageBlock, type SpecialBlockSubtype } from "../features/messages/special-blocks.js";
@@ -31,7 +30,6 @@ const reportStates = new WeakMap<
 // code loaded before this module could spoof the same function source. We therefore
 // fail closed on every unrecorded Pi build and never use module-load capture as trust.
 export const TRUSTED_NATIVE_FINGERPRINTS: Readonly<Record<string, string>> = Object.freeze({
-	"native-user-message:render": "b442a17c",
 	"native-assistant-message:render": "2a39243f",
 	"native-compaction-message:updateDisplay": "f8c44e78",
 	"native-branch-message:updateDisplay": "415d57b7",
@@ -43,19 +41,6 @@ export const TRUSTED_NATIVE_FINGERPRINTS: Readonly<Record<string, string>> = Obj
 
 export const CERTIFICATION_TABLE = Object.freeze({
 	"0.83.0": Object.freeze({
-		"native-user-message:render": Object.freeze({
-			feature: "messages",
-			subtype: "native-user-message",
-			target: UserMessageComponent.prototype,
-			method: "render",
-			writable: true,
-			configurable: true,
-			name: "render",
-			arity: 1,
-			fingerprint: TRUSTED_NATIVE_FINGERPRINTS["native-user-message:render"],
-			adapterId: "message-prefix-osc133-v1",
-			status: "certified" as const,
-		}),
 		"native-assistant-message:render": Object.freeze({
 			feature: "messages",
 			subtype: "native-assistant-message",
@@ -232,14 +217,6 @@ function trustedNativeIdentity(spec: TargetSpec, piVersion: string | undefined):
 }
 
 export const targetSpecs: readonly TargetSpec[] = [
-	{
-		feature: "messages",
-		subtype: "native-user-message",
-		target: UserMessageComponent.prototype,
-		method: "render",
-		adapterId: "message-prefix-osc133-v1",
-		status: "certified",
-	},
 	{
 		feature: "messages",
 		subtype: "native-assistant-message",
@@ -404,7 +381,7 @@ function shape(target: object, method: string): boolean {
 export interface CompatibilityProbeOptions {
 	markers?: Set<string>;
 	config?: Readonly<{
-		messages: { enabled: boolean; userPrefix: boolean; assistantPrefix: boolean; specialBlocks: boolean };
+		messages: { enabled: boolean; assistantPrefix: boolean; specialBlocks: boolean };
 		tools: { enabled: boolean; style: string; maxCollapsedLines: number; maxExpandedLines: number; dimOutput: boolean };
 		preset: string;
 	}>;
@@ -450,7 +427,6 @@ function surfaceDisabled(spec: TargetSpec, config: CompatibilityProbeOptions["co
 	if (!config) return false;
 	if (spec.feature === "tools") return !config.tools.enabled;
 	if (!config.messages.enabled) return true;
-	if (spec.subtype === "native-user-message") return !config.messages.userPrefix;
 	if (spec.subtype === "native-assistant-message") return !config.messages.assistantPrefix;
 	if (isSpecialBlock(spec)) return !config.messages.specialBlocks;
 	return true;
@@ -496,14 +472,8 @@ function probeSpec(options: {
 						args,
 					) ?? Reflect.apply(original as (...values: unknown[]) => unknown, target, args)
 				);
-			if (spec.subtype === "native-user-message" || spec.subtype === "native-assistant-message")
-				return decorateMessageRender(
-					spec.subtype as "native-user-message" | "native-assistant-message",
-					original,
-					target,
-					args,
-					messageSnapshot,
-				);
+			if (spec.subtype === "native-assistant-message")
+				return decorateMessageRender(original, target, args, messageSnapshot);
 			return renderSpecialMessageBlock(spec.subtype as SpecialBlockSubtype, original, target, args);
 		},
 	});

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

@@ -1,5 +1,4 @@
 export type CompatibilitySubtype =
-	| "native-user-message"
 	| "native-assistant-message"
 	| "native-compaction-message"
 	| "native-branch-message"

package/extension-src/pi-style/pi/config-session.ts

@@ -8,7 +8,6 @@ export interface SessionFlagReader {
 }
 export interface SessionAuthorization {
 	core: boolean;
-	user: boolean;
 	assistant: boolean;
 	specialBlocks: boolean;
 	tools: boolean;
@@ -59,7 +58,6 @@ export function resolveProductGate(
 export function readSessionAuthorization(pi: SessionFlagReader): SessionAuthorization {
 	return {
 		core: pi.getFlag("pi-style-core-patches") === true,
-		user: pi.getFlag("pi-style-message-user") === true,
 		assistant: pi.getFlag("pi-style-message-assistant") === true,
 		specialBlocks: pi.getFlag("pi-style-message-special-blocks") === true,
 		tools: pi.getFlag("pi-style-tools") === true,

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

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { StatusSnapshot } from "../domain/status.js";
+import { closeActiveBatch } from "../features/tools/boxed/batch.js";
 import { registerPiStyleCommand } from "./commands.js";
 import { type CompatibilityTestHooks, createPiStyleSessionCoordinator } from "./session-coordinator.js";
 import { usageFromSession } from "./session-usage.js";
@@ -10,6 +11,24 @@ function usagePatch(ctx: ExtensionContext): StatusSnapshot {
 	return usage ? { usage } : {};
 }
 
+/**
+ * Add Pi's read-only tools (grep/find/ls) to the active tool set if they are
+ * registered. Preserves any other active tools (e.g. extension tools).
+ * Only calls setActiveTools when something actually changed.
+ */
+function activateReadOnlyTools(pi: ExtensionAPI): void {
+	const available = new Set(pi.getAllTools().map((tool) => tool.name));
+	const active = new Set(pi.getActiveTools());
+	let changed = false;
+	for (const name of ["grep", "find", "ls"] as const) {
+		if (available.has(name) && !active.has(name)) {
+			active.add(name);
+			changed = true;
+		}
+	}
+	if (changed) pi.setActiveTools([...active]);
+}
+
 let compatibilityTestHooks: CompatibilityTestHooks = {};
 export function __setCompatibilityTestHooks(hooks: CompatibilityTestHooks): () => void {
 	const previous = compatibilityTestHooks;
@@ -26,10 +45,10 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	// product gate `compatibility.allowCorePatches: false` (or `enabled: false`) in config.
 	for (const [name, description] of [
 		["pi-style-core-patches", "Enable pi-style message/tool core patches"],
-		["pi-style-message-user", "Enable pi-style user message prefix"],
 		["pi-style-message-assistant", "Enable pi-style assistant message prefix"],
 		["pi-style-message-special-blocks", "Enable pi-style boxed compaction/skill/branch/custom message blocks"],
 		["pi-style-tools", "Enable pi-style tool renderer decoration"],
+		["pi-style-readonly-tools", "Enable grep/find/ls read-only tools in the active tool set"],
 	] as const)
 		pi.registerFlag(name, { type: "boolean", description, default: true });
 	// ASCII markers stay opt-in; unicode markers are the default.
@@ -37,6 +56,13 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	const coordinator = createPiStyleSessionCoordinator(pi, compatibilityTestHooks);
 	registerPiStyleCommand(pi, coordinator.app);
 	pi.on("session_start", async (event, ctx) => {
+		// Pi only activates read/bash/edit/write by default; grep/find/ls are
+		// registered but inactive (kept out of the model's tool list to keep the
+		// core small). Activate them so the TUI shows them and the model can call
+		// them directly, mirroring Claude Code's glob/grep/read tool set.
+		if (pi.getFlag("pi-style-readonly-tools") === true) {
+			activateReadOnlyTools(pi);
+		}
 		await coordinator.start(event, ctx);
 	});
 	pi.on("agent_start", () => coordinator.app.runtime.current?.dismissStartup());
@@ -54,6 +80,14 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	);
 	pi.on("thinking_level_select", (event) => coordinator.app.update({ thinkingLevel: event.level }, "immediate"));
 	pi.on("session_info_changed", (event) => coordinator.app.update({ sessionName: event.name }, "coalesced"));
+	pi.on("message_start", () => {
+		// A new message is a batch boundary: quiet-tool (read/ls/find) calls of the
+		// new message start a fresh batch instead of joining the previous one.
+		closeActiveBatch();
+		// grep/bash tree panels are NOT cleared here: historical panels must keep
+		// their state so Pi re-renders of previous messages (scroll/resume) stay
+		// intact. Only session boundaries reset them (session-coordinator).
+	});
 	pi.on("message_update", () => coordinator.app.update({}, "coalesced"));
 	// Usage (tokens + cost) is aggregated from finalized session entries at
 	// message/turn boundaries, mirroring Pi's native footer; per-chunk updates