pi-bar 0.3.25 → 0.3.27

package/README.md

@@ -9,9 +9,9 @@
 claude-opus-4.7  ❯  think:med  ❯  2.6% / 1.0M  ❯  Inspecting package structure  ❯  plan:active
 ```
 
-![pi-bar with low context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.25/assets/screenshot-green.png)
-![pi-bar with medium context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.25/assets/screenshot-yellow.png)
-![pi-bar with high context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.25/assets/screenshot-red.png)
+![pi-bar with low context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.27/assets/screenshot-green.png)
+![pi-bar with medium context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.27/assets/screenshot-yellow.png)
+![pi-bar with high context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.27/assets/screenshot-red.png)
 
 ## Why use it?
 

package/extensions/status-footer.ts

@@ -43,11 +43,7 @@ type SerializedStatusFilter =
 type TldrActivityType =
 	| "user_message"
 	| "assistant_update"
-	| "tool_input_start"
-	| "tool_input_update"
-	| "tool_input_end"
 	| "tool_call"
-	| "tool_execution_update"
 	| "tool_result"
 	| "assistant_final"
 	| "assistant_failure";
@@ -58,36 +54,17 @@ type TldrActivity = {
 	displayPriority: TldrDisplayPriority;
 	text: string;
 	toolCallId?: string;
-	// Identifies a continuous streaming run (tool input arg streaming, or tool
-	// execution output streaming). Activities sharing a group represent updates
-	// to the same task; staleness handling treats them as one stream.
-	progressGroup?: string;
 };
 type TldrCheckpoint = {
 	activityIndex: number;
-	activityType: TldrActivityType;
 	displayPriority: TldrDisplayPriority;
 	text: string;
-	progressGroup?: string;
 };
 type TldrCheckpointJob = {
 	activityIndex: number;
-	activityType: TldrActivityType;
 	displayPriority: TldrDisplayPriority;
 	runId: number;
-	progressGroup?: string;
 };
-
-// Activities that represent ongoing streaming work. These are treated
-// specially: their checkpoints can render even when newer same-stream activity
-// exists, and the display refresh slows to a 10s cadence for repeat renders so
-// the footer does not become a model-call ticker.
-function isToolProgressActivity(activityType: TldrActivityType): boolean {
-	return (
-		activityType === "tool_input_update" ||
-		activityType === "tool_execution_update"
-	);
-}
 type TldrModelPreference = { provider: string; id: string };
 type FastModelAuth = {
 	model: Parameters<typeof complete>[0];
@@ -111,16 +88,12 @@ const TLDR_MAX_TOKENS = 120;
 const TLDR_REQUEST_TIMEOUT_MS = 2_000;
 const TLDR_DISPLAY_UPDATE_INTERVAL_MS = 1_200;
 const TLDR_TARGET_SUMMARY_CHARS = 60;
-// While rendering successive progress checkpoints from the same stream (e.g.
-// long bash output), slow the display refresh dramatically. The TLDR text
-// barely changes between adjacent chunks; refreshing every 1.2s would burn API
-// calls and footer renders for noise.
-const TOOL_PROGRESS_DISPLAY_UPDATE_INTERVAL_MS = 10_000;
-const MAX_TOOL_PROGRESS_PARTIAL_CHARS = 280;
 // Burst debouncing on the generation side: coalesce rapid-fire activities into
 // one model call. Quiet window catches short bursts; max wait surfaces progress
 // during continuous activity.
-const NORMAL_CHECKPOINT_QUIET_MS = 700;
+// Quiet window long enough to let tool_result land before flushing, so the
+// model summarizes the completed outcome instead of guessing from tool_call.
+const NORMAL_CHECKPOINT_QUIET_MS = 1_500;
 const NORMAL_CHECKPOINT_MAX_WAIT_MS = 2_500;
 // Defensive ceiling: even if the model ignores the length instruction, never
 // blast a large payload into the footer.
@@ -477,58 +450,13 @@ function extractTextContent(content: readonly unknown[] | undefined): string | u
 	return compacted.length > 0 ? compacted : undefined;
 }
 
-type ToolInputAssistantEvent =
-	| { type: "toolcall_start"; contentIndex: number; partial: unknown }
-	| {
-			type: "toolcall_delta";
-			contentIndex: number;
-			delta: string;
-			partial: unknown;
-		}
-	| {
-			type: "toolcall_end";
-			contentIndex: number;
-			toolCall: { id: string; name: string; arguments?: unknown };
-			partial: unknown;
-		};
-
-function toolCallAtContentIndex(
-	partial: unknown,
-	contentIndex: number,
-): { id: string; name: string; arguments?: unknown } | undefined {
-	if (!partial || typeof partial !== "object") return undefined;
-	const content = (partial as { content?: unknown }).content;
-	if (!Array.isArray(content)) return undefined;
-	const block = content[contentIndex];
-	if (!block || typeof block !== "object") return undefined;
-	const record = block as Record<string, unknown>;
-	if (record.type !== "toolCall") return undefined;
-	if (typeof record.id !== "string" || typeof record.name !== "string") {
-		return undefined;
-	}
-	return {
-		id: record.id,
-		name: record.name,
-		arguments: record.arguments,
-	};
-}
-
 class TldrFactCollector {
 	private nextIndex = 1;
 	private readonly activities: TldrActivity[] = [];
-	// Streaming tool inputs (`toolcall_start/delta/end` from message_update)
-	// arrive before the final tool id is available; content index is the best
-	// stable anchor until the id appears.
-	private readonly activeToolInputAnchors = new Map<string, string>();
 
 	resetConversation(): void {
 		this.nextIndex = 1;
 		this.activities.splice(0);
-		this.activeToolInputAnchors.clear();
-	}
-
-	latestActivity(): TldrActivity | undefined {
-		return this.activities[this.activities.length - 1];
 	}
 
 	recordUserMessage(prompt: string): TldrActivity {
@@ -560,79 +488,6 @@ class TldrFactCollector {
 		);
 	}
 
-	// Stage 1: tool input streaming. The model is writing tool name + args; pi
-	// surfaces this via `assistantMessageEvent` on `message_update` with
-	// toolcall_start / toolcall_delta / toolcall_end. Useful when args are long
-	// (big edits, structured plans) and the user wants visible progress before
-	// the actual tool execution starts.
-	recordToolInputActivity(
-		event: ToolInputAssistantEvent | undefined,
-	): TldrActivity | undefined {
-		if (!event) return undefined;
-
-		switch (event.type) {
-			case "toolcall_start": {
-				const toolCall = toolCallAtContentIndex(event.partial, event.contentIndex);
-				const toolName = toolCall?.name ?? "unknown";
-				const anchorKey = toolCall?.id ?? `content:${event.contentIndex}`;
-				const anchorText = `tool input: ${toolName}`;
-				this.activeToolInputAnchors.set(anchorKey, anchorText);
-				return this.addActivity(
-					"tool_input_start",
-					"normal",
-					anchorText,
-					toolCall?.id,
-				);
-			}
-			case "toolcall_delta": {
-				const toolCall = toolCallAtContentIndex(event.partial, event.contentIndex);
-				const anchorKey = toolCall?.id ?? `content:${event.contentIndex}`;
-				const anchorText =
-					this.activeToolInputAnchors.get(anchorKey) ??
-					`tool input: ${toolCall?.name ?? "unknown"}`;
-
-				// Repeated delta updates for the same call collapse into the latest
-				// snapshot. Otherwise long arg streams would push out useful facts.
-				const last = this.activities[this.activities.length - 1];
-				if (
-					last?.activityType === "tool_input_update" &&
-					last.progressGroup === `tool-input:${anchorKey}`
-				) {
-					this.activities.pop();
-				}
-
-				const argSnapshot = compactValue(toolCall?.arguments, 200);
-				const chunk = event.delta
-					? `latest: ${truncateText(compactText(event.delta), 120)}`
-					: undefined;
-				const update = [argSnapshot, chunk].filter(Boolean).join("; ");
-
-				return this.addActivity(
-					"tool_input_update",
-					"normal",
-					`${anchorText}; ${update || "streaming"}`,
-					toolCall?.id,
-					`tool-input:${anchorKey}`,
-				);
-			}
-			case "toolcall_end": {
-				const anchorKey = event.toolCall.id;
-				const anchorText =
-					this.activeToolInputAnchors.get(anchorKey) ??
-					`tool input: ${event.toolCall.name}`;
-				this.activeToolInputAnchors.delete(anchorKey);
-
-				const args = compactValue(event.toolCall.arguments, 240);
-				return this.addActivity(
-					"tool_input_end",
-					"normal",
-					args ? `${anchorText} completed; ${args}` : `${anchorText} completed`,
-					event.toolCall.id,
-				);
-			}
-		}
-	}
-
 	recordToolCall(event: {
 		toolName: string;
 		input?: Record<string, unknown>;
@@ -646,45 +501,6 @@ class TldrFactCollector {
 		);
 	}
 
-	// Stage 2: tool execution streaming. The host is running the tool and
-	// emitting partial output. Tagged with progressGroup so adjacent chunks of
-	// the same execution are treated as one continuous stream.
-	recordToolExecutionUpdate(event: {
-		toolCallId: string;
-		toolName: string;
-		partialResult: unknown;
-	}): TldrActivity {
-		const partialText =
-			extractTextContent(
-				Array.isArray((event.partialResult as { content?: unknown })?.content)
-					? ((event.partialResult as { content: unknown[] }).content as unknown[])
-					: undefined,
-			) ??
-			compactValue(event.partialResult, MAX_TOOL_PROGRESS_PARTIAL_CHARS) ??
-			"streaming";
-
-		const progressGroup = `tool-execution:${event.toolCallId}`;
-
-		// Adjacent execution-update activities for the same stream collapse into
-		// the latest. The retained activity list stays bounded and the model sees
-		// one current snapshot of in-progress output.
-		const last = this.activities[this.activities.length - 1];
-		if (
-			last?.activityType === "tool_execution_update" &&
-			last.progressGroup === progressGroup
-		) {
-			this.activities.pop();
-		}
-
-		return this.addActivity(
-			"tool_execution_update",
-			"normal",
-			`running ${event.toolName}; ${tailText(partialText, MAX_TOOL_PROGRESS_PARTIAL_CHARS)}`,
-			event.toolCallId,
-			progressGroup,
-		);
-	}
-
 	recordToolResult(event: {
 		toolName: string;
 		input?: Record<string, unknown>;
@@ -703,24 +519,15 @@ class TldrFactCollector {
 		const status = isError ? "error" : "ok";
 		const tool = compactToolInput(event.toolName, event.input);
 
-		// The completed result fact subsumes all in-progress facts for the same
-		// call: the original tool_call, any tool_input_* lifecycle facts, and any
-		// tool_execution_update progress. The model only needs the final outcome.
+		// Result fact subsumes the prior tool_call fact for the same call. Drop the
+		// matching tool_call so the model sees one combined fact instead of two.
 		if (event.toolCallId) {
-			const id = event.toolCallId;
-			for (let i = this.activities.length - 1; i >= 0; i--) {
-				const activity = this.activities[i];
-				if (activity.toolCallId !== id) continue;
-				if (
-					activity.activityType === "tool_call" ||
-					activity.activityType === "tool_input_start" ||
-					activity.activityType === "tool_input_update" ||
-					activity.activityType === "tool_input_end" ||
-					activity.activityType === "tool_execution_update"
-				) {
-					this.activities.splice(i, 1);
-				}
-			}
+			const idx = this.activities.findIndex(
+				(activity) =>
+					activity.activityType === "tool_call" &&
+					activity.toolCallId === event.toolCallId,
+			);
+			if (idx !== -1) this.activities.splice(idx, 1);
 		}
 
 		return this.addActivity(
@@ -788,15 +595,13 @@ class TldrFactCollector {
 		displayPriority: TldrDisplayPriority,
 		text: string,
 		toolCallId?: string,
-		progressGroup?: string,
 	): TldrActivity {
-		const activity: TldrActivity = {
+		const activity = {
 			index: this.nextIndex,
 			activityType,
 			displayPriority,
 			text: truncateText(text, MAX_ACTIVITY_TEXT_CHARS),
 			toolCallId,
-			progressGroup,
 		};
 		this.nextIndex++;
 		this.activities.push(activity);
@@ -828,9 +633,6 @@ class FooterTldrEngine {
 	private pendingNormalCheckpoint?: TldrCheckpointJob;
 	private normalCheckpointTimer?: ReturnType<typeof setTimeout>;
 	private normalCheckpointBurstStartedAt?: number;
-	// Last progress stream that produced a rendered checkpoint. Used to slow the
-	// display refresh for repeat renders from the same stream.
-	private lastRenderedProgressGroup?: string;
 
 	constructor(private readonly requestRender: () => void) {}
 
@@ -850,47 +652,32 @@ class FooterTldrEngine {
 	}
 
 	recordUserMessage(ctx: ExtensionContext, prompt: string): void {
+		// A new user turn replaces the entire visible TLDR context, so wipe both
+		// the rendered text and the prior-turn checkpoint context that feeds the
+		// model. Carrying old checkpoints biased the next turn's phrasing toward
+		// the previous task.
 		this.currentText = null;
+		this.lastRenderedText = "";
+		this.acceptedCheckpoints.splice(0);
+		this.latestAcceptedActivityIndex = 0;
 		this.requestRender();
 		this.enqueue(ctx, this.facts.recordUserMessage(prompt));
 	}
 
-	recordAssistantUpdate(
-		ctx: ExtensionContext,
-		message: unknown,
-		assistantMessageEvent?: unknown,
-	): void {
-		// Tool input streaming hides inside `message_update`. Drain that signal
-		// first; only if no tool-input fact was produced does this look like a
-		// plain assistant text update worth recording.
-		const toolInputActivity = this.facts.recordToolInputActivity(
-			normalizeToolInputEvent(assistantMessageEvent),
-		);
-		if (toolInputActivity) {
-			this.enqueue(ctx, toolInputActivity);
-			return;
-		}
-
+	recordAssistantUpdate(ctx: ExtensionContext, message: unknown): void {
 		const activity = this.facts.recordAssistantUpdate(message);
 		if (activity) this.enqueue(ctx, activity);
 	}
 
 	recordToolCall(
-		ctx: ExtensionContext,
+		_ctx: ExtensionContext,
 		event: { toolName: string; input?: Record<string, unknown>; toolCallId?: string },
 	): void {
-		this.enqueue(ctx, this.facts.recordToolCall(event));
-	}
-
-	recordToolExecutionUpdate(
-		ctx: ExtensionContext,
-		event: {
-			toolCallId: string;
-			toolName: string;
-			partialResult: unknown;
-		},
-	): void {
-		this.enqueue(ctx, this.facts.recordToolExecutionUpdate(event));
+		// Record the fact so a subsequent checkpoint sees the tool was started,
+		// but DO NOT enqueue. tool_call alone has no outcome; flushing here
+		// before tool_result arrives makes the model hallucinate "completed
+		// successfully". The tool_result event triggers the actual checkpoint.
+		this.facts.recordToolCall(event);
 	}
 
 	recordToolResult(
@@ -915,9 +702,33 @@ class FooterTldrEngine {
 			this.startFreshRun();
 			return;
 		}
+
+		// Failure/aborted finals have no narratable content. A model call here
+		// fabricates a reason; render a deterministic literal instead.
+		if (result.activityType === "assistant_failure") {
+			const stopReason = extractStopReason(message);
+			this.renderLiteralFinal(stopReason);
+			this.facts.resetConversation();
+			this.startFreshRun();
+			return;
+		}
+
 		this.enqueue(ctx, result);
 	}
 
+	private renderLiteralFinal(stopReason: string | undefined): void {
+		this.clearPendingDisplay();
+		this.clearPendingNormalCheckpoint();
+		this.checkpointQueue.splice(0);
+		this.abortInFlightCheckpoint();
+		const literal = stopReason === "aborted" ? "Aborted." : `Stopped: ${stopReason ?? "error"}.`;
+		this.currentText = literal;
+		this.lastRenderedText = literal;
+		this.lastRenderedActivityIndex = this.facts.latestActivityIndex();
+		this.lastDisplayAt = performance.now();
+		this.requestRender();
+	}
+
 	private startFreshRun(): void {
 		this.runId++;
 		this.cancelWork();
@@ -927,7 +738,6 @@ class FooterTldrEngine {
 		this.lastDisplayAt = Number.NEGATIVE_INFINITY;
 		this.acceptedCheckpoints.splice(0);
 		this.pendingDisplayCheckpoint = undefined;
-		this.lastRenderedProgressGroup = undefined;
 		this.currentText = null;
 		this.requestRender();
 	}
@@ -996,12 +806,10 @@ class FooterTldrEngine {
 
 	private enqueue(ctx: ExtensionContext, activity: TldrActivity): void {
 		if (!ctx.hasUI) return;
-		const job: TldrCheckpointJob = {
+		const job = {
 			activityIndex: activity.index,
-			activityType: activity.activityType,
 			displayPriority: activity.displayPriority,
 			runId: this.runId,
-			progressGroup: activity.progressGroup,
 		};
 
 		if (job.displayPriority === "immediate") {
@@ -1035,13 +843,9 @@ class FooterTldrEngine {
 		this.scheduleNormalCheckpoint(ctx, job);
 	}
 
-	private clearDisplayTimer(): void {
+	private clearPendingDisplay(): void {
 		if (this.displayTimer) clearTimeout(this.displayTimer);
 		this.displayTimer = undefined;
-	}
-
-	private clearPendingDisplay(): void {
-		this.clearDisplayTimer();
 		this.pendingDisplayCheckpoint = undefined;
 	}
 
@@ -1099,12 +903,10 @@ class FooterTldrEngine {
 			const rawText = extractTextContent(response.content) ?? "";
 			const text = sanitizeTldrText(rawText);
 			if (!text) return;
-			const checkpoint: TldrCheckpoint = {
+			const checkpoint = {
 				activityIndex: job.activityIndex,
-				activityType: job.activityType,
 				displayPriority: job.displayPriority,
 				text,
-				progressGroup: job.progressGroup,
 			};
 			this.acceptCheckpoint(checkpoint);
 			this.considerDisplayingCheckpoint(ctx, checkpoint);
@@ -1136,7 +938,7 @@ class FooterTldrEngine {
 		checkpoint: TldrCheckpoint,
 	): void {
 		if (checkpoint.activityIndex <= this.lastRenderedActivityIndex) return;
-		if (this.shouldDropStaleCheckpoint(checkpoint)) return;
+		if (checkpoint.activityIndex !== this.facts.latestActivityIndex()) return;
 
 		if (checkpoint.displayPriority !== "normal" || !this.lastRenderedText) {
 			this.clearPendingDisplay();
@@ -1144,77 +946,37 @@ class FooterTldrEngine {
 			return;
 		}
 
-		const displayIntervalMs = this.displayIntervalFor(checkpoint);
 		const elapsedMs = performance.now() - this.lastDisplayAt;
-		if (elapsedMs >= displayIntervalMs) {
+		if (elapsedMs >= TLDR_DISPLAY_UPDATE_INTERVAL_MS) {
 			this.clearPendingDisplay();
 			this.renderCheckpoint(checkpoint);
 			return;
 		}
 
 		this.pendingDisplayCheckpoint = checkpoint;
-		// Recompute the timer for each newly accepted pending checkpoint. A long
-		// 10s progress-stream debounce should not block a subsequent ordinary
-		// update that wants to render at the normal 1.2s cadence.
-		this.clearDisplayTimer();
+		if (this.displayTimer) return;
 		this.displayTimer = setTimeout(() => {
 			this.displayTimer = undefined;
 			const pending = this.pendingDisplayCheckpoint;
 			this.pendingDisplayCheckpoint = undefined;
-			if (!pending) return;
-			if (this.shouldDropStaleCheckpoint(pending)) return;
+			if (!pending || pending.activityIndex !== this.facts.latestActivityIndex()) return;
 			this.renderCheckpoint(pending);
-		}, displayIntervalMs - elapsedMs);
-	}
-
-	// A model call for chunk N may finish after chunk N+1 has been recorded.
-	// Most stale checkpoints are dropped, but progress streams are an exception:
-	// while the same stream is still active, a slightly-behind TLDR is still
-	// useful, and dropping it would leave the footer stuck on older text.
-	private shouldDropStaleCheckpoint(checkpoint: TldrCheckpoint): boolean {
-		if (checkpoint.activityIndex === this.facts.latestActivityIndex()) {
-			return false;
-		}
-
-		// Boundary checkpoints (user_message, assistant_final, etc.) must stay
-		// latest-only. A stale prompt-start or final TLDR would describe the wrong
-		// turn entirely.
-		if (checkpoint.displayPriority !== "normal") return true;
-
-		if (!isToolProgressActivity(checkpoint.activityType)) return true;
-		if (!checkpoint.progressGroup) return true;
-
-		const latestActivity = this.facts.latestActivity();
-		return !(
-			latestActivity &&
-			latestActivity.index > checkpoint.activityIndex &&
-			latestActivity.activityType === checkpoint.activityType &&
-			latestActivity.progressGroup === checkpoint.progressGroup
-		);
-	}
-
-	private displayIntervalFor(checkpoint: TldrCheckpoint): number {
-		if (!isToolProgressActivity(checkpoint.activityType)) {
-			return TLDR_DISPLAY_UPDATE_INTERVAL_MS;
-		}
-		// First render from a new progress group uses the normal cadence so the
-		// user sees the stream's first TLDR quickly. Subsequent renders for the
-		// same group slow down: the model output barely changes between chunks.
-		return checkpoint.progressGroup &&
-			checkpoint.progressGroup === this.lastRenderedProgressGroup
-			? TOOL_PROGRESS_DISPLAY_UPDATE_INTERVAL_MS
-			: TLDR_DISPLAY_UPDATE_INTERVAL_MS;
+		}, TLDR_DISPLAY_UPDATE_INTERVAL_MS - elapsedMs);
 	}
 
 	private renderCheckpoint(checkpoint: TldrCheckpoint): void {
 		if (checkpoint.activityIndex <= this.lastRenderedActivityIndex) return;
 		if (checkpoint.text === this.lastRenderedText) return;
+		// Skip near-duplicates: a burst of consecutive checkpoints often produces
+		// the same action fragment with only punctuation/casing differences. They
+		// flash visibly in the footer without adding information.
+		if (isNearDuplicateTldr(checkpoint.text, this.lastRenderedText)) {
+			this.lastRenderedActivityIndex = checkpoint.activityIndex;
+			return;
+		}
 		this.lastRenderedActivityIndex = checkpoint.activityIndex;
 		this.lastRenderedText = checkpoint.text;
 		this.lastDisplayAt = performance.now();
-		this.lastRenderedProgressGroup = isToolProgressActivity(checkpoint.activityType)
-			? checkpoint.progressGroup
-			: undefined;
 		this.currentText = checkpoint.text;
 		this.requestRender();
 	}
@@ -1252,12 +1014,19 @@ function checkpointSystemPrompt(job: TldrCheckpointJob): string {
 			? "Start with a past-tense verb."
 			: "Start with a present-tense -ing verb.";
 	// Frame the model as a human developer describing visible work, not an agent
-	// summarizing its own mechanics. Avoids leaks like tool names, prompt labels,
-	// or our internal scaffolding (activity indexes, prior checkpoints).
+	// summarizing its own mechanics. The banned phrases and few-shot examples
+	// fix concrete regressions observed in backtests: tool-name verbs, success
+	// suffixes, file path leaks, and markdown formatting.
 	return `Write one plain-English TLDR for a Pi coding agent.
 Describe the work progress as if a human developer were doing it.
 Focus on the task activity and current outcome, not agent mechanics.
 Do not mention tools, tool calls, prompts, messages, model output, or implementation details.
+Do not start with tool-name verbs such as Read, Reading, Grep, Listing, Counting, Extracting, Displaying, Editing, Writing, Running, Publishing.
+Use human-developer verbs instead: Reviewing, Investigating, Exploring, Updating, Refining, Fixing, Implementing, Wrapping up.
+Do not use file paths, file extensions, code identifiers, package names, or version strings.
+Do not use backticks, asterisks, underscores, quotes, or any markdown formatting.
+Do not append filler suffixes such as "with success", "successfully", or "completed successfully".
+Do not claim progress or completion that is not present in the activity.
 Use the prior TLDRs for context and the new activity for the update.
 Summarize the current state of work; do not narrate the history.
 If context is sparse, still summarize the available activity.
@@ -1268,9 +1037,45 @@ Prefer verb + direct object. Include outcome only if important.
 Do not address the user.
 Output only the status fragment itself. No prefixes, labels, bullets, or quotes.
 Plain text only; no markdown, JSON, code, file paths, or tool names.
+
+Good examples:
+- Reviewing footer summary behavior
+- Investigating live TLDR regressions
+- Refining sanitizer for stray prefixes
+- Wrapping up extension release
+
+Bad examples:
+- Editing extensions/status-footer.ts with success.
+- Reading status-footer file completed successfully.
+- Publishing \`pi-bar@0.3.3\` to npm.
+- Grepping for sanitizeTldrText callers.
+
 ${tenseInstruction}`;
 }
 
+function extractStopReason(message: unknown): string | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const record = message as Record<string, unknown>;
+	const stopReason = record.stopReason;
+	return typeof stopReason === "string" ? stopReason : undefined;
+}
+
+// Two TLDRs are near-duplicates if their normalized action fragments (lowercase,
+// punctuation/whitespace collapsed) match. Catches bursts of cosmetic variants
+// like "Editing X." vs "Editing X" vs "editing  x.".
+function normalizedActionFragment(text: string): string {
+	return text
+		.toLowerCase()
+		.replace(/[\p{P}\p{S}]+/gu, " ")
+		.replace(/\s+/gu, " ")
+		.trim();
+}
+
+function isNearDuplicateTldr(current: string, previous: string): boolean {
+	if (!previous) return false;
+	return normalizedActionFragment(current) === normalizedActionFragment(previous);
+}
+
 function previousCheckpointLines(checkpoints: readonly TldrCheckpoint[]): string {
 	if (checkpoints.length === 0) return "none";
 	return checkpoints
@@ -1283,50 +1088,6 @@ function formatRawActivity(activity: TldrActivity): string {
 	return `- ${activity.text}`;
 }
 
-// Narrows the unknown `assistantMessageEvent` from `message_update` to the
-// three tool-input streaming variants. Other event shapes (text_start, etc.)
-// produce undefined, signalling "no tool input fact to record".
-function normalizeToolInputEvent(value: unknown): ToolInputAssistantEvent | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const record = value as Record<string, unknown>;
-	const type = record.type;
-	if (type !== "toolcall_start" && type !== "toolcall_delta" && type !== "toolcall_end") {
-		return undefined;
-	}
-	if (typeof record.contentIndex !== "number") return undefined;
-
-	if (type === "toolcall_delta") {
-		return {
-			type,
-			contentIndex: record.contentIndex,
-			delta: typeof record.delta === "string" ? record.delta : "",
-			partial: record.partial,
-		};
-	}
-	if (type === "toolcall_end") {
-		const toolCall = record.toolCall;
-		if (
-			!toolCall ||
-			typeof toolCall !== "object" ||
-			typeof (toolCall as Record<string, unknown>).id !== "string" ||
-			typeof (toolCall as Record<string, unknown>).name !== "string"
-		) {
-			return undefined;
-		}
-		return {
-			type,
-			contentIndex: record.contentIndex,
-			toolCall: toolCall as { id: string; name: string; arguments?: unknown },
-			partial: record.partial,
-		};
-	}
-	return {
-		type,
-		contentIndex: record.contentIndex,
-		partial: record.partial,
-	};
-}
-
 // Strips ANSI/CSI/OSC/DCS/SOS/PM/APC escape sequences from model output before
 // it lands in the terminal. The TLDR text is model-controlled and renders into
 // the footer; the system prompt asking for plain text is not a security
@@ -1436,6 +1197,7 @@ function stripTerminalControls(text: string): string {
 const LEAKED_PREFIX_PATTERN =
 	/^\s*(?:[-*•]\s*)?(?:(?:through\s+activity|activity|checkpoint)\s+\d+\s*[:.\-—–]\s*|(?:tldr|summary)\s*[:.\-—–]\s*)+/i;
 const LEADING_PUNCT_PATTERN = /^[\s\-—–•*:#.,;]+/;
+const TRAILING_PUNCT_PATTERN = /[\s\-—–•*:#.,;]+$/;
 
 function stripLeakedScaffolding(text: string): string {
 	let cleaned = text;
@@ -1448,13 +1210,63 @@ function stripLeakedScaffolding(text: string): string {
 	return cleaned;
 }
 
+// Strip backticks (` and triple-backtick fences) and markdown emphasis markers
+// the model occasionally adds despite the prompt's plain-text rule. We keep
+// inner content verbatim; only the formatting characters disappear.
+function stripMarkdownFormatting(text: string): string {
+	return text
+		.replace(/```+/g, "")
+		.replace(/`+/g, "")
+		.replace(/(^|[^\\])([*_~]{1,3})(.+?)\2/g, "$1$3");
+}
+
+// File-path / version / package leaks observed in backtests:
+//   extensions/status-footer.ts, README.md, package.json, pi-bar@0.3.3, …
+const FILE_PATH_PATTERN =
+	/(?:\b[\w./@-]+\.(?:ts|tsx|js|jsx|mjs|cjs|md|json|yml|yaml|toml|lock|sh|py|rs|go|html|css))\b/g;
+const PACKAGE_VERSION_PATTERN = /\b[\w./@-]+@\d[\w.+-]*\b/g;
+const VERSION_PATTERN = /\bv?\d+\.\d+(?:\.\d+(?:[-+][\w.]+)?)?\b/g;
+
+function stripIdentifierLeaks(text: string): string {
+	return text
+		.replace(PACKAGE_VERSION_PATTERN, "")
+		.replace(FILE_PATH_PATTERN, "")
+		.replace(VERSION_PATTERN, "")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+// Trailing filler suffixes observed in backtests:
+//   "... with success.", "... completed successfully.", "... successfully."
+const SUCCESS_SUFFIX_PATTERN =
+	/[\s,;:—–-]*(?:with\s+success|completed\s+successfully|finished\s+successfully|done\s+successfully|successfully\s+completed|successfully\s+finished|successfully)\s*[.!?]*\s*$/i;
+
+function stripSuccessSuffix(text: string): string {
+	let cleaned = text;
+	let stripped = false;
+	while (true) {
+		const next = cleaned.replace(SUCCESS_SUFFIX_PATTERN, "").trim();
+		if (next === cleaned || next.length === 0) break;
+		cleaned = next;
+		stripped = true;
+	}
+	// Only clean up trailing punctuation when an actual success suffix was
+	// removed; otherwise we would strip the natural period from a normal
+	// sentence like "Reviewing footer behavior.".
+	if (stripped) cleaned = cleaned.replace(TRAILING_PUNCT_PATTERN, "").trim();
+	return cleaned;
+}
+
 function sanitizeTldrText(
 	text: string,
 	maxChars = MAX_SAFE_TLDR_CHARS,
 ): string {
 	const stripped = stripTerminalControls(text);
-	const cleaned = stripLeakedScaffolding(stripped) || stripped;
-	return truncateText(cleaned, maxChars);
+	const withoutMarkdown = stripMarkdownFormatting(stripped);
+	const withoutScaffolding = stripLeakedScaffolding(withoutMarkdown) || withoutMarkdown;
+	const withoutLeaks = stripIdentifierLeaks(withoutScaffolding) || withoutScaffolding;
+	const withoutSuccess = stripSuccessSuffix(withoutLeaks) || withoutLeaks;
+	return truncateText(withoutSuccess, maxChars);
 }
 
 function shouldShowStatus(key: string, filter: StatusFilter): boolean {
@@ -1744,18 +1556,11 @@ export default function (pi: ExtensionAPI) {
 		tldr.recordUserMessage(ctx, event.prompt);
 	});
 	pi.on("message_update", async (event, ctx) => {
-		tldr.recordAssistantUpdate(
-			ctx,
-			event.message,
-			(event as { assistantMessageEvent?: unknown }).assistantMessageEvent,
-		);
+		tldr.recordAssistantUpdate(ctx, event.message);
 	});
 	pi.on("tool_call", async (event, ctx) => {
 		tldr.recordToolCall(ctx, event);
 	});
-	pi.on("tool_execution_update", async (event, ctx) => {
-		tldr.recordToolExecutionUpdate(ctx, event);
-	});
 	pi.on("tool_result", async (event, ctx) => {
 		tldr.recordToolResult(ctx, event);
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bar",
-  "version": "0.3.25",
+  "version": "0.3.27",
   "description": "Pi footer/statusline showing active model, thinking level, context pressure, live TLDR, and extension statuses.",
   "type": "module",
   "keywords": [
@@ -51,6 +51,6 @@
     "extensions": [
       "./extensions/status-footer.ts"
     ],
-    "image": "https://cdn.jsdelivr.net/npm/pi-bar@0.3.25/assets/screenshot-yellow.png"
+    "image": "https://cdn.jsdelivr.net/npm/pi-bar@0.3.27/assets/screenshot-yellow.png"
   }
 }