@herbertgao/pi-extensions 2026.8.4 → 2026.8.5

package/node_modules/pi-lens/dist/clients/runtime-agent-end.js

@@ -4,8 +4,11 @@ import { applyConservativeActionableWarningFixes, checkActionableWarningsReportF
 import { publishFilesTouched } from "./bus-publish.js";
 import { publishAutofixStart, publishFormatStart, } from "./format-events-publish.js";
 import { logLatency } from "./latency-logger.js";
+import { isPathIgnoredByProject } from "./file-utils.js";
+import { newLspMutationCorrelationId } from "./lsp-mutation.js";
 import { getGlobalActionableWarningMaxFixes, } from "./lens-config.js";
 import { resyncLspFile, runFormatPhase } from "./pipeline.js";
+import { getAmbientAbortSignal } from "./safe-spawn.js";
 import { appendProjectChange, } from "./project-changes.js";
 /**
  * A queued file is claimed by any flush once it has sat unclaimed by its own
@@ -16,6 +19,7 @@ import { appendProjectChange, } from "./project-changes.js";
  * extra staleness for guaranteed eventual formatting. (#791)
  */
 export const DEFERRED_FORMAT_STALE_AFTER_MS = 10 * 60_000;
+const DEFERRED_FORMAT_CONCURRENCY = 3;
 function recordProjectChange(args) {
     const bump = args.runtime.bumpFileSeq;
     if (!bump)
@@ -138,43 +142,63 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         return !disabled;
     });
     if (formatRecords.length > 0) {
-        // Run all formatter subprocesses concurrently — no shared state touched here.
-        // bumpFileSeq / cacheManager mutations happen in the sequential pass below.
-        const outcomes = await Promise.all(formatRecords.map(async (record) => {
-            const fileStart = Date.now();
-            const filePath = path.resolve(record.filePath);
-            if (!nodeFs.existsSync(filePath)) {
-                dbg(`agent_end deferred_format skipped missing file: ${filePath}`);
-                return { kind: "skipped", filePath, reason: "missing" };
-            }
-            try {
-                const result = await runFormatPhase(filePath, getFormatService, dbg);
-                return { kind: "done", record, filePath, result, fileStart };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                dbg(`agent_end deferred_format failed for ${filePath}: ${message}`);
-                return { kind: "failed", filePath, message, fileStart };
+        const work = new Array(formatRecords.length);
+        const started = new Set();
+        let nextIndex = 0;
+        const ambientSignal = getAmbientAbortSignal();
+        const worker = async () => {
+            while (nextIndex < formatRecords.length) {
+                const index = nextIndex++;
+                if (ambientSignal?.aborted)
+                    return;
+                const record = formatRecords[index];
+                const fileStart = Date.now();
+                const filePath = path.resolve(record.filePath);
+                started.add(index);
+                if (!nodeFs.existsSync(filePath)) {
+                    work[index] = { record, filePath, fileStart, missing: true };
+                    continue;
+                }
+                try {
+                    work[index] = {
+                        record,
+                        filePath,
+                        fileStart,
+                        result: await runFormatPhase(filePath, getFormatService, dbg),
+                    };
+                }
+                catch (err) {
+                    work[index] = {
+                        record,
+                        filePath,
+                        fileStart,
+                        error: err instanceof Error ? err.message : String(err),
+                    };
+                }
             }
-        }));
-        // Process results sequentially — bumpFileSeq and cacheManager mutations
-        // must stay ordered to avoid sequence number races.
-        for (const outcome of outcomes) {
-            if (outcome.kind === "skipped") {
-                summary.skipped.push({
-                    filePath: outcome.filePath,
-                    reason: outcome.reason,
-                });
+        };
+        await Promise.all(Array.from({ length: Math.min(DEFERRED_FORMAT_CONCURRENCY, formatRecords.length) }, () => worker()));
+        if (ambientSignal?.aborted) {
+            runtime.requeueDeferredFormatFiles(formatRecords.filter((_, index) => !started.has(index)));
+        }
+        for (const entry of work) {
+            if (!entry)
+                continue;
+            await new Promise((resolve) => setImmediate(resolve));
+            const { record, filePath, fileStart } = entry;
+            if (entry.missing) {
+                dbg(`agent_end deferred_format skipped missing file: ${filePath}`);
+                summary.skipped.push({ filePath, reason: "missing" });
                 continue;
             }
-            if (outcome.kind === "failed") {
-                summary.failed.push({
-                    filePath: outcome.filePath,
-                    errors: [outcome.message],
-                });
+            if (entry.error) {
+                dbg(`agent_end deferred_format failed for ${filePath}: ${entry.error}`);
+                summary.failed.push({ filePath, errors: [entry.error] });
                 continue;
             }
-            const { record, filePath, result, fileStart } = outcome;
+            const result = entry.result;
+            if (!result)
+                continue;
             summary.formatted++;
             if (result.formatFailures.length > 0) {
                 summary.failed.push({ filePath, errors: result.formatFailures });
@@ -202,7 +226,7 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
                     const content = nodeFs.readFileSync(filePath, "utf-8");
                     const lineCount = content.split("\n").length;
                     const hasImports = /^import\s/m.test(content);
-                    cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, hasImports, bookkeepingCwd);
+                    cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, hasImports, bookkeepingCwd, currentSessionId ?? runtime.telemetrySessionId, "pi");
                 }
                 catch (err) {
                     dbg(`agent_end deferred_format modified-range tracking failed for ${filePath}: ${err}`);
@@ -251,6 +275,14 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         }
         else {
             const enabledFiles = actionReport.data.files.filter((file) => {
+                // #1247: the per-edit dispatch surface gates ignored files before
+                // running; the turn-end autofix must apply the same filter or a
+                // `.pi-lens.json` `ignore` entry cannot protect a prose file
+                // (CHANGELOG.md / AGENTS.md) from being rewritten here.
+                if (isPathIgnoredByProject(file.filePath, ctxCwd ?? runtime.projectRoot)) {
+                    dbg(`agent_end actionable_warnings_autofix: skipped ${file.filePath} (ignored by project)`);
+                    return false;
+                }
                 const enabled = !!getFlag("lens-actionable-warning-autofix", file.filePath);
                 if (!enabled) {
                     const source = getFlagSource?.("lens-actionable-warning-autofix", file.filePath);
@@ -281,49 +313,42 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             if (!freshness.fresh) {
                 dbg(`agent_end actionable_warnings_autofix: stale report (${freshness.reason}; reportProjectSeqEnd=${freshness.reportProjectSeqEnd ?? "missing"}; currentProjectSeq=${freshness.currentProjectSeq}${freshness.filePath ? `; file=${freshness.filePath}; reportFileSeq=${freshness.reportFileSeq}; currentFileSeq=${freshness.currentFileSeq}` : ""}), skipping fixes`);
             }
-            else {
+            else if (eligibleReport.summary.autoFixEligible > 0) {
                 // #684: same "genuine work about to happen" gate as
                 // publishFormatStart — only fires when the report is fresh AND
                 // has at least one autofix-eligible warning, right before
                 // applyConservativeActionableWarningFixes actually starts.
-                if (eligibleReport.summary.autoFixEligible > 0) {
-                    publishAutofixStart({
-                        cwd: ctxCwd ?? runtime.projectRoot,
-                        paths: eligibleReport.files
-                            .filter((file) => file.warnings.some((warning) => !warning.suppressed &&
-                            warning.actions.some((action) => action.autoFixEligible)))
-                            .map((file) => file.filePath),
-                        eligibleCount: eligibleReport.summary.autoFixEligible,
-                        dbg,
-                    });
-                }
+                publishAutofixStart({
+                    cwd: ctxCwd ?? runtime.projectRoot,
+                    paths: eligibleReport.files
+                        .filter((file) => file.warnings.some((warning) => !warning.suppressed &&
+                        warning.actions.some((action) => action.autoFixEligible)))
+                        .map((file) => file.filePath),
+                    eligibleCount: eligibleReport.summary.autoFixEligible,
+                    dbg,
+                });
                 const fixStart = Date.now();
+                const fixCwd = ctxCwd ?? runtime.projectRoot;
+                const mutationContext = {
+                    cwd: fixCwd,
+                    correlationId: newLspMutationCorrelationId(),
+                    tool: "lsp-quickfix",
+                    source: "autofix",
+                    runtime,
+                    cacheManager,
+                    readGuard: getFlag("no-read-guard") ? undefined : runtime.readGuard,
+                    recordAutofix: getFlag("lens-turn-summary")
+                        ? (filePath) => runtime.turnSummary.recordAutofix(filePath, { tool: "lsp-quickfix" })
+                        : undefined,
+                    dbg,
+                };
                 const fixSummary = await applyConservativeActionableWarningFixes({
-                    cwd: ctxCwd ?? runtime.projectRoot,
+                    cwd: fixCwd,
                     report: eligibleReport,
                     maxFixes: getGlobalActionableWarningMaxFixes(),
                     dbg,
+                    mutationContext,
                 });
-                for (const changedFile of fixSummary.changedFiles) {
-                    if (!nodeFs.existsSync(changedFile))
-                        continue;
-                    recordProjectChange({
-                        runtime,
-                        cwd: ctxCwd ?? runtime.projectRoot,
-                        filePath: changedFile,
-                        source: "autofix",
-                        dbg,
-                    });
-                    if (!getFlag("no-read-guard"))
-                        runtime.readGuard.recordWritten(changedFile);
-                    try {
-                        const content = nodeFs.readFileSync(changedFile, "utf-8");
-                        cacheManager.addModifiedRange(changedFile, { start: 1, end: content.split("\n").length }, /^import\s/m.test(content), ctxCwd ?? runtime.projectRoot);
-                    }
-                    catch (err) {
-                        dbg(`agent_end actionable warning changed-file tracking failed for ${changedFile}: ${err}`);
-                    }
-                }
                 if (fixSummary.changedFiles.length > 0) {
                     publishFilesTouched({
                         reason: "autofix",
@@ -336,13 +361,6 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
                             kind: "autofix",
                         })),
                     });
-                    if (getFlag("lens-turn-summary")) {
-                        for (const changedFile of fixSummary.changedFiles) {
-                            runtime.turnSummary.recordAutofix(changedFile, {
-                                tool: "lsp-quickfix",
-                            });
-                        }
-                    }
                 }
                 logLatency({
                     type: "phase",
@@ -361,6 +379,9 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
                     notify(`pi-lens applied ${fixSummary.applied} conservative LSP warning quickfix(es)`, "info");
                 }
             }
+            else {
+                dbg("agent_end actionable_warnings_autofix: fresh report, 0 autofix-eligible warnings, skipping");
+            }
         }
     }
     logLatency({
@@ -377,6 +398,19 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             skipped: summary.skipped.length,
         },
     });
+    logLatency({
+        type: "phase",
+        toolName: "agent_end",
+        filePath: ctxCwd ?? runtime.projectRoot,
+        phase: "agent_end_deferred_format_done",
+        durationMs: Date.now() - startedAt,
+        metadata: {
+            formatted: summary.formatted,
+            changed: summary.changed.length,
+            failed: summary.failed.length,
+            skipped: summary.skipped.length,
+        },
+    });
     dbg(`agent_end deferred_format complete: formatted=${summary.formatted} changed=${summary.changed.length} failed=${summary.failed.length} skipped=${summary.skipped.length}`);
     if (summary.failed.length > 0) {
         notify(`pi-lens deferred format: ${summary.changed.length} changed, ${summary.failed.length} failed`, "warning");

package/node_modules/pi-lens/dist/clients/runtime-context.js

@@ -1,30 +1,54 @@
+// Exported so the Stop-hook bin strips exactly what these bridges prepend.
+export const AUTOMATION_FRAMING = "[pi-lens automated check — not a user request] ";
+function turnEndMessage(content) {
+    return {
+        role: "user",
+        content: `${AUTOMATION_FRAMING}Address 🔴 blockers before continuing; ℹ️ advisories are informational only.\n\n${content}`,
+    };
+}
+/** Read a turn-end finding without changing its durable delivery state. */
+export function peekTurnEndFindings(cacheManager, cwd) {
+    const findings = cacheManager.readCache("turn-end-findings", cwd);
+    if (!findings?.data?.content || findings.data.consumed === true)
+        return;
+    return { messages: [turnEndMessage(findings.data.content)] };
+}
 export function consumeTurnEndFindings(cacheManager, cwd) {
     const findings = cacheManager.readCache("turn-end-findings", cwd);
+    if (!findings?.data?.content || findings.data.consumed === true)
+        return;
+    // A blocker record is also the opt-in commit gate's durable state. Mark the
+    // context message consumed without deleting the record; clean/advisory-only
+    // records retain the historical consume-and-clear behavior.
+    if (findings.data.hasBlockers === true &&
+        typeof findings.data.sessionId === "string") {
+        cacheManager.writeCache("turn-end-findings", { ...findings.data, consumed: true }, cwd);
+    }
+    else {
+        cacheManager.clearCache("turn-end-findings", cwd);
+    }
+    return { messages: [turnEndMessage(findings.data.content)] };
+}
+/** Read test findings without consuming them; used by acknowledged IPC delivery. */
+export function peekTestFindings(cacheManager, cwd) {
+    const findings = cacheManager.readCache("test-runner-findings", cwd);
     if (!findings?.data?.content)
         return;
-    cacheManager.writeCache("turn-end-findings", null, cwd);
     return {
         messages: [
             {
                 role: "user",
-                content: `[pi-lens automated check — not a user request] Address 🔴 blockers before continuing; ℹ️ advisories are informational only.\n\n${findings.data.content}`,
+                content: `${AUTOMATION_FRAMING}Test failures detected last turn — fix before continuing:\n\n${findings.data.content}`,
             },
         ],
     };
 }
 export function consumeTestFindings(cacheManager, cwd) {
-    const findings = cacheManager.readCache("test-runner-findings", cwd);
-    if (!findings?.data?.content)
+    const findings = peekTestFindings(cacheManager, cwd);
+    if (!findings)
         return;
     cacheManager.writeCache("test-runner-findings", null, cwd);
-    return {
-        messages: [
-            {
-                role: "user",
-                content: `[pi-lens automated check — not a user request] Test failures detected last turn — fix before continuing:\n\n${findings.data.content}`,
-            },
-        ],
-    };
+    return findings;
 }
 export function consumeSessionStartGuidance(cacheManager, cwd) {
     const guidance = cacheManager.readCache("session-start-guidance", cwd);

package/node_modules/pi-lens/dist/clients/runtime-coordinator.js

@@ -1,6 +1,8 @@
 import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { normalizeMapKey } from "./path-utils.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
 import { ReadGuard } from "./read-guard.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { TurnSummaryCollector } from "./turn-summary.js";
@@ -45,12 +47,13 @@ export class RuntimeCoordinator {
     _fileLastProjectSeq = new Map();
     _gitGuardHasBlockers = false;
     _gitGuardSummary = "";
+    _gitGuardCacheUnknownReason;
     callGraph = null;
     wordIndex = null;
     _readGuard = null;
     _pendingDeferredFormatFiles = new Map();
     _lspReadWarmState = new Map();
-    _pendingInlineBlockers = new Map();
+    _pendingInlineBlockers = new PathKeyedMap(normalizeMapKey);
     _actionableWarningsThisTurn = new Map();
     _codeQualityWarningsThisTurn = new Map();
     // #484: opt-in per-RUN summary of diagnostics/autofixes/formats,
@@ -87,6 +90,7 @@ export class RuntimeCoordinator {
         this._fileLastProjectSeq.clear();
         this._gitGuardHasBlockers = false;
         this._gitGuardSummary = "";
+        this._gitGuardCacheUnknownReason = undefined;
         this._readGuard = null;
         this._pendingDeferredFormatFiles.clear();
         this._lspReadWarmState.clear();
@@ -107,8 +111,12 @@ export class RuntimeCoordinator {
         this._cascadeSessionStats.coldSnapshotTouches += coldSnapshotTouches;
     }
     updateGitGuardStatus(hasBlockers, output) {
-        this._gitGuardHasBlockers = hasBlockers;
-        if (!hasBlockers) {
+        // The status is an aggregate over the current per-file map. A clean B
+        // result must not erase an unresolved A result; the pipeline records/clears
+        // the edited file immediately before this method runs.
+        this._gitGuardHasBlockers =
+            hasBlockers || this.getInlineBlockersSnapshot().length > 0;
+        if (!this._gitGuardHasBlockers) {
             this._gitGuardSummary = "";
             return;
         }
@@ -116,7 +124,10 @@ export class RuntimeCoordinator {
             .split("\n")
             .map((line) => line.trim())
             .find((line) => line.length > 0);
-        this._gitGuardSummary = (firstLine ?? "Unresolved blockers detected").slice(0, 160);
+        const summaries = this.getInlineBlockersSnapshot()
+            .map((entry) => entry.summary.trim())
+            .filter(Boolean);
+        this._gitGuardSummary = (summaries[0] ?? firstLine ?? "Unresolved blockers detected").slice(0, 160);
     }
     get gitGuardHasBlockers() {
         return this._gitGuardHasBlockers;
@@ -124,6 +135,15 @@ export class RuntimeCoordinator {
     get gitGuardSummary() {
         return this._gitGuardSummary;
     }
+    markGitGuardCacheUnknown(reason) {
+        this._gitGuardCacheUnknownReason = reason;
+    }
+    clearGitGuardCacheUnknown() {
+        this._gitGuardCacheUnknownReason = undefined;
+    }
+    get gitGuardCacheUnknownReason() {
+        return this._gitGuardCacheUnknownReason;
+    }
     beginTurn() {
         this._cascadeRuns = [];
         // _pendingCascadeRuns is deliberately NOT cleared here: a cascade compute
@@ -131,7 +151,9 @@ export class RuntimeCoordinator {
         // measured up to ~19s) must surface on the NEXT turn_end, not be dropped —
         // pre-#450 those findings were always awaited, never lost. Session reset
         // still clears it.
-        this._pendingInlineBlockers.clear();
+        // Inline blockers are session-scoped per-file state. They are cleared only
+        // when that file is re-analyzed clean or the session resets; a new turn must
+        // not let a clean unrelated file erase an unresolved blocker.
         this._actionableWarningsThisTurn.clear();
         this._codeQualityWarningsThisTurn.clear();
         // _turnSummary is deliberately NOT cleared here (#484 rework): the
@@ -365,8 +387,45 @@ export class RuntimeCoordinator {
     clearInlineBlockers(filePath) {
         this._pendingInlineBlockers.delete(path.resolve(filePath));
     }
+    reconcileInlineBlockers() {
+        // Rebuild, never delete-in-place: `PathKeyedMap.delete()` re-normalizes
+        // the key, and `normalizeMapKey` realpaths a live file but lowercases
+        // the tail of a deleted one — so on Windows a mixed-case filename gets
+        // a DIFFERENT delete-time key than its set-time key and the delete
+        // misses (#1245, verified live: `MyCase.ts` survived reconcile).
+        // Existence-checking the display path and rebuilding survivors avoids
+        // the key-mismatch entirely; live survivors re-set to identical keys
+        // (both realpath), so only the stale entries are dropped.
+        const survivors = [];
+        for (const [displayPath, value] of this._pendingInlineBlockers.entries()) {
+            if (fs.existsSync(displayPath))
+                survivors.push([displayPath, value]);
+        }
+        if (survivors.length !== this._pendingInlineBlockers.size) {
+            this._pendingInlineBlockers.clear();
+            for (const [displayPath, value] of survivors) {
+                this._pendingInlineBlockers.set(displayPath, value);
+            }
+        }
+    }
+    /**
+     * Stale-entry reconcile (#1245): a blocker recorded for a file that has
+     * since been deleted can never be cleared — `clearInlineBlockers` fires
+     * only on a LATER dispatch of the same path, which a deleted file never
+     * gets. Every read of the blocker map (turn_end injection, git-guard
+     * size/summary, `syncGitGuardRecord`) therefore drops entries whose file no
+     * longer exists on disk: a blocker for a deleted file is stale by
+     * definition (the agent cannot fix it), so it must not re-surface every
+     * turn or gate a commit. The map is tiny (per-turn blockers) and reads are
+     * bounded (once per turn_end / tool_result), so the probe cost is
+     * negligible.
+     */
+    getInlineBlockersSnapshot() {
+        this.reconcileInlineBlockers();
+        return [...this._pendingInlineBlockers.values()];
+    }
     consumeInlineBlockers() {
-        const entries = [...this._pendingInlineBlockers.values()];
+        const entries = this.getInlineBlockersSnapshot();
         this._pendingInlineBlockers.clear();
         return entries;
     }
@@ -500,6 +559,15 @@ export class RuntimeCoordinator {
         }
         return { claimed, staleClaimed, deferredToOwner };
     }
+    /** Return claimed records that were never started by an aborted drain. */
+    requeueDeferredFormatFiles(records) {
+        for (const record of records) {
+            const key = path.resolve(record.filePath);
+            if (!this._pendingDeferredFormatFiles.has(key)) {
+                this._pendingDeferredFormatFiles.set(key, record);
+            }
+        }
+    }
     shouldWarmLspOnRead(filePath, maxAgeMs = 120_000) {
         const state = this._lspReadWarmState.get(path.resolve(filePath));
         if (!state)