@herbertgao/pi-extensions 2026.9.0 → 2026.9.1

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

@@ -1,10 +1,12 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
-import { loadBootstrapClients } from "./bootstrap.js";
+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";
 import { evaluateGitGuard, isGitCommitOrPushAttempt } from "./git-guard.js";
+import { dropHashlineAnchorMemo } from "./hashline-anchor.js";
 import { evaluateSharedCheckoutGuard } from "./shared-checkout-guard.js";
 import { logLatency } from "./latency-logger.js";
 import { normalizeMapKey } from "./path-utils.js";
@@ -12,6 +14,10 @@ import { captureFileStats, getOpaqueBaselineStore, isGitWorktree, } from "./opaq
 import { normalizeForGuardMatch } from "./host-edit-normalize.js";
 import { retargetReplacementIndentation } from "./indent-retarget.js";
 import { LANGUAGE_POLICY } from "./language-policy.js";
+import { isComplexitySupportedFile } from "./tree-sitter-shared.js";
+import { classifyMutatingTool, readMutationPathField, } from "./mutating-tool.js";
+import { isProvisionalLearnedAttribution } from "./mutation-attribution.js";
+import { armObservedMutation } from "./observed-mutation.js";
 import { getLSPService } from "./lsp/index.js";
 import { findDocumentSymbolAtLine, getOpenDocumentSymbols, lspSymbolKindName, qualifiedLspSymbolName, } from "./lsp-document-symbols.js";
 import { computeTrailingWhitespaceOldTextPatch, findUniqueMatchLineRange, } from "./oldtext-autopatch.js";
@@ -19,21 +25,45 @@ import { applyPartiallyApplicableEdits } from "./partial-edit-apply.js";
 import { isExternalOrVendorFile, resolveHostPathVariants, resolveHostToolPath, } from "./path-utils.js";
 import { EXPANSION_BUDGET_MS, EXPANSION_LIMIT_LINES, tryExpandRead, } from "./read-expansion.js";
 import { boundedIndexesForCount, createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent, } from "./read-guard-logger.js";
-import { countFileLines, getTouchedLinesForGuard, relocateEditRange, tryCorrectIndentationMismatch, tryCorrectIndentationMismatchFromContent, } from "./read-guard-tool-lines.js";
+import { countFileLines, formatAlreadyAppliedNotes, getTouchedLinesForGuard, relocateEditRange, tryCorrectIndentationMismatch, tryCorrectIndentationMismatchFromContent, } from "./read-guard-tool-lines.js";
 import { handleToolResult } from "./runtime-tool-result.js";
-import { isToolCallEventType, resolveToolCallCorrelationId, } from "./tool-event.js";
+import { resolveToolCallCorrelationId } from "./tool-event.js";
 import { getSharedTreeSitterClient } from "./tree-sitter-shared.js";
 const LSP_TOOLCALL_NAV_TOUCH_BUDGET_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_TOOLCALL_NAV_TOUCH_MS ??
     process.env.PI_LENS_LSP_NAV_CLIENT_WAIT_MS ??
     "1500", 10) || 1500);
 const LSP_TOOLCALL_TOUCH_BUDGET_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_TOOLCALL_TOUCH_MS ?? "750", 10) || 750);
+/**
+ * Composes the final block reason for a partial apply whose commit landed
+ * (#2402). The committed bytes lead the message; the preflight's per-edit
+ * failure bodies follow UNCHANGED, so they still describe exactly the edits
+ * that were NOT applied. The preflight header (🔄/🛑) is never reused here —
+ * relabelling committed edits as a retryable oldText miss is the #2402 defect.
+ */
+function composePartialApplyReason(args) {
+    const parts = [];
+    const editSuffix = args.appliedCount === 1 ? "" : "s";
+    parts.push(args.postEditStatus === "failed"
+        ? `⚠️ PARTIAL APPLY — ${args.appliedCount} edit${editSuffix} committed (${args.appliedIndices}). Post-edit analysis failed after the commit; the committed bytes stand and were not reverted. Do NOT resubmit the applied edits.`
+        : `⚠️ PARTIAL APPLY — ${args.appliedCount} edit${editSuffix} committed (${args.appliedIndices}). Do NOT resubmit the applied edits.`);
+    if (args.preflightDetails && args.preflightDetails.length > 0) {
+        parts.push(args.preflightDetails.join("\n\n"));
+    }
+    const alreadyNotes = formatAlreadyAppliedNotes(args.alreadyAppliedEdits);
+    if (alreadyNotes)
+        parts.push(alreadyNotes.trimStart());
+    if (args.postEditOutput && args.postEditStatus === "succeeded") {
+        parts.push(`Post-apply analysis:\n${args.postEditOutput}`);
+    }
+    return parts.join("\n\n");
+}
 function getToolCallRawFilePath(toolName, event) {
     const inputObj = (event.input ?? {});
-    if (isToolCallEventType("write", event) ||
-        isToolCallEventType("edit", event)) {
-        const filePath = event.input.path;
-        return typeof filePath === "string" ? filePath : undefined;
-    }
+    // #2423: the seam owns "does this tool target a file it mutates". No ctx is
+    // passed — the path is not resolved yet, so adapters must not log here.
+    const mutation = classifyMutatingTool({ ...event, toolName });
+    if (mutation)
+        return mutation.path;
     if (toolName === "read") {
         if (typeof inputObj.path === "string")
             return inputObj.path;
@@ -163,11 +193,12 @@ function isIndentationOnlyChange(before, after) {
     return beforeLines.every((line, index) => line.trim() === afterLines[index].trim());
 }
 function getNewContentFromToolCall(event) {
-    if (isToolCallEventType("write", event)) {
+    const mutation = classifyMutatingTool(event);
+    if (mutation?.kind === "write") {
         return event.input
             .content;
     }
-    if (isToolCallEventType("edit", event)) {
+    if (mutation?.kind === "edit") {
         const edits = event.input.edits;
         return edits?.map((edit) => edit.newText ?? "").join("\n");
     }
@@ -274,10 +305,20 @@ export async function handleToolCall(deps) {
 }
 async function handleToolCallImpl(deps) {
     const { event, ctx, lensEnabled, getFlag, dbg, runtime, cacheManager, ensureLSPConfigInitialized, updateLspStatus, resetLSPService, getTreeSitterClient = getSharedTreeSitterClient, } = deps;
+    // #2423 review round 4, finding F5: the hashline anchor memo is keyed by
+    // mtime+size, which a same-size rewrite inside one mtime tick cannot
+    // distinguish from stale content. It only ever needs to survive the
+    // several `classifyMutatingTool` asks WITHIN this one tool_call, so drop
+    // it here at the boundary rather than trusting mtime+size across calls.
+    dropHashlineAnchorMemo();
     const readGuardCorrelationId = getReadGuardCorrelationId(event);
     let filePath;
     const logToolReadGuardEvent = (entry) => logReadGuardEvent({ ...entry, correlationId: readGuardCorrelationId });
     const toolName = event.toolName ?? "";
+    // #2423: one classification per tool_call, reused by every branch below that
+    // used to compare `toolName` to the `"write"` / `"edit"` literals. No ctx —
+    // `filePath` is not resolved yet, and adapters stay silent without one.
+    const mutation = classifyMutatingTool(event);
     const editInputForTelemetry = event.input;
     // #1655 item 3: SNAPSHOT the requested batch width here, at handler entry.
     // `input` is a live, mutable, extension-ordered object — pi types it
@@ -291,12 +332,12 @@ async function handleToolCallImpl(deps) {
     // object hundreds of lines and several `await`s later, so a batch that
     // changed width in between produced an internally inconsistent summary —
     // indexes from the call-time array, totals from the mutated one.
-    const requestedEditIndexes = toolName === "write"
+    const requestedEditIndexes = mutation?.kind === "write"
         ? [0]
         : Array.isArray(editInputForTelemetry?.edits)
             ? boundedIndexesForCount(editInputForTelemetry.edits.length)
             : [0];
-    const requestedEditTotal = toolName === "write"
+    const requestedEditTotal = mutation?.kind === "write"
         ? 1
         : Array.isArray(editInputForTelemetry?.edits)
             ? editInputForTelemetry.edits.length
@@ -374,6 +415,46 @@ async function handleToolCallImpl(deps) {
             }
         }
     }
+    // #2430: the observational net. A call the seam could NOT classify, whose
+    // input still names a file, gets a bounded pre-snapshot so the tool_result
+    // side can see whether it actually wrote anything. `bash` is excluded
+    // because it already has its own (wider, git-first) baseline above, and a
+    // classified mutation never reaches here at all — that is what keeps the
+    // cost of a plain write/edit at zero.
+    //
+    // `isProvisionalLearnedAttribution` is the ONE exception (#2449 review round
+    // 2, F2): a tool attributed from a single observation IS classified from
+    // here on, but its attribution has not earned persistence yet, and the only
+    // thing that can earn it is a second real disk diff. Without this clause the
+    // tool is classified on call two and never observed again, so
+    // `PERSIST_AFTER_OBSERVATIONS = 2` is unreachable and nothing is ever
+    // written to disk for the next session to learn from.
+    //
+    // The eligibility check inside `armObservedMutation` is a map lookup, so an
+    // ineligible tool (durably attributed, or twice observed clean) pays that
+    // and nothing else. The universe is the TARGET PATH alone, so an armed call
+    // costs one stat plus one hash of the file it named — not a directory walk.
+    if ((mutation === undefined || isProvisionalLearnedAttribution(toolName)) &&
+        toolName !== "bash" &&
+        !getFlag("no-read-guard")) {
+        const observedRawPath = readMutationPathField(event);
+        const observedPath = observedRawPath
+            ? resolveToolCallFilePath(observedRawPath, ctx.cwd, runtime.projectRoot)
+                ?.path
+            : undefined;
+        if (observedPath) {
+            await armObservedMutation({
+                toolCallId: resolveToolCallCorrelationId(event),
+                toolName,
+                targetPath: observedPath,
+                cwd: ctx.cwd ?? runtime.projectRoot,
+                sessionGeneration: runtime.sessionGeneration,
+                turnIndex: runtime.turnIndex,
+                signal: ctx.signal,
+                dbg,
+            });
+        }
+    }
     if (getFlag("lens-guard") &&
         isGitCommitOrPushAttempt(toolName, event.input)) {
         const guard = evaluateGitGuard(runtime, cacheManager, ctx.cwd ?? runtime.projectRoot);
@@ -419,7 +500,7 @@ async function handleToolCallImpl(deps) {
         return;
     dbg(`tool_call fired for: ${filePath} (exists: ${nodeFs.existsSync(filePath)})`);
     const toolCallId = resolveToolCallCorrelationId(event);
-    const attributesMutationTarget = toolCallId !== undefined && (toolName === "write" || toolName === "edit");
+    const attributesMutationTarget = toolCallId !== undefined && mutation !== undefined;
     const targetMissing = !nodeFs.existsSync(filePath);
     // #1642 F1: a brand-new file's WRITE is never a "skip" — `tool_call`
     // fires PRE-execution, so `existsSync` is false for every path a write
@@ -457,7 +538,7 @@ async function handleToolCallImpl(deps) {
         // those paths have no quote and no AM/PM, so every stage-2 candidate
         // collapses onto the base path and nothing is "tried". `unresolved` is
         // the whole condition; the tried list is detail for the reason string.
-        if (toolName !== "write" && pathResolution?.unresolved) {
+        if (mutation?.kind !== "write" && pathResolution?.unresolved) {
             const tried = pathResolution.triedVariants.length > 0
                 ? `tried ${pathResolution.triedVariants.join(", ")}`
                 : "no variant differed from the resolved path";
@@ -480,8 +561,7 @@ async function handleToolCallImpl(deps) {
     const shouldWarmReadLsp = toolName === "read" &&
         lspAutoTouchEligible &&
         runtime.shouldWarmLspOnRead(filePath);
-    const shouldAutoTouch = (toolName === "write" ||
-        toolName === "edit" ||
+    const shouldAutoTouch = (mutation !== undefined ||
         toolName === "lsp_navigation" ||
         shouldWarmReadLsp) &&
         !getFlag("no-lsp") &&
@@ -675,13 +755,41 @@ async function handleToolCallImpl(deps) {
             timestamp: Date.now(),
         });
     }
-    const { complexityClient } = await loadBootstrapClients();
     // Record complexity baseline for historical tracking (booboo/tdi).
     // Not shown inline - just captured for delta analysis.
+    //
+    // #2467: every client-free guard runs FIRST, so a tool call that cannot
+    // produce a baseline never loads the analyzer graph. This await used to sit
+    // above them and fire on EVERY tool_call — a bash command, a grep, a read
+    // of a vendored file, a second read of an already-baselined file all paid
+    // the seventeen-module load.
+    //
+    // `isComplexitySupportedFile` is the LAST of those guards and the one that
+    // matters most in a real repo: complexity has node mappings for six
+    // grammars, so every .md/.json/.yaml/.css/.java/.sh read is unsupported.
+    // Asking the CLIENT (`isSupportedFile`) would mean loading the graph to
+    // learn the answer is no — and because only a produced baseline memoizes
+    // the file, the same read would pay it again on every repeat. The predicate
+    // is the client's own answer, hoisted into `tree-sitter-shared.ts` where it
+    // needs nothing but the extension registry; `ComplexityClient.isSupportedFile`
+    // delegates to it, so this is not a second copy.
     if (!isExternalOrVendor &&
-        complexityClient.isSupportedFile(filePath) &&
-        !runtime.complexityBaselines.has(filePath)) {
-        const baseline = await complexityClient.analyzeFile(filePath);
+        filePath &&
+        !runtime.complexityBaselines.has(filePath) &&
+        isComplexitySupportedFile(filePath)) {
+        // Fail open: no clients means no baseline for this call, counted once in
+        // the ledger. A complexity baseline is delta-analysis bookkeeping — it
+        // must never be the reason a user's tool call fails or stalls.
+        const complexityClient = (await requestBootstrapClients({
+            reason: "tool-call-complexity-baseline",
+            // The pre-dispatch hook. It carries no wall budget in #2523's
+            // contract, which is why `LedgerHookKey` names it alongside the
+            // budgeted families rather than leaving this site to spell its
+            // own axis value (#2557 review F7).
+            hook: "tool_call",
+            signal: getAmbientAbortSignal(),
+        }))?.complexityClient;
+        const baseline = await complexityClient?.analyzeFile(filePath);
         if (baseline) {
             runtime.complexityBaselines.set(filePath, baseline);
             const { captureSnapshot } = await import("./metrics-history.js");
@@ -698,8 +806,8 @@ async function handleToolCallImpl(deps) {
     // --- Read-Before-Edit Guard: check edits ---
     // write = full replacement; no prior read needed (you're starting fresh).
     // edit = partial modification; guard enforced to prevent blind overwrites.
-    const isEditOnly = isToolCallEventType("edit", event);
-    const isWriteOrEdit = isToolCallEventType("write", event) || isEditOnly;
+    const isEditOnly = mutation?.kind === "edit";
+    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")) {
@@ -912,7 +1020,7 @@ async function handleToolCallImpl(deps) {
         const isExistingFile = typeof readGuard?.isNewFile !== "function" ||
             !readGuard.isNewFile(filePath);
         if (readGuard && isExistingFile && !isExternalOrVendor) {
-            const { touchedLines, editRanges, preflightError, partiallyApplicable, contentMatchValidated, editBatchSummary, } = getTouchedLinesForGuard(event, filePath, runtime.telemetrySessionId, readGuardCorrelationId);
+            const { touchedLines, editRanges, preflightError, preflightDetails, alreadyAppliedEdits, partiallyApplicable, contentMatchValidated, editBatchSummary, } = getTouchedLinesForGuard(event, filePath, runtime.telemetrySessionId, readGuardCorrelationId, runtime.partialApplyRecords);
             if (preflightError) {
                 if (partiallyApplicable && partiallyApplicable.length > 0) {
                     try {
@@ -921,6 +1029,7 @@ async function handleToolCallImpl(deps) {
                             edits: partiallyApplicable,
                             summary: editBatchSummary,
                             correlationId: readGuardCorrelationId,
+                            recordStore: runtime.partialApplyRecords,
                             afterWrite: async () => {
                                 const { biomeClient, ruffClient, metricsClient, agentBehaviorClient, } = await loadBootstrapClients();
                                 const result = await handleToolResult({
@@ -962,10 +1071,32 @@ async function handleToolCallImpl(deps) {
                                     .join("\n\n");
                             },
                         });
+                        if (partial.rejected) {
+                            // Nothing was written and no post-edit dispatch ran. The
+                            // preflight verdict still describes the whole batch; append
+                            // the structured rejection so the agent rebuilds from a
+                            // fresh read instead of retrying the stale payload.
+                            if (!editBatchSummary)
+                                logBlockedEditSummary("preflight");
+                            return {
+                                block: true,
+                                reason: `${preflightError}\n\n🛑 Batch not applied: ${partial.rejected.detail}`,
+                            };
+                        }
                         if (partial.postEditStatus === "failed") {
+                            // The commit stands; the post-edit analysis does not. The
+                            // committed bytes must never be re-labelled by the preflight
+                            // header (a RETRYABLE/RE-READ line here sends the agent into
+                            // the #2402 retry loop against already-applied edits).
                             return {
                                 block: true,
-                                reason: `${preflightError}\n\nPartial apply pipeline failed after ${partial.appliedCount} edit${partial.appliedCount === 1 ? "" : "s"} committed.`,
+                                reason: composePartialApplyReason({
+                                    appliedCount: partial.appliedCount,
+                                    appliedIndices: partial.appliedIndices,
+                                    postEditStatus: "failed",
+                                    preflightDetails,
+                                    alreadyAppliedEdits,
+                                }),
                             };
                         }
                         if (partial.appliedCount > 0) {
@@ -977,23 +1108,25 @@ async function handleToolCallImpl(deps) {
                                     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,
                                 },
                             });
-                            let reason = preflightError.replace("🔄 RETRYABLE — Edit target not found", `⚠️ PARTIAL APPLY — ${partial.appliedCount} edit${partial.appliedCount !== 1 ? "s" : ""} applied (${partial.appliedIndices})`);
-                            if (partial.postEditOutput) {
-                                reason += `\n\nPost-apply analysis:\n${partial.postEditOutput}`;
-                            }
-                            return { block: true, reason };
+                            return {
+                                block: true,
+                                reason: composePartialApplyReason({
+                                    appliedCount: partial.appliedCount,
+                                    appliedIndices: partial.appliedIndices,
+                                    postEditStatus: "succeeded",
+                                    postEditOutput: partial.postEditOutput,
+                                    preflightDetails,
+                                    alreadyAppliedEdits,
+                                }),
+                            };
                         }
                     }
                     catch {
-                        // fall through to full block
+                        // commit write failure — fall through to the full preflight block
                     }
                 }
                 if (!editBatchSummary)
@@ -1005,7 +1138,7 @@ async function handleToolCallImpl(deps) {
                 sessionId: runtime.telemetrySessionId,
                 filePath,
                 metadata: {
-                    tool: isToolCallEventType("write", event) ? "write" : "edit",
+                    tool: mutation?.kind ?? "edit",
                     touchedLines: touchedLines ?? null,
                     isExistingFile,
                 },