@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/runtime-tool-call.js

@@ -1,6 +1,5 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
-import { extractReadPathsFromCommand, extractWrittenPathsFromCommand, } from "./bash-file-access.js";
 import { loadBootstrapClients } from "./bootstrap.js";
 import { detectFileKind } from "./file-kinds.js";
 import { isPathIgnoredByProject } from "./file-utils.js";
@@ -14,7 +13,7 @@ import { computeTrailingWhitespaceOldTextPatch, findUniqueMatchLineRange, } from
 import { applyPartiallyApplicableEdits } from "./partial-edit-apply.js";
 import { isExternalOrVendorFile } from "./path-utils.js";
 import { EXPANSION_BUDGET_MS, EXPANSION_LIMIT_LINES, tryExpandRead, } from "./read-expansion.js";
-import { logReadGuardEvent } from "./read-guard-logger.js";
+import { boundedIndexesForCount, createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent, } from "./read-guard-logger.js";
 import { countFileLines, getTouchedLinesForGuard, relocateEditRange, tryCorrectIndentationMismatch, tryCorrectIndentationMismatchFromContent, } from "./read-guard-tool-lines.js";
 import { handleToolResult } from "./runtime-tool-result.js";
 import { isToolCallEventType } from "./tool-event.js";
@@ -142,7 +141,42 @@ function getNewContentFromToolCall(event) {
 }
 export async function handleToolCall(deps) {
     const { event, ctx, lensEnabled, getFlag, dbg, runtime, cacheManager, ensureLSPConfigInitialized, updateLspStatus, resetLSPService, getTreeSitterClient = getSharedTreeSitterClient, } = deps;
+    const readGuardCorrelationId = getReadGuardCorrelationId(event);
+    let filePath;
+    const logToolReadGuardEvent = (entry) => logReadGuardEvent({ ...entry, correlationId: readGuardCorrelationId });
     const toolName = event.toolName ?? "";
+    const editInputForTelemetry = event.input;
+    const requestedEditIndexes = toolName === "write"
+        ? [0]
+        : Array.isArray(editInputForTelemetry?.edits)
+            ? boundedIndexesForCount(editInputForTelemetry.edits.length)
+            : [0];
+    const logBlockedEditSummary = (source) => logToolReadGuardEvent({
+        event: "edit_batch_summary",
+        filePath: filePath ?? "",
+        metadata: {
+            tool: toolName,
+            source,
+            editBatchSummary: createReadGuardEditBatchSummary({
+                requestedIndexes: requestedEditIndexes,
+                requestedTotal: toolName === "write"
+                    ? 1
+                    : Array.isArray(editInputForTelemetry?.edits)
+                        ? editInputForTelemetry.edits.length
+                        : 1,
+                rejectedReasons: requestedEditIndexes.map((index) => ({
+                    index,
+                    code: "preflight_blocked",
+                })),
+                rejectedTotal: toolName === "write"
+                    ? 1
+                    : Array.isArray(editInputForTelemetry?.edits)
+                        ? editInputForTelemetry.edits.length
+                        : 1,
+                terminalStatus: "blocked",
+            }),
+        },
+    });
     if (!lensEnabled)
         return;
     if (getFlag("lens-guard") &&
@@ -156,7 +190,7 @@ export async function handleToolCall(deps) {
         }
     }
     const rawFilePath = getToolCallRawFilePath(toolName, event);
-    const filePath = resolveToolCallFilePath(rawFilePath, ctx.cwd, runtime.projectRoot);
+    filePath = resolveToolCallFilePath(rawFilePath, ctx.cwd, runtime.projectRoot);
     if (!getFlag("no-lsp")) {
         try {
             const configCwd = filePath
@@ -312,7 +346,7 @@ export async function handleToolCall(deps) {
                 else {
                     enclosingSymbol = expansion.enclosingSymbol;
                 }
-                logReadGuardEvent({
+                logToolReadGuardEvent({
                     event: "ts_range_expanded",
                     sessionId: runtime.telemetrySessionId,
                     filePath,
@@ -348,7 +382,7 @@ export async function handleToolCall(deps) {
     if (toolName === "read" && filePath && !isExternalOrVendor) {
         const totalLines = countFileLines(filePath);
         const deliveredLimit = effectiveReadLimit ?? 1;
-        logReadGuardEvent({
+        logToolReadGuardEvent({
             event: "read_pattern",
             sessionId: runtime.telemetrySessionId,
             filePath,
@@ -379,41 +413,6 @@ export async function handleToolCall(deps) {
             timestamp: Date.now(),
         });
     }
-    // --- Read-Before-Edit Guard: register file access done via `bash` ---
-    // Mirrors how the Read/Write tools are tracked. Only the bash tool —
-    // grep/find tools (and their patterns) are not contiguous file access.
-    //   reads  (cat/head/tail/sed -n) → recordRead with the exact range shown
-    //   writes (>, >>, tee, sed -i, cp/mv dest, touch) → noteCreatedFile, so the
-    //          agent "owns" the file (recordWritten fires at tool_result), same
-    //          as the Write tool.
-    if (toolName === "bash" && !getFlag("no-read-guard")) {
-        const cmd = event.input?.command;
-        if (typeof cmd === "string" && cmd) {
-            const effectiveCwd = ctx.cwd ?? runtime.projectRoot ?? process.cwd();
-            const inScope = (fp) => !isPathIgnoredByProject(fp, runtime.projectRoot, false) &&
-                !isExternalOrVendorFile(fp, runtime.projectRoot);
-            for (const span of extractReadPathsFromCommand(cmd, effectiveCwd)) {
-                if (!inScope(span.filePath))
-                    continue;
-                runtime.readGuard.recordRead({
-                    filePath: span.filePath,
-                    requestedOffset: span.offset,
-                    requestedLimit: span.limit,
-                    effectiveOffset: span.offset,
-                    effectiveLimit: span.limit,
-                    expandedByLsp: false,
-                    turnIndex: runtime.turnIndex,
-                    writeIndex: runtime.peekWriteIndex(),
-                    timestamp: Date.now(),
-                });
-            }
-            for (const wp of extractWrittenPathsFromCommand(cmd, effectiveCwd)) {
-                if (!inScope(wp))
-                    continue;
-                runtime.readGuard.noteCreatedFile(wp, runtime.turnIndex, runtime.peekWriteIndex());
-            }
-        }
-    }
     const { complexityClient } = await loadBootstrapClients();
     // Record complexity baseline for historical tracking (booboo/tdi).
     // Not shown inline - just captured for delta analysis.
@@ -511,7 +510,7 @@ export async function handleToolCall(deps) {
                     continue;
                 entry.apply(escaped);
                 entry.value = escaped;
-                logReadGuardEvent({
+                logToolReadGuardEvent({
                     event: "oldtext_escape_autopatched",
                     sessionId: runtime.telemetrySessionId,
                     filePath,
@@ -541,7 +540,7 @@ export async function handleToolCall(deps) {
                     entry.applyNewText(patch.newText);
                     entry.newText = patch.newText;
                 }
-                logReadGuardEvent({
+                logToolReadGuardEvent({
                     event: "oldtext_trailing_ws_autopatched",
                     sessionId: runtime.telemetrySessionId,
                     filePath,
@@ -612,7 +611,7 @@ export async function handleToolCall(deps) {
                 if (correctedNewText !== undefined) {
                     entry.applyNewText(correctedNewText);
                 }
-                logReadGuardEvent({
+                logToolReadGuardEvent({
                     event: "oldtext_indent_autopatched",
                     sessionId: runtime.telemetrySessionId,
                     filePath,
@@ -651,20 +650,25 @@ export async function handleToolCall(deps) {
         const isExistingFile = typeof readGuard?.isNewFile !== "function" ||
             !readGuard.isNewFile(filePath);
         if (readGuard && isExistingFile && !isExternalOrVendor) {
-            const { touchedLines, editRanges, preflightError, partiallyApplicable, contentMatchValidated, } = getTouchedLinesForGuard(event, filePath, runtime.telemetrySessionId);
+            const { touchedLines, editRanges, preflightError, partiallyApplicable, contentMatchValidated, editBatchSummary, } = getTouchedLinesForGuard(event, filePath, runtime.telemetrySessionId, readGuardCorrelationId);
             if (preflightError) {
                 if (partiallyApplicable && partiallyApplicable.length > 0) {
                     try {
                         const partial = await applyPartiallyApplicableEdits({
                             filePath,
                             edits: partiallyApplicable,
+                            summary: editBatchSummary,
+                            correlationId: readGuardCorrelationId,
                             afterWrite: async () => {
                                 const { biomeClient, ruffClient, metricsClient, agentBehaviorClient, } = await loadBootstrapClients();
                                 const result = await handleToolResult({
                                     event: {
                                         toolName: "write",
                                         input: { path: filePath },
-                                        details: { piLensPartialApply: true },
+                                        details: {
+                                            piLensPartialApply: true,
+                                            readGuardCorrelationId,
+                                        },
                                         content: [],
                                         provider: event.provider,
                                         model: event.model,
@@ -683,20 +687,35 @@ export async function handleToolCall(deps) {
                                     agentBehaviorRecord: (toolName, analyzedPath) => agentBehaviorClient.recordToolCall(toolName, analyzedPath),
                                     formatBehaviorWarnings: (warnings) => agentBehaviorClient.formatWarnings(warnings),
                                 });
+                                if (result?.isError) {
+                                    throw new Error("post-edit pipeline rejected synthetic partial apply");
+                                }
                                 return result?.content
                                     ?.map((item) => item.text)
                                     .filter((text) => !!text)
                                     .join("\n\n");
                             },
                         });
+                        if (partial.postEditStatus === "failed") {
+                            return {
+                                block: true,
+                                reason: `${preflightError}\n\nPartial apply pipeline failed after ${partial.appliedCount} edit${partial.appliedCount === 1 ? "" : "s"} committed.`,
+                            };
+                        }
                         if (partial.appliedCount > 0) {
-                            logReadGuardEvent({
+                            logToolReadGuardEvent({
                                 event: "edit_partial_apply",
                                 sessionId: runtime.telemetrySessionId,
                                 filePath,
                                 metadata: {
                                     appliedCount: partial.appliedCount,
+                                    appliedTotal: partial.appliedTotal,
                                     appliedIndices: partial.appliedIndices,
+                                    skippedCount: partial.skippedCount ?? 0,
+                                    skippedTotal: partial.skippedTotal ?? 0,
+                                    skippedIndices: partial.skippedIndices ?? "",
+                                    indexesTruncated: partial.indexesTruncated ?? false,
+                                    editBatchSummary: partial.summary,
                                     routedThroughPostEditPipeline: true,
                                 },
                             });
@@ -711,9 +730,11 @@ export async function handleToolCall(deps) {
                         // fall through to full block
                     }
                 }
+                if (!editBatchSummary)
+                    logBlockedEditSummary("preflight");
                 return { block: true, reason: preflightError };
             }
-            logReadGuardEvent({
+            logToolReadGuardEvent({
                 event: "edit_check_started",
                 sessionId: runtime.telemetrySessionId,
                 filePath,
@@ -750,7 +771,7 @@ export async function handleToolCall(deps) {
                         writeIndex: 0,
                         timestamp: Date.now(),
                     });
-                    logReadGuardEvent({
+                    logToolReadGuardEvent({
                         event: "edit_range_relocated",
                         sessionId: runtime.telemetrySessionId,
                         filePath,
@@ -763,10 +784,12 @@ export async function handleToolCall(deps) {
                     // Relocation applied — let the re-targeted edit proceed.
                 }
                 else if (verdict.action === "block") {
+                    logBlockedEditSummary("range_relocated_blocked");
                     return { block: true, reason: verdict.reason };
                 }
             }
             else if (verdict.action === "block") {
+                logBlockedEditSummary("read_guard_blocked");
                 return {
                     block: true,
                     reason: verdict.reason,

package/node_modules/pi-lens/dist/clients/runtime-tool-result.js

@@ -1,17 +1,20 @@
 import * as nodeCrypto from "node:crypto";
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
-import { extractGrepSearchReadsFromOutput, extractWrittenPathsFromCommand, } from "./bash-file-access.js";
+import { extractReadPathsFromCommand, extractGrepSearchReadsFromOutput, extractWrittenPathsFromCommand, } from "./bash-file-access.js";
 import { registerSearchReads, } from "./search-read-registration.js";
 import { createFileTime } from "./file-time.js";
 import { publishFormatQueued } from "./format-events-publish.js";
 import { isPathIgnoredByProject } from "./file-utils.js";
 import { getFormatService } from "./format-service.js";
-import { isExternalOrVendorFile } from "./path-utils.js";
+import { isExternalOrVendorFile, normalizeEphemeralMapKey } from "./path-utils.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
 import { resolveLanguageRootForFile } from "./language-profile.js";
 import { logLatency } from "./latency-logger.js";
+import { boundedIndexesForCount, createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent, } from "./read-guard-logger.js";
 import { runPipeline } from "./pipeline.js";
 import { appendProjectChange, } from "./project-changes.js";
+import { syncGitGuardRecord } from "./git-guard.js";
 import { scheduleWordIndexPersist } from "./word-index.js";
 function parseDiffRanges(diff) {
     const changedLines = [];
@@ -40,19 +43,23 @@ function parseDiffRanges(diff) {
     ranges.push({ start: rangeStart, end: rangeEnd });
     return ranges;
 }
-// Deduplicates tool_result calls for the same post-write file state.
-// The pi framework can emit one tool_result per edit hunk; those events often
-// observe the same final file content. Deduping by file alone is unsafe because
-// a later same-turn edit to the same file must still run the pipeline.
-const inFlightPipelines = new Map();
-const lastAnalyzedStateByFile = new Map();
+// Keyed by (normalized) filePath, then by the raw stateHash — the path portion
+// needs normalizing (divergent Windows spellings must collapse to one entry),
+// the stateHash suffix must NOT be folded into the path key (a real content
+// change for the same file has to stay a distinct entry). A flat
+// `PathKeyedMap<InFlightPipeline>` keyed by a composite `${filePath}:${hash}`
+// string can't express that split cleanly (the normalizer only sees the whole
+// composite string, so it can't fold the path half without also mangling the
+// hash half); nesting keeps each axis normalized/compared with its own rules.
+const inFlightPipelines = new PathKeyedMap(normalizeEphemeralMapKey);
+const lastAnalyzedStateByFile = new PathKeyedMap(normalizeEphemeralMapKey);
 // Called at turn_start — entries from the previous turn can never match the new
 // turnIndex so they're dead weight. Clearing here keeps the map bounded to the
 // files touched in the current turn only (typically < 20).
 export function clearLastAnalyzedStateCache() {
     lastAnalyzedStateByFile.clear();
 }
-const debouncedPipelines = new Map();
+const debouncedPipelines = new PathKeyedMap(normalizeEphemeralMapKey);
 const DEFAULT_DEBOUNCE_MS = 0;
 const MAX_DEBOUNCE_MS = 1000;
 function getDebounceMs() {
@@ -98,7 +105,13 @@ function scheduleDebounced(filePath, debounceMs, deps) {
     const existing = debouncedPipelines.get(filePath);
     if (existing) {
         clearTimeout(existing.timer);
-        existing.latestDeps = deps;
+        const incomingId = deps._telemetryParticipantIds?.[0] ?? getReadGuardCorrelationId(deps.event);
+        const priorIds = existing.latestDeps._telemetryParticipantIds ?? [];
+        existing.latestDeps = {
+            ...deps,
+            _telemetryParticipantIds: [...priorIds, incomingId].slice(0, 100),
+            _telemetryParticipantTotal: (existing.latestDeps._telemetryParticipantTotal ?? priorIds.length) + 1,
+        };
         existing.coalescedCount += 1;
         existing.timer = setTimeout(() => {
             debouncedPipelines.delete(filePath);
@@ -114,6 +127,7 @@ function scheduleDebounced(filePath, debounceMs, deps) {
         resolveFn = res;
         rejectFn = rej;
     });
+    const initialParticipantIds = deps._telemetryParticipantIds ?? [getReadGuardCorrelationId(deps.event)];
     const entry = {
         timer: setTimeout(() => {
             debouncedPipelines.delete(filePath);
@@ -122,7 +136,11 @@ function scheduleDebounced(filePath, debounceMs, deps) {
         promise,
         resolve: resolveFn,
         reject: rejectFn,
-        latestDeps: deps,
+        latestDeps: {
+            ...deps,
+            _telemetryParticipantIds: initialParticipantIds.slice(0, 100),
+            _telemetryParticipantTotal: deps._telemetryParticipantTotal ?? initialParticipantIds.length,
+        },
         scheduledAt: Date.now(),
         coalescedCount: 1,
     };
@@ -139,6 +157,15 @@ function getFileStateHash(filePath) {
         return `unreadable:${code}`;
     }
 }
+function getRequestedEditCount(event) {
+    if (event.toolName === "write")
+        return 1;
+    const edits = event.input?.edits;
+    return Array.isArray(edits) && edits.length > 0 ? edits.length : 1;
+}
+function getRequestedEditIndexes(event) {
+    return boundedIndexesForCount(getRequestedEditCount(event));
+}
 function sourceForToolName(toolName, details) {
     if (details
         ?.piLensPartialApply) {
@@ -191,7 +218,8 @@ export async function handleToolResult(deps) {
     if (event.toolName === "bash" &&
         typeof event.input.command === "string") {
         const command = event.input.command;
-        const written = extractWrittenPathsFromCommand(command, workspaceRoot).filter((wp) => !isExternalOrVendorFile(wp, workspaceRoot) &&
+        const written = extractWrittenPathsFromCommand(command, workspaceRoot).filter((wp) => event.isError !== true &&
+            !isExternalOrVendorFile(wp, workspaceRoot) &&
             !isPathIgnoredByProject(wp, workspaceRoot, false));
         for (const wp of written) {
             if (!getFlag("no-read-guard"))
@@ -202,12 +230,31 @@ export async function handleToolResult(deps) {
                 _bypassDebounce: true,
             });
         }
+        if (event.isError !== true && !getFlag("no-read-guard")) {
+            for (const span of extractReadPathsFromCommand(command, workspaceRoot)) {
+                if (isExternalOrVendorFile(span.filePath, workspaceRoot))
+                    continue;
+                if (isPathIgnoredByProject(span.filePath, workspaceRoot, false))
+                    continue;
+                deps.readGuard?.recordRead({
+                    filePath: span.filePath,
+                    requestedOffset: span.offset,
+                    requestedLimit: span.limit,
+                    effectiveOffset: span.offset,
+                    effectiveLimit: span.limit,
+                    expandedByLsp: false,
+                    turnIndex: runtime.turnIndex,
+                    writeIndex: runtime.peekWriteIndex(),
+                    timestamp: Date.now(),
+                });
+            }
+        }
     }
     // Search tools reveal specific lines (file:line) the agent then edits — register
     // those shown lines (± context) as reads so the follow-up edit isn't blocked (#169).
     // Our tools attach locations as `details.searchReads`; bash grep is parsed from
     // `grep -n` output. Only shown lines are registered, never the whole file.
-    if (deps.readGuard && !getFlag("no-read-guard")) {
+    if (deps.readGuard && event.isError !== true && !getFlag("no-read-guard")) {
         const searchReads = [];
         const detailSearchReads = event.details?.searchReads;
         if (Array.isArray(detailSearchReads))
@@ -240,13 +287,54 @@ export async function handleToolResult(deps) {
         dbg(`tool_result: skipped pipeline - file outside project root or in node_modules: ${filePath}`);
         return;
     }
+    const readGuardCorrelationId = getReadGuardCorrelationId(event);
+    const resultDetails = (event.details ?? {});
+    const isPartialApplyResult = resultDetails.piLensPartialApply === true;
+    const requestedEditIndexes = getRequestedEditIndexes(event);
+    const requestedEditTotal = getRequestedEditCount(event);
+    const participantIds = [
+        ...(deps._telemetryParticipantIds ?? []),
+        readGuardCorrelationId,
+    ].slice(0, 100);
+    const participantTotal = (deps._telemetryParticipantTotal ?? 0) +
+        (deps._telemetryParticipantIds?.includes(readGuardCorrelationId) ? 0 : 1);
+    const hostToolResultFailed = event.isError === true || resultDetails.isError === true;
+    if (hostToolResultFailed) {
+        logReadGuardEvent({
+            event: "edit_batch_summary",
+            correlationId: readGuardCorrelationId,
+            filePath,
+            metadata: {
+                tool: event.toolName,
+                source: "host_tool_result",
+                editBatchSummary: createReadGuardEditBatchSummary({
+                    requestedIndexes: requestedEditIndexes,
+                    requestedTotal: requestedEditTotal,
+                    rejectedReasons: requestedEditIndexes.map((index) => ({
+                        index,
+                        code: "write_failed",
+                    })),
+                    rejectedTotal: requestedEditTotal,
+                    participantIds: [readGuardCorrelationId],
+                    participantTotal: 1,
+                    commitStatus: "failed",
+                    terminalStatus: "failed",
+                }),
+            },
+        });
+        return { content: event.content, isError: true };
+    }
     // Coalesce sequential edits to the same file into one pipeline run against
     // the final state. Only the debounce-fired call (with _bypassDebounce=true)
     // proceeds to the pipeline body; in-window callers share its promise.
     if (!deps._bypassDebounce) {
         const debounceMs = getDebounceMs();
         if (debounceMs > 0) {
-            return scheduleDebounced(filePath, debounceMs, deps);
+            return scheduleDebounced(filePath, debounceMs, {
+                ...deps,
+                _telemetryParticipantIds: [readGuardCorrelationId],
+                _telemetryParticipantTotal: 1,
+            });
         }
     }
     // Refresh the read-guard's FileTime stamp so that the model's own write
@@ -275,13 +363,18 @@ export async function handleToolResult(deps) {
         }
     }
     const initialStateHash = getFileStateHash(filePath);
-    const pipelineDedupeKey = `${filePath}:${initialStateHash}`;
     // Deduplicate concurrent calls for the same final file state (pi can fire one
     // tool_result per edit hunk). Do not dedupe by file alone: a distinct later
     // same-turn edit to this file must still be analyzed.
-    if (inFlightPipelines.has(pipelineDedupeKey)) {
+    const inFlight = inFlightPipelines.get(filePath)?.get(initialStateHash);
+    if (inFlight) {
         dbg(`tool_result: skipping duplicate concurrent state for ${filePath}`);
-        await inFlightPipelines.get(pipelineDedupeKey);
+        const duplicateId = readGuardCorrelationId;
+        if (inFlight.participantIds.length < 100) {
+            inFlight.participantIds.push(duplicateId);
+        }
+        inFlight.participantTotal += 1;
+        await inFlight.promise;
         return;
     }
     // Deduplicate sequential duplicate events for the same post-write state in the
@@ -319,6 +412,13 @@ export async function handleToolResult(deps) {
     const writeIndex = runtime.nextWriteIndex();
     let modifiedRanges;
     try {
+        // #1334 S6: the host DECLARES this payload (`EditToolDetails`, a
+        // type-only export), so use it instead of re-declaring `{ diff?: string }`
+        // here — the ad-hoc shape hid the sibling `patch`/`firstChangedLine`
+        // fields. `Partial<>` keeps the defensive posture: the host types mark
+        // `diff` required, but this runs against whatever a live host actually
+        // sent, and the `details?.diff` truthiness check below is what the code
+        // has always relied on.
         const details = event.details;
         dbg(`tool_result: details.diff=${details?.diff ? "present" : "missing"}, details keys: ${Object.keys(event.details || {}).join(", ")}`);
         if (event.toolName === "edit" && details?.diff) {
@@ -367,6 +467,7 @@ export async function handleToolResult(deps) {
     const pipelinePromise = runPipeline({
         filePath,
         cwd: dispatchCwd,
+        projectRoot: turnStateCwd,
         toolName: event.toolName,
         modifiedRanges,
         telemetry: {
@@ -404,12 +505,57 @@ export async function handleToolResult(deps) {
         getFormatService,
         fixedThisTurn: runtime.fixedThisTurn,
     });
-    inFlightPipelines.set(pipelineDedupeKey, pipelinePromise);
+    const pipelineTelemetry = {
+        promise: pipelinePromise,
+        participantIds: [...new Set(participantIds)].slice(0, 100),
+        participantTotal,
+    };
+    let filePipelines = inFlightPipelines.get(filePath);
+    if (!filePipelines) {
+        filePipelines = new Map();
+        inFlightPipelines.set(filePath, filePipelines);
+    }
+    filePipelines.set(initialStateHash, pipelineTelemetry);
     try {
         result = await pipelinePromise;
     }
     catch (pipelineErr) {
+        if (getFlag("lens-guard")) {
+            runtime.markGitGuardCacheUnknown("pipeline_crash");
+        }
         dbg(`runPipeline crashed: ${pipelineErr}`);
+        logReadGuardEvent({
+            event: "edit_post_edit_pipeline_failed",
+            correlationId: readGuardCorrelationId,
+            filePath,
+            metadata: {
+                tool: event.toolName,
+                commitStatus: "committed",
+                reasonCode: "pipeline_failed",
+            },
+        });
+        logReadGuardEvent({
+            event: "edit_batch_summary",
+            correlationId: readGuardCorrelationId,
+            filePath,
+            metadata: {
+                tool: event.toolName,
+                editBatchSummary: createReadGuardEditBatchSummary({
+                    requestedIndexes: requestedEditIndexes,
+                    requestedTotal: requestedEditTotal,
+                    resolvedIndexes: requestedEditIndexes,
+                    resolvedTotal: requestedEditTotal,
+                    appliedIndexes: requestedEditIndexes,
+                    appliedTotal: requestedEditTotal,
+                    participantIds: pipelineTelemetry.participantIds,
+                    participantTotal: pipelineTelemetry.participantTotal,
+                    commitStatus: "committed",
+                    postEditStatus: "failed",
+                    terminalStatus: "failed",
+                    durationMs: Date.now() - toolResultStart,
+                }),
+            },
+        });
         dbg(`runPipeline crash stack: ${pipelineErr.stack}`);
         if (!getFlag("no-lsp")) {
             resetLSPService({ fast: true, reason: "pipeline_crash" });
@@ -422,14 +568,57 @@ export async function handleToolResult(deps) {
             result: "pipeline_crash",
         });
         const notice = runtime.formatPipelineCrashNotice(filePath, pipelineErr);
-        if (!notice)
-            return;
         return {
-            content: [...event.content, { type: "text", text: notice }],
+            content: notice
+                ? [...event.content, { type: "text", text: notice }]
+                : event.content,
+            isError: true,
         };
     }
     finally {
-        inFlightPipelines.delete(pipelineDedupeKey);
+        // Prune the per-file inner map once it's empty so a file touched once
+        // this session doesn't leave a permanent empty entry in the outer map.
+        filePipelines.delete(initialStateHash);
+        if (filePipelines.size === 0) {
+            inFlightPipelines.delete(filePath);
+        }
+    }
+    if (!isPartialApplyResult) {
+        const postEditStatus = result.isError ? "failed" : "succeeded";
+        if (result.isError) {
+            logReadGuardEvent({
+                event: "edit_post_edit_pipeline_failed",
+                correlationId: readGuardCorrelationId,
+                filePath,
+                metadata: {
+                    tool: event.toolName,
+                    commitStatus: "committed",
+                    reasonCode: "pipeline_failed",
+                },
+            });
+        }
+        logReadGuardEvent({
+            event: "edit_batch_summary",
+            correlationId: readGuardCorrelationId,
+            filePath,
+            metadata: {
+                tool: event.toolName,
+                editBatchSummary: createReadGuardEditBatchSummary({
+                    requestedIndexes: requestedEditIndexes,
+                    requestedTotal: requestedEditTotal,
+                    resolvedIndexes: requestedEditIndexes,
+                    resolvedTotal: requestedEditTotal,
+                    appliedIndexes: requestedEditIndexes,
+                    appliedTotal: requestedEditTotal,
+                    participantIds: pipelineTelemetry.participantIds,
+                    participantTotal: pipelineTelemetry.participantTotal,
+                    commitStatus: "committed",
+                    postEditStatus,
+                    terminalStatus: postEditStatus === "failed" ? "failed" : "success",
+                    durationMs: Date.now() - toolResultStart,
+                }),
+            },
+        });
     }
     lastAnalyzedStateByFile.set(filePath, {
         turnIndex: runtime.turnIndex,
@@ -549,6 +738,13 @@ export async function handleToolResult(deps) {
     else {
         runtime.clearInlineBlockers(filePath);
     }
+    runtime.updateGitGuardStatus(result.hasBlockers, result.output);
+    if (getFlag("lens-guard")) {
+        syncGitGuardRecord(runtime, cacheManager, turnStateCwd, filePath);
+        if (result.isError && !result.hasBlockers) {
+            runtime.markGitGuardCacheUnknown("pipeline_error");
+        }
+    }
     if (result.isError) {
         return {
             content: [...event.content, { type: "text", text: result.output }],
@@ -556,7 +752,6 @@ export async function handleToolResult(deps) {
         };
     }
     let output = result.output;
-    runtime.updateGitGuardStatus(result.hasBlockers, result.output);
     if (behaviorWarnings.length > 0 && !result.hasBlockers) {
         output += `\n\n${formatBehaviorWarnings(behaviorWarnings)}`;
     }