pi-ui-extend 0.1.48 → 0.1.49

package/dist/app/rendering/conversation-tool-renderer.js

@@ -31,7 +31,6 @@ export function renderConversationToolEntry(entry, width, options) {
         id: entry.id,
         toolName,
         headerArgs: display.headerArgs,
-        headerArgsSegments: display.headerArgsSegments,
         bodyLineStyles: display.bodyLineStyles,
         bodyStyle: display.bodyStyle,
         preserveAnsi: display.preserveAnsi,

package/dist/app/rendering/tool-block-renderer.d.ts

@@ -2,13 +2,12 @@ import { type ResolvedToolRule } from "../../config.js";
 import type { ToolBodySyntaxHighlights } from "../../syntax-highlight.js";
 import type { Theme } from "../../theme.js";
 import type { RenderedLine } from "../types.js";
-import type { ToolBodyLineStyle, ToolHeaderSegment } from "../../tool-renderers/types.js";
+import type { ToolBodyLineStyle } from "../../tool-renderers/types.js";
 export type ToolBlockEntry = {
     id: string;
     toolName: string;
     headerLabel?: string | undefined;
     headerArgs?: string | undefined;
-    headerArgsSegments?: readonly ToolHeaderSegment[] | undefined;
     bodyLineStyles?: readonly ToolBodyLineStyle[] | undefined;
     bodyStyle?: "diff" | undefined;
     preserveAnsi?: boolean | undefined;

package/dist/app/rendering/tool-block-renderer.js

@@ -19,7 +19,7 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const expanded = entry.expanded;
     const stateIcon = toolStatusIcon(entry);
     const toolColor = options.headerColorOverride ?? resolveColor(rule.color, colors);
-    const toolOutputColor = colors.statusForeground;
+    const toolOutputColor = toolColor;
     const headerLabel = (entry.headerLabel ?? entry.toolName).toLowerCase();
     const bg = options.backgroundOverride;
     const applyBackground = bg ? (lines) => { for (const line of lines)
@@ -31,7 +31,6 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const target = { kind: "tool", id: entry.id };
     const showGutter = options.showGutter ?? true;
     const header = clippedHeaderArgs ? `${headerPrefix} ${clippedHeaderArgs}` : headerPrefix;
-    const headerArgsStart = clippedHeaderArgs ? headerPrefix.length + 1 : header.length;
     const headerLine = {
         text: header,
         target,
@@ -40,7 +39,6 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
         segments: [
             { start: 0, end: stateIcon.length, foreground: toolStatusIconColor(entry, colors), bold: true },
             { start: stateIcon.length, end: headerPrefix.length, bold: true },
-            ...headerArgsStyledSegments(headerArgsStart, clippedHeaderArgs.length, entry.headerArgsSegments, colors),
         ],
     };
     const headerLines = [headerLine];
@@ -88,10 +86,7 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
 }
 function renderCollapsedPreviewLines(entry, body, rule, width, target, color, colors, hasLspDiagnostics, showGutter) {
     const preview = previewBodyText(body, rule.direction, rule.previewLines);
-    // bodyLineStyles is aligned to entry.expandedText (args block prefix + output), but the
-    // collapsed body here is the raw output only. Applying bodyLineStyles would misalign and
-    // incorrectly dim the first N output lines, so we do not pass it to the collapsed preview.
-    const allPreviewLines = renderToolBodyLines(preview.text, width, target, color, entry.bodyStyle, colors, undefined, entry.bodyWrap, hasLspDiagnostics, undefined, entry.preserveAnsi, showGutter, { rawLineOffset: preview.rawLineOffset, bodyEndsAfterText: !preview.omittedAfter });
+    const allPreviewLines = renderToolBodyLines(preview.text, width, target, color, entry.bodyStyle, colors, undefined, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter, { rawLineOffset: preview.rawLineOffset, bodyEndsAfterText: !preview.omittedAfter });
     const overflow = preview.omittedBefore || preview.omittedAfter || allPreviewLines.length > rule.previewLines;
     if (!overflow)
         return allPreviewLines;
@@ -487,38 +482,3 @@ function diffLineStyle(line, colors) {
 function formatToolHeaderArgs(argsText) {
     return sanitizeText(argsText ?? "").replace(/\n+/g, " ").trim();
 }
-function headerArgsStyledSegments(headerArgsStart, clippedLength, customSegments, colors) {
-    if (clippedLength <= 0)
-        return [];
-    if (!customSegments || customSegments.length === 0)
-        return [{ start: headerArgsStart, end: headerArgsStart + clippedLength, foreground: colors.muted }];
-    const segments = [];
-    let offset = 0;
-    const clippedCustomSegments = customSegments
-        .map((segment) => clippedHeaderSegment(segment, clippedLength))
-        .filter((segment) => segment !== undefined)
-        .sort((left, right) => left.start - right.start || left.end - right.end);
-    for (const segment of clippedCustomSegments) {
-        const start = Math.max(offset, segment.start);
-        if (start >= segment.end)
-            continue;
-        if (start > offset)
-            segments.push({ start: headerArgsStart + offset, end: headerArgsStart + start, foreground: colors.muted });
-        segments.push({
-            ...segment,
-            start: headerArgsStart + start,
-            end: headerArgsStart + segment.end,
-        });
-        offset = segment.end;
-    }
-    if (offset < clippedLength)
-        segments.push({ start: headerArgsStart + offset, end: headerArgsStart + clippedLength, foreground: colors.muted });
-    return segments;
-}
-function clippedHeaderSegment(segment, clippedLength) {
-    const start = Math.max(0, Math.min(clippedLength, segment.start));
-    const end = Math.max(start, Math.min(clippedLength, segment.end));
-    if (end <= start)
-        return undefined;
-    return { ...segment, start, end };
-}

package/dist/tool-renderers/compress.js

@@ -1,4 +1,4 @@
-import { compactProgressBarSegments, formatCompactProgressBar } from "../context-progress-bar.js";
+import { formatCompactProgressBar } from "../context-progress-bar.js";
 import { parseArgsText, stringArg } from "./utils.js";
 export const renderCompressTool = (input) => {
     const topic = stringArg(input, ["topic"]);
@@ -6,7 +6,6 @@ export const renderCompressTool = (input) => {
     const header = joinHeaderParts(topic ? { text: topic } : undefined, summary) ?? { text: "" };
     return {
         ...(header.text ? { headerArgs: header.text } : {}),
-        ...((header.segments?.length ?? 0) > 0 ? { headerArgsSegments: header.segments } : {}),
         collapsedBody: "",
         expandedText: fullCompressResponse(input.output, input.status),
     };
@@ -20,14 +19,14 @@ function formatCompressSummary(input) {
     const parsed = parseArgsText(output);
     if (!isRecord(parsed))
         return { text: oneLine(output) };
-    return formatCompressSuccess(parsed, input);
+    return formatCompressSuccess(parsed);
 }
 function fullCompressResponse(output, status) {
     if (output.trim())
         return output.trimEnd();
     return status === "running" ? "running…" : "(empty)";
 }
-function formatCompressSuccess(result, input) {
+function formatCompressSuccess(result) {
     const tokensSaved = numberValue(result.tokensSaved);
     const contextPercent = numberValue(result.contextPercent);
     const contextTokens = numberValue(result.contextTokens);
@@ -43,7 +42,7 @@ function formatCompressSuccess(result, input) {
     const barPercent = compressedContextPercent ?? contextPercent;
     const parts = [
         { text: tokensSaved != null ? `saved ${formatCompactNumber(tokensSaved)}` : "compressed" },
-        barPercent != null ? progressPart(barPercent, input, originalContextTokens) : undefined,
+        barPercent != null ? progressPart(barPercent, originalContextTokens) : undefined,
         compressedContextPercent != null && contextPercent != null ? { text: `context ${formatPercent(contextPercent)}` } : undefined,
         itemCount != null ? { text: `${itemCount} ${plural(itemCount, "item")}` } : undefined,
         summaryTokens != null ? { text: `${formatCompactNumber(summaryTokens)} summary tokens` } : undefined,
@@ -53,17 +52,9 @@ function formatCompressSuccess(result, input) {
     ].filter((part) => Boolean(part));
     return joinHeaderParts(...parts) ?? { text: "compressed" };
 }
-function progressPart(percent, input, previousContextTokens) {
+function progressPart(percent, previousContextTokens) {
     const text = `${formatCompactProgressBar(percent)} ${formatPercent(percent)}${previousContextTokens != null ? ` of ${formatCompactNumber(previousContextTokens)}` : ""}`;
-    if (!input.colors)
-        return { text };
-    return {
-        text,
-        segments: compactProgressBarSegments(0, percent, {
-            fill: input.toolColor ?? input.colors.muted,
-            track: input.colors.statusDotBase,
-        }),
-    };
+    return { text };
 }
 function inferContextTokens(contextPercent, contextWindow) {
     if (contextPercent == null || contextWindow == null || contextWindow <= 0)
@@ -80,19 +71,7 @@ function joinHeaderParts(...parts) {
     if (defined.length === 0)
         return undefined;
     const separator = " · ";
-    const segments = [];
-    let offset = 0;
-    for (const [index, part] of defined.entries()) {
-        if (index > 0)
-            offset += separator.length;
-        if (part.segments) {
-            for (const segment of part.segments) {
-                segments.push({ ...segment, start: offset + segment.start, end: offset + segment.end });
-            }
-        }
-        offset += part.text.length;
-    }
-    return { text: defined.map((part) => part.text).join(separator), segments };
+    return { text: defined.map((part) => part.text).join(separator) };
 }
 function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;

package/dist/tool-renderers/index.js

@@ -4,6 +4,7 @@ import { renderCompressTool } from "./compress.js";
 import { renderQuestionTool } from "./question.js";
 import { renderReadTool } from "./read.js";
 import { renderRepoTool } from "./repo.js";
+import { renderSearchTool } from "./search.js";
 import { renderShellTool } from "./shell.js";
 import { applySkillReadDisplay } from "./skill.js";
 import { renderSubagentsTool } from "./subagents.js";
@@ -25,6 +26,13 @@ const TOOL_RENDERERS = {
     Write: renderWriteTool,
     ast_grep: renderAstTool,
     ast_apply: renderAstTool,
+    grep: renderSearchTool,
+    Grep: renderSearchTool,
+    rg: renderSearchTool,
+    Glob: renderSearchTool,
+    glob: renderSearchTool,
+    find: renderSearchTool,
+    Find: renderSearchTool,
     web_search: renderWebSearchTool,
     web_fetch: renderWebFetchTool,
     todo: renderTodoTool,

package/dist/tool-renderers/question.js

@@ -16,7 +16,7 @@ export const renderQuestionTool = (input) => {
     return {
         headerArgs: formatHeader(questions),
         collapsedBody: resultText,
-        ...expandedTextFromParts({ text: questionsText, color: "muted" }, { text: input.isError ? `error\n${resultText}` : resultText }),
+        ...expandedTextFromParts({ text: questionsText }, { text: input.isError ? `error\n${resultText}` : resultText }),
     };
 };
 function questionItems(value) {

package/dist/tool-renderers/search.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderSearchTool: ToolRendererMiddleware;

package/dist/tool-renderers/search.js

@@ -0,0 +1,15 @@
+import { argsRecord, formatArgsInline } from "./utils.js";
+// Search tools (grep/Glob/find) show their arguments inline in the header. Rendering the
+// arguments again as a muted body block (as defaultToolRender does) would dim the first output
+// lines and duplicate the header, so these tools render the output only — like repo_* tools.
+const PREFERRED_KEYS = ["pattern", "path", "glob", "type", "output_mode", "output_line_limit", "case_sensitive", "regex", "multiline", "-n", "context", "head_limit", "max_results"];
+export const renderSearchTool = (input) => {
+    const args = argsRecord(input);
+    const result = input.output || (input.status === "running" ? "running…" : "(empty)");
+    const headerArgs = args ? formatArgsInline(args, PREFERRED_KEYS) : undefined;
+    return {
+        ...(headerArgs ? { headerArgs } : {}),
+        collapsedBody: input.output,
+        expandedText: result,
+    };
+};

package/dist/tool-renderers/skill.js

@@ -10,7 +10,7 @@ export function applySkillReadDisplay(input, rendered) {
     if (!skill)
         return rendered;
     const pathText = skill.path ?? "";
-    const expanded = expandedTextFromParts({ text: pathText, color: "muted" }, { text: resultText(input, { empty: !pathText }) });
+    const expanded = expandedTextFromParts({ text: pathText }, { text: resultText(input, { empty: !pathText }) });
     const resultStartLine = pathText ? lineCount(pathText) + 1 : 0;
     return {
         ...rendered,

package/dist/tool-renderers/types.d.ts

@@ -1,13 +1,5 @@
 import type { Theme } from "../theme.js";
 import type { ToolBodySyntaxHighlights } from "../syntax-highlight.js";
-export type ToolHeaderSegment = {
-    start: number;
-    end: number;
-    foreground?: string;
-    background?: string;
-    bold?: boolean;
-    strikethrough?: boolean;
-};
 export type ToolBodyLineStyle = {
     startLine: number;
     endLine?: number;
@@ -31,7 +23,6 @@ export type ToolRenderInput = {
 export type ToolRenderResult = {
     toolName?: string;
     headerArgs?: string;
-    headerArgsSegments?: readonly ToolHeaderSegment[];
     bodyLineStyles?: readonly ToolBodyLineStyle[];
     bodyStyle?: "diff";
     preserveAnsi?: boolean;

package/dist/tool-renderers/utils.js

@@ -70,7 +70,7 @@ export function resultSection(input) {
 export function argsAndResultExpandedText(input, argsBlock) {
     const formattedArgs = argsBlock.trimEnd();
     const showArgs = formattedArgs.length > 0 && formattedArgs !== "(empty)";
-    return expandedTextFromParts(...(showArgs ? [{ text: formattedArgs, color: "muted" }] : []), { text: resultText(input, { empty: !showArgs }) });
+    return expandedTextFromParts(...(showArgs ? [{ text: formattedArgs }] : []), { text: resultText(input, { empty: !showArgs }) });
 }
 export function resultText(input, options = {}) {
     if (input.output)

package/external/pi-tools-suite/src/codex-reasoning-fix/index.ts

@@ -8,14 +8,24 @@
  * uncommitted in pi-mono and never shipped, so every released pi-ai version
  * (incl. 0.79.10) is affected.
  *
- * The fix must run at the WebSocket.send layer, not at before_provider_request:
- * pi's openai-codex-responses provider uses a websocket-cached transport that
- * rebuilds the body into a delta AFTER the before_provider_request hook, so the
- * hook never sees the bytes actually sent. This module wraps
- * WebSocket.prototype.send once and strips `content` from every non-message
- * input item of each `response.create` frame, on the exact bytes leaving the
- * socket. The before_provider_request hook is kept as a secondary guard for the
- * SSE-fallback transport (full body, no delta).
+ * The fix must run at the transport layer because the provider has TWO paths:
+ *
+ *  1. WebSocket-cached path (normal): `buildCachedWebSocketRequestBody` rebuilds
+ *     the body into a DELTA after `before_provider_request`, so the hook never
+ *     sees the bytes actually sent. We wrap `WebSocket.prototype.send` once and
+ *     strip `content` from every non-message input item of each
+ *     `response.create` frame, on the exact bytes leaving the socket.
+ *
+ *  2. SSE/fetch fallback path: once a websocket attempt fails (common at large
+ *     context — full body, ~100+ input items), the transport records an SSE
+ *     fallback for the session and every subsequent request goes through a plain
+ *     `fetch()` POST with the FULL body (`bodyJson`). The `before_provider_request`
+ *     hook should clean this, but in practice it does not reliably catch every
+ *     offending item, so we also wrap `globalThis.fetch` once and strip the same
+ *     spurious `content` from the request body on the exact bytes leaving the
+ *     HTTP client.
+ *
+ * The `before_provider_request` hook is kept as a third secondary guard.
  *
  * Remove this whole module once an upstream pi-ai release carries the fix.
  */
@@ -31,9 +41,54 @@ type ProviderRequestContext = {
 };
 
 installWireStripper();
+installFetchStripper();
+
+/**
+ * Strip spurious `content` from any object that carries an `input` or
+ * `messages` array. Shared core for the wire-frame, fetch, and hook paths.
+ * Returns the cleaned object plus a tally only when something changed;
+ * otherwise `undefined` (caller forwards the original untouched).
+ */
+export function stripCarrier(obj: unknown): { obj: Record<string, unknown>; stripped: number } | undefined {
+	if (!isRecord(obj)) return undefined;
+	const field = Array.isArray(obj.input) ? "input" : Array.isArray(obj.messages) ? "messages" : null;
+	if (!field) return undefined;
+
+	const list = obj[field] as unknown[];
+	let stripped = 0;
+	let changed = false;
+	const next = new Array(list.length);
+	for (let i = 0; i < list.length; i++) {
+		const item = list[i];
+		if (isSpuriousContentItem(item)) {
+			const { content: _drop, ...rest } = item as Record<string, unknown>;
+			next[i] = rest;
+			stripped++;
+			changed = true;
+		} else {
+			next[i] = item;
+		}
+	}
+	if (!changed) return undefined;
+	return { obj: { ...obj, [field]: next }, stripped };
+}
 
 /**
- * Wrap WebSocket.prototype.send once. For each `response.create` frame, strip
+ * True only for items that carry a spurious `content`: an explicit `type` that
+ * is NOT "message". Role-based messages (no `type`) and typed messages
+ * (`type:"message"`) legitimately hold content — they are left untouched.
+ */
+function isSpuriousContentItem(item: unknown): boolean {
+	return (
+		isRecord(item) &&
+		typeof item.type === "string" &&
+		item.type !== "message" &&
+		Object.prototype.hasOwnProperty.call(item, "content")
+	);
+}
+
+/**
+ * Wrap `WebSocket.prototype.send` once. For each `response.create` frame, strip
  * the offending `content` from non-message input items and forward the cleaned
  * frame. Forwards the original untouched on any parse/rewrite failure so the
  * transport never breaks.
@@ -52,9 +107,11 @@ function installWireStripper(): void {
 			if (typeof data === "string") {
 				try {
 					const parsed = JSON.parse(data);
-					const result = stripContentFromWireFrame(parsed);
-					if (result) {
-						outgoing = JSON.stringify(result.frame);
+					if (isRecord(parsed) && parsed.type === "response.create") {
+						const result = stripCarrier(parsed);
+						if (result) {
+							outgoing = JSON.stringify(result.obj);
+						}
 					}
 				} catch {
 					// Non-JSON or malformed: forward untouched.
@@ -69,43 +126,59 @@ function installWireStripper(): void {
 	}
 }
 
+/**
+ * Wrap `globalThis.fetch` once. For JSON POST bodies carrying an `input` or
+ * `messages` array (Codex / OpenAI Responses shape), strip the spurious
+ * `content` from non-message items before the request leaves the HTTP client.
+ * This closes the SSE-fallback path that the WebSocket wrapper cannot see.
+ * Forwards the original request untouched on any non-matching/parse failure.
+ */
+function installFetchStripper(): void {
+	try {
+		const g = globalThis as { fetch?: typeof fetch };
+		const original = g.fetch;
+		if (typeof original !== "function") return;
+		if ((original as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped) return;
+
+		const wrapped = function fetchStripper(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+			const nextInit = stripFetchInit(init);
+			return original.call(this, input, nextInit ?? init);
+		};
+		(wrapped as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped = true;
+		g.fetch = wrapped as typeof fetch;
+	} catch {
+		// best-effort; never break on setup
+	}
+}
+
+/**
+ * If `init` carries a JSON body shaped like a Responses request, return a new
+ * `init` with the stripped body. Returns `undefined` when nothing matched so
+ * the caller forwards the original `init` untouched.
+ */
+export function stripFetchInit(init: RequestInit | undefined): RequestInit | undefined {
+	if (!init || typeof init.body !== "string") return undefined;
+	try {
+		const parsed = JSON.parse(init.body);
+		const result = stripCarrier(parsed);
+		if (!result) return undefined;
+		return { ...init, body: JSON.stringify(result.obj) };
+	} catch {
+		return undefined;
+	}
+}
+
 /**
  * If `frame` is a Codex `response.create` carrying an `input` (or `messages`)
- * array, return the cleaned frame (content stripped from every non-message
- * item) plus a tally of how many items were stripped. Returns `undefined`
- * when nothing matched (caller forwards the original frame untouched). The
- * returned `frame` is a clean Codex payload with no extra fields.
+ * array, return the cleaned frame plus a tally of stripped items. Returns
+ * `undefined` when nothing matched (caller forwards the original frame
+ * untouched). Exported for unit testing.
  */
 export function stripContentFromWireFrame(frame: unknown): { frame: Record<string, unknown>; stripped: number } | undefined {
 	if (!isRecord(frame) || frame.type !== "response.create") return undefined;
-	const field = Array.isArray(frame.input) ? "input" : Array.isArray(frame.messages) ? "messages" : null;
-	if (!field) return undefined;
-
-	const list = frame[field] as unknown[];
-	let stripped = 0;
-	let changed = false;
-	const next = new Array(list.length);
-	for (let i = 0; i < list.length; i++) {
-		const item = list[i];
-		// Only items with an explicit `type` that is NOT "message" can carry a
-		// spurious `content`. Role-based messages (no `type`) and typed
-		// messages (`type:"message"`) legitimately hold content — leave them.
-		if (
-			isRecord(item) &&
-			typeof item.type === "string" &&
-			item.type !== "message" &&
-			Object.prototype.hasOwnProperty.call(item, "content")
-		) {
-			const { content: _drop, ...rest } = item;
-			next[i] = rest;
-			stripped++;
-			changed = true;
-		} else {
-			next[i] = item;
-		}
-	}
-	if (!changed) return undefined;
-	return { frame: { ...frame, [field]: next }, stripped };
+	const result = stripCarrier(frame);
+	if (!result) return undefined;
+	return { frame: result.obj, stripped: result.stripped };
 }
 
 export default function codexReasoningFix(pi: ExtensionAPI): void {
@@ -117,36 +190,12 @@ export default function codexReasoningFix(pi: ExtensionAPI): void {
 
 /**
  * Strip spurious `content` from non-message items in a full payload. Secondary
- * guard for the SSE-fallback / non-websocket path. Same rule as the wire
- * stripper; exported for unit testing.
+ * guard for the SSE-fallback / non-websocket path. Returns the same reference
+ * when nothing changed; exported for unit testing.
  */
 export function stripReasoningContentFromPayload(payload: unknown): unknown {
-	if (!isRecord(payload)) return payload;
-	const inputList = Array.isArray(payload.input) ? payload.input : undefined;
-	const messagesList = Array.isArray(payload.messages) ? payload.messages : undefined;
-	const field = inputList ? "input" : messagesList ? "messages" : undefined;
-	const list = inputList ?? messagesList;
-	if (!field || !list) return payload;
-
-	let changed = false;
-	const next = new Array(list.length);
-	for (let i = 0; i < list.length; i++) {
-		const item = list[i];
-		if (
-			isRecord(item) &&
-			typeof item.type === "string" &&
-			item.type !== "message" &&
-			Object.prototype.hasOwnProperty.call(item, "content")
-		) {
-			const { content: _drop, ...rest } = item;
-			next[i] = rest;
-			changed = true;
-		} else {
-			next[i] = item;
-		}
-	}
-	if (!changed) return payload;
-	return { ...payload, [field]: next };
+	const result = stripCarrier(payload);
+	return result ? result.obj : payload;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/external/pi-tools-suite/src/dcp/index.ts

@@ -532,6 +532,23 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}, ctx)
 			}
 
+			const hasCompressionSuggestion =
+				candidate !== null || messageCandidates.length > 0
+			if (!manualEmergencyOnly && !hasCompressionSuggestion) {
+				const clearedAnchors = clearDcpNudgeAnchors(state)
+				state.consecutiveIgnoredStrongNudges = 0
+				if (clearedAnchors > 0) await saveDcpState(ctx, state)
+				if (nudgeType || clearedAnchors > 0) {
+					writeDcpDebugLog(effectiveConfig, "context.no_compression_candidate", {
+						contextPercent,
+						thresholds,
+						nudgeType,
+						clearedAnchors,
+						state: summarizeDcpState(state),
+					}, ctx)
+				}
+			}
+
 			// Track consecutive ignored context-strong nudges for the
 			// auto-compress fallback. A strong nudge is "ignored" if it fires
 			// again on a later context event without a successful compress in
@@ -539,9 +556,12 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			// the emergency threshold (handled by the below-threshold early
 			// return above, which clears anchors; counter is also reset on any
 			// successful compress in the compress tool).
-			if (nudgeType === "context-strong" || nudgeType === "context-soft") {
+			if (
+				hasCompressionSuggestion &&
+				(nudgeType === "context-strong" || nudgeType === "context-soft")
+			) {
 				state.consecutiveIgnoredStrongNudges += 1
-			} else if (nudgeType === null) {
+			} else if (nudgeType === null || !hasCompressionSuggestion) {
 				state.consecutiveIgnoredStrongNudges = 0
 			}
 
@@ -604,7 +624,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}
 			}
 
-			if (nudgeType && !manualEmergencyOnly) {
+			if (nudgeType && !manualEmergencyOnly && hasCompressionSuggestion) {
 				const nudgeText = appendConcreteNudgeGuidance(
 					baseNudgeText(nudgeType),
 					candidate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "private": false,
   "type": "module",
   "bin": {