pi-ui-extend 0.1.36 → 0.1.38

package/dist/bundled-extensions/terminal-bell/index.js

@@ -9,6 +9,12 @@ const IDLE_RETRY_DELAY_MS = 100;
 const MAX_IDLE_RETRIES = 40;
 const SUBAGENTS_LIVE_COUNT_EVENT = "pi-tools-suite:async-subagents:live-count";
 const TERMINAL_BELL_ATTENTION_EVENT = "pix:terminal-bell:attention";
+/**
+ * Renderer-relayed signal that the session is in an auto-retry cycle.
+ * Payload: `{ active: boolean }`. The SDK does not forward retry state to
+ * extensions, so the renderer emits this on the extension event bus.
+ */
+const RETRY_ACTIVE_EVENT = "pix:retry-active";
 const DEFAULT_COMPLETION_NOTIFICATION_TITLE = "Pix - completion";
 const DEFAULT_ERROR_NOTIFICATION_TITLE = "Pix - error";
 const DEFAULT_QUESTION_NOTIFICATION_TITLE = "Pix - question";
@@ -154,9 +160,22 @@ function trimmed(value) {
     const normalized = value?.trim();
     return normalized ? normalized : undefined;
 }
+function isStaleExtensionContextError(error) {
+    return error instanceof Error && /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message);
+}
+function safeSessionName(ctx, pi) {
+    try {
+        return trimmed(pi?.getSessionName?.() ?? ctx.sessionManager.getSessionName?.());
+    }
+    catch (error) {
+        if (isStaleExtensionContextError(error))
+            return undefined;
+        throw error;
+    }
+}
 function buildNotificationTemplateValues(ctx, pi) {
     const sessionId = ctx.sessionManager.getSessionId();
-    const sessionName = trimmed(pi?.getSessionName?.() ?? ctx.sessionManager.getSessionName?.());
+    const sessionName = safeSessionName(ctx, pi);
     const sessionFile = ctx.sessionManager.getSessionFile() ?? "";
     return {
         sessionId,
@@ -167,6 +186,19 @@ function buildNotificationTemplateValues(ctx, pi) {
         cwd: ctx.cwd,
     };
 }
+function buildNotificationContextSnapshot(ctx, pi) {
+    try {
+        return {
+            hasUI: ctx.hasUI === true,
+            templateValues: buildNotificationTemplateValues(ctx, pi),
+        };
+    }
+    catch (error) {
+        if (isStaleExtensionContextError(error))
+            return undefined;
+        throw error;
+    }
+}
 function renderNotificationTemplate(template, values, appendReasonIfUnused = false) {
     let usedReason = false;
     const rendered = template.replace(/\{(sessionId|sessionName|sessionTitle|sessionFile|sessionFileBase|cwd|reason)\}/g, (_match, key) => {
@@ -242,8 +274,8 @@ function detectMacActivationBundleId() {
         return undefined;
     return TERM_PROGRAM_BUNDLE_IDS[termProgram];
 }
-function playAttentionSound(ctx) {
-    if (!terminalBellSoundEnabled(ctx))
+function playAttentionSoundFor(context) {
+    if (!terminalBellSoundEnabled(context))
         return;
     if (process.platform !== "darwin")
         return;
@@ -286,13 +318,13 @@ function sendTelegramNotification(title, message) {
         // fetch may be unavailable or throw synchronously; ignore.
     }
 }
-function notifySessionStopped(ctx, pi, macActivationBundleId, options) {
-    const templateValues = buildNotificationTemplateValues(ctx, pi);
+function notifySessionStopped(context, macActivationBundleId, options) {
+    const templateValues = context.templateValues;
     const title = renderNotificationTemplate(notificationTitleTemplate(options.title), templateValues);
     const renderedMessage = renderNotificationTemplate(options.message ?? process.env.PI_TERMINAL_BELL_NOTIFY_MESSAGE ?? DEFAULT_NOTIFICATION_MESSAGE, templateValues);
     // Telegram is independent of the bundled desktop sound/notification gate.
     sendTelegramNotification(title, renderedMessage);
-    if (!terminalBellNotificationsEnabled(ctx))
+    if (!terminalBellNotificationsEnabled(context))
         return;
     if (process.platform === "darwin") {
         const terminalNotifier = findExecutable(process.env.PI_TERMINAL_BELL_NOTIFIER ?? "terminal-notifier");
@@ -351,10 +383,15 @@ export default function terminalBell(pi) {
     if (extensionDisabled())
         return;
     let timer;
-    let lastCtx;
+    let pendingBell;
     let deferredUntilSubagentsFinish = false;
     let liveSubagentCount = 0;
     let lastFailureReason;
+    // True while the session is in an auto-retry cycle (relayed via the
+    // extension event bus). Suppresses the failure bell on intermediate retry
+    // attempts; the final exhausted failure still rings because no retry-start
+    // signal precedes it.
+    let retryActive = false;
     const activeSubagentWaitToolCallIds = new Set();
     const notifiedAskUserToolCallIds = new Set();
     const idleDelayMs = parseDelayMs(process.env.PI_TERMINAL_BELL_DELAY_MS);
@@ -368,57 +405,91 @@ export default function terminalBell(pi) {
     function hasSubagentWork() {
         return liveSubagentCount > 0 || activeSubagentWaitToolCallIds.size > 0;
     }
-    function notifyAttention(ctx, message) {
-        if (canRingTerminal(ctx))
+    function notifyAttention(notification, message) {
+        if (canRingTerminal(notification))
             writeBell();
-        playAttentionSound(ctx);
-        notifySessionStopped(ctx, pi, macActivationBundleId, {
+        playAttentionSoundFor(notification);
+        notifySessionStopped(notification, macActivationBundleId, {
             title: message ? DEFAULT_ERROR_NOTIFICATION_TITLE : DEFAULT_COMPLETION_NOTIFICATION_TITLE,
             ...(message ? { message } : {}),
         });
         pi.events.emit(TERMINAL_BELL_ATTENTION_EVENT, {
-            cwd: ctx.cwd,
-            sessionFile: ctx.sessionManager.getSessionFile(),
-            sessionId: ctx.sessionManager.getSessionId(),
+            cwd: notification.templateValues.cwd,
+            sessionFile: notification.templateValues.sessionFile,
+            sessionId: notification.templateValues.sessionId,
         });
     }
-    function attemptBell(ctx, attempt, message) {
+    function attemptBell(pending, attempt) {
         timer = undefined;
-        if (!ctx.isIdle()) {
-            if (attempt < MAX_IDLE_RETRIES)
-                scheduleBell(ctx, IDLE_RETRY_DELAY_MS, attempt + 1, message);
+        const { ctx, notification, message } = pending;
+        // Safety net: if a retry-start signal arrives between the agent_end that
+        // queued this bell and the timer firing, suppress the bell entirely.
+        if (retryActive)
             return;
+        try {
+            if (!ctx.isIdle()) {
+                if (attempt < MAX_IDLE_RETRIES)
+                    scheduleBell(ctx, IDLE_RETRY_DELAY_MS, attempt + 1, message, notification);
+                return;
+            }
+            if (ctx.hasPendingMessages())
+                return;
+        }
+        catch (error) {
+            if (isStaleExtensionContextError(error)) {
+                pendingBell = undefined;
+                deferredUntilSubagentsFinish = false;
+                return;
+            }
+            throw error;
         }
-        if (ctx.hasPendingMessages())
-            return;
         if (hasSubagentWork()) {
             deferredUntilSubagentsFinish = true;
             return;
         }
         deferredUntilSubagentsFinish = false;
-        notifyAttention(ctx, message);
+        notifyAttention(notification, message);
     }
-    function scheduleBell(ctx, delayMs = idleDelayMs, attempt = 0, message) {
-        lastCtx = ctx;
+    function scheduleBell(ctx, delayMs = idleDelayMs, attempt = 0, message, notification = buildNotificationContextSnapshot(ctx, pi)) {
+        if (!notification)
+            return;
+        pendingBell = { ctx, notification, ...(message ? { message } : {}) };
         clearTimer();
-        timer = setTimeout(() => attemptBell(ctx, attempt, message), delayMs);
+        timer = setTimeout(() => {
+            if (!pendingBell)
+                return;
+            try {
+                attemptBell(pendingBell, attempt);
+            }
+            catch (error) {
+                if (isStaleExtensionContextError(error)) {
+                    pendingBell = undefined;
+                    deferredUntilSubagentsFinish = false;
+                    return;
+                }
+                throw error;
+            }
+        }, delayMs);
         timer.unref?.();
     }
     function notifyAskUserWaiting(toolCallId, ctx) {
         if (notifiedAskUserToolCallIds.has(toolCallId))
             return;
         notifiedAskUserToolCallIds.add(toolCallId);
-        if (canRingTerminal(ctx))
+        const notification = buildNotificationContextSnapshot(ctx, pi);
+        if (!notification)
+            return;
+        if (canRingTerminal(notification))
             writeBell();
-        playAttentionSound(ctx);
-        notifySessionStopped(ctx, pi, macActivationBundleId, {
+        playAttentionSoundFor(notification);
+        notifySessionStopped(notification, macActivationBundleId, {
             title: DEFAULT_QUESTION_NOTIFICATION_TITLE,
             message: process.env.PI_TERMINAL_BELL_ASK_USER_NOTIFY_MESSAGE ?? DEFAULT_ASK_USER_NOTIFICATION_MESSAGE,
         });
         pi.events.emit(TERMINAL_BELL_ATTENTION_EVENT, {
-            cwd: ctx.cwd,
-            sessionFile: ctx.sessionManager.getSessionFile(),
-            sessionId: ctx.sessionManager.getSessionId(),
+            cwd: notification.templateValues.cwd,
+            sessionFile: notification.templateValues.sessionFile,
+            sessionId: notification.templateValues.sessionId,
         });
     }
     pi.events.on(SUBAGENTS_LIVE_COUNT_EVENT, (data) => {
@@ -427,14 +498,27 @@ export default function terminalBell(pi) {
         if (count === undefined)
             return;
         liveSubagentCount = count;
-        if (count === 0 && deferredUntilSubagentsFinish && lastCtx) {
-            scheduleBell(lastCtx);
+        if (count === 0 && deferredUntilSubagentsFinish && pendingBell) {
+            scheduleBell(pendingBell.ctx, idleDelayMs, 0, pendingBell.message, pendingBell.notification);
+        }
+    });
+    pi.events.on(RETRY_ACTIVE_EVENT, (data) => {
+        retryActive = data != null && typeof data === "object" && data.active === true;
+        if (retryActive) {
+            // A retry is starting right after an intermediate agent_end: cancel
+            // any bell queued from that attempt so we don't chime on every
+            // failed retry attempt. The final exhausted failure rings normally
+            // because it is not followed by a retry-start signal.
+            clearTimer();
+            pendingBell = undefined;
+            deferredUntilSubagentsFinish = false;
         }
     });
     pi.on("agent_start", async () => {
         clearTimer();
         deferredUntilSubagentsFinish = false;
         lastFailureReason = undefined;
+        retryActive = false;
         activeSubagentWaitToolCallIds.clear();
         notifiedAskUserToolCallIds.clear();
     });
@@ -481,10 +565,11 @@ export default function terminalBell(pi) {
     });
     pi.on("session_shutdown", async () => {
         clearTimer();
-        lastCtx = undefined;
+        pendingBell = undefined;
         deferredUntilSubagentsFinish = false;
         liveSubagentCount = 0;
         lastFailureReason = undefined;
+        retryActive = false;
         activeSubagentWaitToolCallIds.clear();
         notifiedAskUserToolCallIds.clear();
     });

package/dist/markdown-format.d.ts

@@ -29,4 +29,5 @@ export declare function formatMarkdownTables(text: string, maxWidth?: number): s
 export declare function renderMarkdownLine(text: string, start?: number): RenderedMarkdownLine;
 export declare function renderMarkdownTextLines(text: string, width: number, start?: number, options?: RenderMarkdownTextLinesOptions): RenderedMarkdownTextLine[];
 export declare function markdownSyntaxHighlightsForText(text: string, startColumn?: number): ToolBodySyntaxHighlights;
+export declare function stripDcpControlMetadata(text: string): string;
 export declare function isOnlyHiddenMetadata(text: string): boolean;

package/dist/markdown-format.js

@@ -620,15 +620,40 @@ function markdownLineSyntaxHighlight(fence, fenceDelimiterLine, start) {
     return { language: "markdown", start };
 }
 function sanitizeMarkdownText(text) {
-    return expandTabs(text.replace(/\x1b/g, "␛").replace(/\r/g, ""));
+    return expandTabs(stripDcpControlMetadata(text).replace(/\x1b/g, "␛").replace(/\r/g, ""));
+}
+export function stripDcpControlMetadata(text) {
+    if (!text.includes("<dcp-message-ids>"))
+        return text;
+    const lines = text.split("\n");
+    const kept = [];
+    let inMessageIds = false;
+    let touched = false;
+    for (const line of lines) {
+        if (inMessageIds) {
+            touched = true;
+            if (/<\/dcp-message-ids>\s*$/i.test(line))
+                inMessageIds = false;
+            continue;
+        }
+        if (/^\s*<dcp-message-ids>/i.test(line)) {
+            touched = true;
+            if (!/<\/dcp-message-ids>\s*$/i.test(line))
+                inMessageIds = true;
+            continue;
+        }
+        kept.push(line);
+    }
+    return touched ? kept.join("\n").trimEnd() : text;
 }
 function isHiddenMarkdownMetadataLine(line) {
-    return isMarkdownReferenceDefinition(line) || isStreamingDcpMetadataPrefix(line);
+    return isMarkdownReferenceDefinition(line);
 }
 export function isOnlyHiddenMetadata(text) {
-    if (!text)
-        return false;
-    for (const line of text.split("\n")) {
+    const stripped = stripDcpControlMetadata(text);
+    if (!stripped)
+        return text.length > 0;
+    for (const line of stripped.split("\n")) {
         if (line.length === 0)
             continue;
         if (!isHiddenMarkdownMetadataLine(line))
@@ -639,17 +664,6 @@ export function isOnlyHiddenMetadata(text) {
 function isMarkdownReferenceDefinition(line) {
     return /^ {0,3}\[[^\]\n]+\]:[ \t]*\S.*$/u.test(line);
 }
-function isStreamingDcpMetadataPrefix(line) {
-    const content = line.replace(/^ {0,3}/u, "");
-    if (content.length === 0)
-        return false;
-    return isDcpReferencePrefix(content, DCP_MESSAGE_REFERENCE_PREFIX) || isDcpReferencePrefix(content, DCP_BLOCK_REFERENCE_PREFIX);
-}
-function isDcpReferencePrefix(content, markerPrefix) {
-    return markerPrefix.startsWith(content) || (content.startsWith(markerPrefix) && /^\d*$/u.test(content.slice(markerPrefix.length)));
-}
-const DCP_MESSAGE_REFERENCE_PREFIX = "[dcp-id]: # (m";
-const DCP_BLOCK_REFERENCE_PREFIX = "[dcp-block-id]: # (b";
 function markdownFence(line) {
     const match = /^\s{0,3}(`{3,}|~{3,})(.*)$/.exec(line);
     const marker = match?.[1];

package/dist/schemas/pi-tools-suite-schema.d.ts

@@ -21,6 +21,10 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
     dcp: Type.TOptional<Type.TObject<{
         enabled: Type.TOptional<Type.TBoolean>;
         debug: Type.TOptional<Type.TBoolean>;
+        debugLog: Type.TOptional<Type.TObject<{
+            maxBytes: Type.TOptional<Type.TNumber>;
+            maxBackups: Type.TOptional<Type.TNumber>;
+        }>>;
         manualMode: Type.TOptional<Type.TObject<{
             enabled: Type.TOptional<Type.TBoolean>;
             automaticStrategies: Type.TOptional<Type.TBoolean>;
@@ -84,6 +88,7 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
         routing: Type.TOptional<Type.TObject<{
             enabled: Type.TOptional<Type.TBoolean>;
             model: Type.TOptional<Type.TString>;
+            fallbackModels: Type.TOptional<Type.TArray<Type.TString>>;
             maxTaskChars: Type.TOptional<Type.TNumber>;
             maxTokens: Type.TOptional<Type.TNumber>;
             maxRetries: Type.TOptional<Type.TNumber>;

package/dist/schemas/pi-tools-suite-schema.js

@@ -100,6 +100,10 @@ const DcpStrategiesConfig = Type.Object({
 const DcpConfig = Type.Object({
     enabled: Type.Optional(Type.Boolean({ description: "Enable DCP (Dynamic Context Pruning)." })),
     debug: Type.Optional(Type.Boolean({ description: "Enable DCP debug logging." })),
+    debugLog: Type.Optional(Type.Object({
+        maxBytes: Type.Optional(Type.Number({ description: "Maximum size in bytes of the active debug log before it is rotated. Default 5242880 (5 MB).", minimum: 1024 })),
+        maxBackups: Type.Optional(Type.Number({ description: "Number of rotated backups to keep (.1 .. .N). Default 3, minimum 1.", minimum: 1 })),
+    }, { description: "Debug log rotation. The JSONL log is written to ~/.pi/agent/dcp-debug.jsonl." })),
     manualMode: Type.Optional(DcpManualModeConfig),
     compress: Type.Optional(DcpCompressConfig),
     strategies: Type.Optional(DcpStrategiesConfig),
@@ -117,6 +121,7 @@ const RetryConfig = Type.Object({
 const SubagentRoutingConfig = Type.Object({
     enabled: Type.Optional(Type.Boolean({ description: "Enable LLM-based automatic role routing." })),
     model: Type.Optional(Type.String({ description: "Router model in provider/model form." })),
+    fallbackModels: Type.Optional(Type.Array(Type.String(), { uniqueItems: true, description: "Ordered router model fallbacks tried when the primary routing model is unavailable or fails. The current parent model is always tried last." })),
     maxTaskChars: Type.Optional(Type.Number({ description: "Max task/scope characters sent to router.", minimum: 100 })),
     maxTokens: Type.Optional(Type.Number({ description: "Max router response tokens.", minimum: 8 })),
     maxRetries: Type.Optional(Type.Number({ description: "Router request retries.", minimum: 0 })),

package/dist/tool-renderers/apply-patch.js

@@ -1,9 +1,14 @@
 import { isAbsolute, relative, sep } from "node:path";
+import { normalizeBeginPatchForDisplay } from "./patch-normalize.js";
 import { expandedTextFromParts, resultText, stringArg, summarizePatch } from "./utils.js";
 export const renderApplyPatchTool = (input) => {
     const detailsDiff = diffFromDetails(input.details);
     const argPatch = stringArg(input, ["input", "patch"]);
-    const patch = argPatch ?? detailsDiff?.text;
+    const rawPatch = argPatch ?? detailsDiff?.text;
+    // Re-minimize loose `*** Begin Patch` hunks so unchanged neighbor lines are
+    // rendered as context instead of spurious `-` deletions. Plain unified diffs
+    // and other formats pass through unchanged.
+    const patch = rawPatch ? normalizeBeginPatchForDisplay(rawPatch) : rawPatch;
     const path = pathForDisplay(stringArg(input, ["path", "file_path", "filePath"]), input.cwd);
     const summary = summarizePatch(patch) ?? "patch";
     const expanded = expandedTextFromParts({ text: patch }, { text: resultText(input, { empty: !patch }) });

package/dist/tool-renderers/patch-normalize.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Normalize OpenAI-style `*** Begin Patch` hunks for display.
+ *
+ * Problem: in the `Begin Patch` format the model often emits a hunk that
+ * reproduces a whole block of a file with the old version as `-` lines and the
+ * new version as `+` lines, even when most of those lines are identical. This is
+ * the "contextless / loose hunk matching" behavior. A patch that effectively
+ * only adds one line can therefore look like it deletes several existing rules.
+ *
+ * The naive per-line renderer (`diffLineStyle`) faithfully colors every `-` red
+ * and every `+` green, which misleads the user.
+ *
+ * Fix: for each `*** Update File:` hunk we reconstruct the old side
+ * (context + `-` lines) and the new side (context + `+` lines), compute a
+ * minimal LCS line diff between them, and re-emit the hunk so that:
+ *   - lines present in both sides become plain context (no `-`),
+ *   - truly removed lines stay `-`,
+ *   - truly added lines stay `+`.
+ *
+ * This is a display-only transformation. Well-formed minimal hunks (and any
+ * non-`Begin Patch` unified diffs) are left untouched.
+ */
+/** Re-emit a `*** Begin Patch` string with loose hunks re-minimized. */
+export declare function normalizeBeginPatchForDisplay(patch: string): string;

package/dist/tool-renderers/patch-normalize.js

@@ -0,0 +1,163 @@
+/**
+ * Normalize OpenAI-style `*** Begin Patch` hunks for display.
+ *
+ * Problem: in the `Begin Patch` format the model often emits a hunk that
+ * reproduces a whole block of a file with the old version as `-` lines and the
+ * new version as `+` lines, even when most of those lines are identical. This is
+ * the "contextless / loose hunk matching" behavior. A patch that effectively
+ * only adds one line can therefore look like it deletes several existing rules.
+ *
+ * The naive per-line renderer (`diffLineStyle`) faithfully colors every `-` red
+ * and every `+` green, which misleads the user.
+ *
+ * Fix: for each `*** Update File:` hunk we reconstruct the old side
+ * (context + `-` lines) and the new side (context + `+` lines), compute a
+ * minimal LCS line diff between them, and re-emit the hunk so that:
+ *   - lines present in both sides become plain context (no `-`),
+ *   - truly removed lines stay `-`,
+ *   - truly added lines stay `+`.
+ *
+ * This is a display-only transformation. Well-formed minimal hunks (and any
+ * non-`Begin Patch` unified diffs) are left untouched.
+ */
+const MAX_NORMALIZE_LINES = 4000;
+/** Re-emit a `*** Begin Patch` string with loose hunks re-minimized. */
+export function normalizeBeginPatchForDisplay(patch) {
+    if (!patch.includes("*** Begin Patch"))
+        return patch;
+    const lines = patch.split("\n");
+    if (lines.length > MAX_NORMALIZE_LINES)
+        return patch;
+    const sections = parseBeginPatchSections(lines);
+    return sections.map(renderSection).filter((line) => line !== null).join("\n");
+}
+function parseBeginPatchSections(lines) {
+    const sections = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (line.startsWith("*** Update File:")) {
+            sections.push({ kind: "marker", line });
+            i += 1;
+            while (i < lines.length) {
+                const inner = lines[i] ?? "";
+                if (inner.startsWith("*** "))
+                    break;
+                if (inner.startsWith("@@")) {
+                    sections.push({ kind: "hunk-header", line: inner });
+                    i += 1;
+                    const body = [];
+                    while (i < lines.length) {
+                        const bodyLine = lines[i] ?? "";
+                        if (bodyLine.startsWith("@@") || bodyLine.startsWith("*** "))
+                            break;
+                        body.push(parseHunkLine(bodyLine));
+                        i += 1;
+                    }
+                    sections.push({ kind: "hunk-body", lines: body });
+                }
+                else {
+                    sections.push({ kind: "raw", line: inner });
+                    i += 1;
+                }
+            }
+            continue;
+        }
+        if (line.startsWith("*** Add File:") || line.startsWith("*** Delete File:") || line.startsWith("*** Begin Patch") || line.startsWith("*** End Patch")) {
+            sections.push({ kind: "marker", line });
+            i += 1;
+            continue;
+        }
+        // Stray line outside any file section (e.g. a loose @@ without an Update
+        // File header). Keep it verbatim to preserve structure.
+        sections.push({ kind: "raw", line });
+        i += 1;
+    }
+    return sections;
+}
+function parseHunkLine(line) {
+    if (line.startsWith("+"))
+        return { type: "add", text: line.slice(1) };
+    if (line.startsWith("-"))
+        return { type: "del", text: line.slice(1) };
+    if (line.startsWith(" "))
+        return { type: "context", text: line.slice(1) };
+    // Lines without a prefix inside a Begin Patch hunk body are treated as
+    // context (the format uses a leading space for context, but loose patches
+    // sometimes omit it).
+    return { type: "context", text: line };
+}
+function renderSection(section) {
+    switch (section.kind) {
+        case "marker":
+        case "hunk-header":
+        case "raw":
+            return section.line;
+        case "hunk-body": {
+            const oldLines = section.lines.filter((entry) => entry.type !== "add").map((entry) => entry.text);
+            const newLines = section.lines.filter((entry) => entry.type !== "del").map((entry) => entry.text);
+            const ops = diffLines(oldLines, newLines);
+            const rendered = [];
+            for (const op of ops) {
+                rendered.push(renderDiffOp(op));
+            }
+            return rendered.length > 0 ? rendered.join("\n") : null;
+        }
+    }
+}
+function renderDiffOp(op) {
+    if (op.type === "delete")
+        return `-${op.text}`;
+    if (op.type === "insert")
+        return `+${op.text}`;
+    // Context marker is a leading space. Loose `-`/`+` blocks carry the space
+    // that separated the marker from the content (e.g. `- rule one`), so reuse
+    // that space instead of emitting a second one.
+    return op.text.startsWith(" ") ? op.text : ` ${op.text}`;
+}
+/** Minimal LCS-based line diff. */
+function diffLines(oldLines, newLines) {
+    const m = oldLines.length;
+    const n = newLines.length;
+    if (m === 0 && n === 0)
+        return [];
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i -= 1) {
+        for (let j = n - 1; j >= 0; j -= 1) {
+            const oldLine = oldLines[i] ?? "";
+            const newLine = newLines[j] ?? "";
+            dp[i][j] = oldLine === newLine
+                ? (dp[i + 1]?.[j + 1] ?? 0) + 1
+                : Math.max(dp[i + 1]?.[j] ?? 0, dp[i]?.[j + 1] ?? 0);
+        }
+    }
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        const oldLine = oldLines[i] ?? "";
+        const newLine = newLines[j] ?? "";
+        if (oldLine === newLine) {
+            result.push({ type: "equal", text: oldLine });
+            i += 1;
+            j += 1;
+        }
+        else if ((dp[i + 1]?.[j] ?? 0) >= (dp[i]?.[j + 1] ?? 0)) {
+            result.push({ type: "delete", text: oldLine });
+            i += 1;
+        }
+        else {
+            result.push({ type: "insert", text: newLine });
+            j += 1;
+        }
+    }
+    while (i < m) {
+        result.push({ type: "delete", text: oldLines[i] ?? "" });
+        i += 1;
+    }
+    while (j < n) {
+        result.push({ type: "insert", text: newLines[j] ?? "" });
+        j += 1;
+    }
+    return result;
+}

package/external/pi-tools-suite/README.md

@@ -8,6 +8,7 @@ This package keeps shared Pi tools as ordinary source folders under `src/` and r
 - `src/ast-grep` — `ast_grep` / `ast_apply`
 - `src/async-subagents` — `subagents` tool and sub-agent slash commands, including oh-my-openagent-style `/ultrawork` (`/ulw`) and `/hyperplan` orchestration prompts, plus config-defined sub-agent model/thinking/args presets selected via `/subagent-preset` from `asyncSubagents` in `~/.config/pi/pi-tools-suite.jsonc`; includes the `frontend` profile for Gemini-friendly UI/UX and visual frontend work plus the `vision` profile for screenshot/image description via `openai-codex/gpt-5.4-mini`; enforces a 30-minute per-agent execution timeout, project-wide `maxConcurrent` queueing, optional retry/backoff, and `result.json` structured metadata/chaining fields next to raw `result.md`; stores project-local run files and a registry under `.pi/subagents/` so result/status collection can recover after compaction or reload while the main session remains alive
 - `src/lsp` — shared LSP diagnostics hook/library that enriches mutating tool results with diagnostics and shuts down language servers on session shutdown
+- `src/comment-checker` — AI-slop comment guard that listens to the `tool_result` event for `write` / `edit` / `apply_patch` mutations, extracts net-new code comment lines, classifies them (filler phrasing, restating code, decorative separators, generic paraphrasing, or — under aggressive strictness — any non-valuable comment), and appends a short nudge to the tool result so the agent removes unnecessary comments on its next turn; TODO/FIXME, license headers, docstrings, pragmas, linter directives, shebangs, and decorators are never flagged; language-agnostic across `//` / `/* */` / `#` / `--` / `<!-- -->` / triple-quote comment styles; per-session deduplication (at most one nudge per 30 s) prevents fix/remark loops; configured via the `commentChecker` section (`enabled`, `strictness`: `conservative` | `balanced` | `aggressive`, default `balanced`) or `PI_COMMENT_CHECKER_ENABLED` / `PI_COMMENT_CHECKER_STRICTNESS`
 - `src/repo-discovery` — `/idx-init`, `/idx-update`, and indexed-only `repo_architecture` / `repo_structure` / `repo_ast` / `repo_search` / `repo_explain` / `repo_deps`; tools register only when the launch project has `.indexer-cli`
 - `src/antigravity-auth` — `antigravity` custom provider with Google Antigravity OAuth login, startup account list, auth.json-only runtime account loading, `/antigravity-add-account` OAuth append into rotation, `/antigravity-account` status display, account rotation/failover, Antigravity plus Gemini CLI model registration, and streaming through the Cloud Code Assist unified gateway
 - `src/todo` — `todo` tool, `/todos`, `/todos-persist`, and `/todos-scope`; supports parent/subtask hierarchy, blockers, ready-task filtering, deferred out-of-scope items, batch operations, JSON/Markdown import/export, automatic clearing when all visible todos are completed, and optional project persistence via `/todos persist on` or `/todos-persist on`; localization/i18n has been removed
@@ -19,7 +20,7 @@ This package keeps shared Pi tools as ordinary source folders under `src/` and r
 
 `index.ts` is intentionally only a thin auto-discovery shim that re-exports `src/index.ts`. There is no `pi.extensions` manifest here, so local Pi auto-discovery loads the suite once via `~/.pi/agent/extensions/pi-tools-suite/index.ts` and does not double-register tools.
 
-Registration order is preserved in `src/index.ts`: glm-coding-discipline, ast-grep, async-subagents, lsp, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, then prompt-commands. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
+Registration order is preserved in `src/index.ts`: glm-coding-discipline, ast-grep, async-subagents, lsp, comment-checker, repo-discovery command/tool gate, antigravity-auth provider, todo, model-tools, usage, web-search, dcp, then prompt-commands. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
 
 ## Disabling modules
 
@@ -123,7 +124,7 @@ DCP settings are stored only under `dcp` in the user shared config file `~/.conf
 }
 ```
 
-`minContextPercent` / `maxContextPercent` accept legacy fractions (`0.25`), percent strings (`"25%"`), or absolute token counts when Pi knows the current model context window. `minContextLimit` / `maxContextLimit` and `modelMinContextLimits` / `modelMaxContextLimits` are explicit absolute-or-percent aliases. `modelOverrides` and the `modelMin*` / `modelMax*` maps support exact model keys plus `*` / `?` wildcard patterns; matching is applied from generic to specific so exact bare-model matches override bare wildcards, and exact `provider/model` matches override provider wildcards. Array fields are union-merged, so model-specific `protectedTools` extend the defaults instead of replacing them. If `compress.protectUserMessages` is enabled, range compression appends selected user messages verbatim instead of rejecting the range; individual message compression still skips protected raw user messages. Protected tool outputs are copied into summaries for tools protected by name or `protectedFilePatterns`; protected `subagents` result reads also try to include the saved `result.md` artifact when available.
+`minContextPercent` / `maxContextPercent` accept legacy fractions (`0.25`), percent strings (`"25%"`), or absolute token counts when Pi knows the current model context window. `minContextLimit` / `maxContextLimit` and `modelMinContextLimits` / `modelMaxContextLimits` are explicit absolute-or-percent aliases. `modelOverrides` and the `modelMin*` / `modelMax*` maps support exact model keys plus `*` / `?` wildcard patterns; matching is applied from generic to specific so exact bare-model matches override bare wildcards, and exact `provider/model` matches override provider wildcards. Array fields are union-merged, so model-specific `protectedTools` extend the defaults instead of replacing them. If `compress.protectUserMessages` is enabled, range compression appends selected user messages verbatim instead of rejecting the range; individual message compression still skips protected raw user messages. Protected tool outputs are copied into summaries for tools protected by name or `protectedFilePatterns`; protected `subagents` result reads also try to include the saved `result.md` artifact when available. Set `dcp.debug: true` to write a JSONL debug log of DCP context/prune/compress events to `~/.pi/agent/dcp-debug.jsonl` (override the path with `PI_DCP_DEBUG_LOG`, or enable without config via `PI_DCP_DEBUG=1`); off by default. The log is size-limited and rotated: once it reaches `dcp.debugLog.maxBytes` (default `5242880` = 5 MB) it is renamed to `.1`, older backups shift down (`.1`→`.2`, …) and the oldest beyond `dcp.debugLog.maxBackups` (default `3`, minimum `1`) is dropped; override either with `PI_DCP_DEBUG_MAX_BYTES` / `PI_DCP_DEBUG_MAX_BACKUPS`.
 
 ## LSP setup
 

package/external/pi-tools-suite/package.json

@@ -38,9 +38,9 @@
     "vscode-languageserver-protocol": "^3.17.5"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "0.79.4",
-    "@earendil-works/pi-coding-agent": "0.79.4",
-    "@earendil-works/pi-tui": "0.79.4",
+    "@earendil-works/pi-ai": "0.79.6",
+    "@earendil-works/pi-coding-agent": "0.79.6",
+    "@earendil-works/pi-tui": "0.79.6",
     "typebox": "*"
   },
   "devDependencies": {