@herbertgao/pi-extensions 2026.9.6 → 2026.9.8

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

@@ -1,7 +1,6 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import { loadBootstrapClients, requestBootstrapClients } from "./bootstrap.js";
-import { getAmbientAbortSignal } from "./safe-spawn.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
 import { detectFileKind } from "./file-kinds.js";
 import { isPathIgnoredByProject } from "./file-utils.js";
@@ -457,7 +456,7 @@ async function handleToolCallImpl(deps) {
     }
     if (getFlag("lens-guard") &&
         isGitCommitOrPushAttempt(toolName, event.input)) {
-        const guard = evaluateGitGuard(runtime, cacheManager, ctx.cwd ?? runtime.projectRoot);
+        const guard = evaluateGitGuard(runtime, cacheManager, ctx.cwd ?? runtime.projectRoot, ctx.host ?? "pi");
         if (guard.block) {
             return {
                 block: true,
@@ -633,7 +632,6 @@ async function handleToolCallImpl(deps) {
     // For partial reads (small limit, not from line 1), find the enclosing
     // symbol and expand the read range to cover it. This gives the read guard
     // accurate symbol-level coverage without requiring an LSP server.
-    let expandedByLsp = false;
     let enclosingSymbol;
     const readExpansionClient = toolName === "read" &&
         !getFlag("no-lsp") &&
@@ -658,7 +656,6 @@ async function handleToolCallImpl(deps) {
                 readInput.limit = expansion.newLimit;
                 effectiveReadOffset = expansion.newOffset;
                 effectiveReadLimit = expansion.newLimit;
-                expandedByLsp = true;
                 let enriched = false;
                 let enrichedAncestry = expansion.ancestry;
                 const lspSymbols = await getOpenDocumentSymbols(filePath);
@@ -720,7 +717,10 @@ async function handleToolCallImpl(deps) {
             // Best-effort only.
         }
     }
-    // --- Read-Before-Edit Guard: record reads ---
+    // Register the host-resolved path at tool_call. This path is load-bearing for
+    // the read guard and the observed-mutation settled sweep, including under
+    // --no-read-guard. The paired tool_result adds the authoritative delivered
+    // range after the host applies EOF and output-cap clipping (#2802 probe 3).
     if (toolName === "read" && filePath && !isExternalOrVendor) {
         const totalLines = countFileLines(filePath);
         const deliveredLimit = effectiveReadLimit ?? 1;
@@ -739,7 +739,7 @@ async function handleToolCallImpl(deps) {
                 fractionRead: totalLines > 0
                     ? Math.round((deliveredLimit / totalLines) * 100) / 100
                     : 1,
-                expandedByTs: expandedByLsp,
+                expandedByTs: enclosingSymbol !== undefined,
             },
         });
         runtime.readGuard.recordRead({
@@ -748,11 +748,15 @@ async function handleToolCallImpl(deps) {
             requestedLimit: requestedReadLimit ?? deliveredLimit,
             effectiveOffset: effectiveReadOffset,
             effectiveLimit: deliveredLimit,
-            expandedByLsp,
-            enclosingSymbol,
+            expandedByLsp: enclosingSymbol !== undefined,
+            ...(enclosingSymbol !== undefined && { enclosingSymbol }),
             turnIndex: runtime.turnIndex,
             writeIndex: runtime.peekWriteIndex(),
             timestamp: Date.now(),
+            provisional: true,
+            ...(resolveToolCallCorrelationId(event) !== undefined && {
+                source: `native-read:${resolveToolCallCorrelationId(event)}:provisional`,
+            }),
         });
     }
     // Record complexity baseline for historical tracking (booboo/tdi).
@@ -788,7 +792,10 @@ async function handleToolCallImpl(deps) {
             // budgeted families rather than leaving this site to spell its
             // own axis value (#2557 review F7).
             hook: "tool_call",
-            signal: getAmbientAbortSignal(),
+            // The ambient slot is populated by tool_result, after this hook has
+            // already run. Use the live tool_call signal so Escape can release
+            // this await (#2523 AC4).
+            signal: deps.ctx.signal,
         }))?.complexityClient;
         const baseline = await complexityClient?.analyzeFile(filePath);
         if (baseline) {
@@ -820,7 +827,11 @@ async function handleToolCallImpl(deps) {
     const isWriteOrEdit = mutation !== undefined;
     // Track any Write so recordWritten can inject a synthetic read afterward.
     // The agent authored the content (new or overwritten), so it trivially "knows" the file.
-    if (!isEditOnly && isWriteOrEdit && filePath && !getFlag("no-read-guard")) {
+    if (!isEditOnly &&
+        isWriteOrEdit &&
+        event.toolName !== "bash" &&
+        filePath &&
+        !getFlag("no-read-guard")) {
         runtime.readGuard.noteCreatedFile(filePath, runtime.turnIndex, runtime.peekWriteIndex());
     }
     // --- Indentation mismatch correction ---
@@ -985,8 +996,27 @@ async function handleToolCallImpl(deps) {
                 entry.currentMatchCount === 0 &&
                 entry.correctedMatchCount === 1) {
                 entry.apply(entry.corrected);
+                // The same unique-match span the synthetic-read bridge below
+                // resolves, computed once and reused: it also anchors the
+                // interior-mask lexer to the real file (#3116 review round 2,
+                // F1) so a template literal the oldText fragment crosses the
+                // boundary of is read correctly instead of ambiguously — a
+                // fragment-only lexer can misread which side of a boundary a
+                // line falls on when the fragment doesn't carry the opener or
+                // closer that resolves it. Falls back to fragment-only masking
+                // inside retargetReplacementIndentation when no unique span is
+                // found (file unreadable, or the corrected text isn't unique in
+                // the host's fuzzy-match space).
+                const matchedRange = matchNormalizedContent !== undefined
+                    ? findUniqueMatchLineRange(matchNormalizedContent, entry.corrected)
+                    : undefined;
                 const correctedNewText = entry.newText
-                    ? retargetReplacementIndentation(entry.newText, entry.value, entry.corrected)
+                    ? retargetReplacementIndentation(entry.newText, entry.value, entry.corrected, matchNormalizedContent !== undefined && matchedRange
+                        ? {
+                            content: matchNormalizedContent,
+                            startLine: matchedRange.startLine,
+                        }
+                        : undefined)
                     : undefined;
                 if (correctedNewText !== undefined) {
                     entry.applyNewText(correctedNewText);
@@ -1007,7 +1037,7 @@ async function handleToolCallImpl(deps) {
                 // for the matched range so a zero_read block downstream isn't
                 // thrown after the autopatch already verified the content.
                 if (matchNormalizedContent !== undefined && runtime.readGuard) {
-                    const range = findUniqueMatchLineRange(matchNormalizedContent, entry.corrected);
+                    const range = matchedRange;
                     if (range) {
                         runtime.readGuard.recordRead({
                             filePath,
@@ -1043,6 +1073,7 @@ async function handleToolCallImpl(deps) {
                             afterWrite: async () => {
                                 const { biomeClient, ruffClient, metricsClient, agentBehaviorClient, } = await loadBootstrapClients();
                                 const result = await handleToolResult({
+                                    signal: deps.ctx.signal,
                                     event: {
                                         toolName: "write",
                                         input: { path: filePath },