@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

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

@@ -16,6 +16,8 @@ import { runPipeline } from "./pipeline.js";
 import { appendProjectChange, } from "./project-changes.js";
 import { syncGitGuardRecord } from "./git-guard.js";
 import { scheduleWordIndexPersist } from "./word-index.js";
+import { RUNTIME_CONFIG } from "./runtime-config.js";
+const AUTHORITATIVE_CONTENT_MAX_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 function parseDiffRanges(diff) {
     const changedLines = [];
     for (const line of diff.split("\n")) {
@@ -207,6 +209,8 @@ export async function handleToolResult(deps) {
             : path.resolve(workspaceRoot, rawFilePath)
         : rawFilePath;
     const behaviorWarnings = agentBehaviorRecord(event.toolName, filePath);
+    const syntheticWriteContent = [];
+    let syntheticAttachmentBytes = 0;
     // Bash writes (redirects, tee, sed -i, cp/mv, touch, git checkout/restore) —
     // these change file content but never go through the edit tool, so bash
     // early-returns before the dispatch pipeline below. For each in-project file
@@ -224,11 +228,59 @@ export async function handleToolResult(deps) {
         for (const wp of written) {
             if (!getFlag("no-read-guard"))
                 deps.readGuard?.recordWritten(wp);
-            await handleToolResult({
+            const receipt = runtime.recordMutationToolReceipt;
+            const autofixMode = receipt
+                ? receipt.call(runtime, wp, "write").autofixMode
+                : "immediate";
+            const syntheticResult = await handleToolResult({
                 ...deps,
                 event: { ...event, toolName: "write", input: { path: wp } },
                 _bypassDebounce: true,
+                _autofixMode: autofixMode,
             });
+            if (syntheticResult) {
+                // The per-attachment cap bounds each file, but a multi-file bash
+                // write (`sed -i` over globs, `;`-chained rewrites) appends one
+                // attachment per path — share ONE authoritative-content budget
+                // across the whole command so the aggregate tool result stays
+                // bounded too. Past the budget, degrade to the re-read warning.
+                for (const block of syntheticResult.content.slice(event.content.length)) {
+                    const blockBytes = typeof block.text === "string"
+                        ? Buffer.byteLength(block.text, "utf-8")
+                        : 0;
+                    const isAuthoritativeAttachment = typeof block.text === "string" &&
+                        block.text.startsWith("pi-lens applied autofix to ");
+                    if (isAuthoritativeAttachment &&
+                        syntheticAttachmentBytes + blockBytes >
+                            AUTHORITATIVE_CONTENT_MAX_BYTES) {
+                        // S3e (#1432 review): this is the SECOND
+                        // `authoritative_content_attachment_decision` row for `wp` —
+                        // the synthetic `handleToolResult` call above already logged
+                        // an "attached" row for the same path under its per-file
+                        // cap. This outer, aggregate-budget row is logged later and
+                        // is the one that matches what the caller actually sees
+                        // (the re-read warning below, not the attachment), so it
+                        // wins for `wp`; the inner "attached" row is a stale
+                        // per-file view superseded by this shared-budget decision.
+                        logLatency({
+                            type: "phase",
+                            phase: "authoritative_content_attachment_decision",
+                            filePath: wp,
+                            durationMs: 0,
+                            metadata: { path: wp, bytes: blockBytes, decision: "aggregate-budget-degraded" },
+                        });
+                        syntheticWriteContent.push({
+                            type: "text",
+                            text: `⚠️ **File was modified by auto-format/fix. You MUST re-read ${wp} before making any further edits — the aggregate authoritative content for this command is too large to attach.**`,
+                        });
+                        continue;
+                    }
+                    if (isAuthoritativeAttachment) {
+                        syntheticAttachmentBytes += blockBytes;
+                    }
+                    syntheticWriteContent.push(block);
+                }
+            }
         }
         if (event.isError !== true && !getFlag("no-read-guard")) {
             for (const span of extractReadPathsFromCommand(command, workspaceRoot)) {
@@ -277,7 +329,9 @@ export async function handleToolResult(deps) {
     }
     if (event.toolName !== "write" && event.toolName !== "edit") {
         dbg(`tool_result: skipped turn tracking - toolName="${event.toolName}" (not write/edit)`);
-        return;
+        return syntheticWriteContent.length > 0
+            ? { content: [...event.content, ...syntheticWriteContent] }
+            : undefined;
     }
     if (!filePath) {
         dbg(`tool_result: skipped turn tracking - no filePath for toolName="${event.toolName}"`);
@@ -324,6 +378,16 @@ export async function handleToolResult(deps) {
         });
         return { content: event.content, isError: true };
     }
+    // Must happen before debounce admission: latestDeps intentionally retains only
+    // the latest event, but write -> edit is a sticky turn transition.
+    const receipt = runtime.recordMutationToolReceipt;
+    const autofixMode = deps._bypassDebounce
+        ? (deps._autofixMode ?? (event.toolName === "edit" ? "deferred" : "immediate"))
+        : receipt
+            ? receipt.call(runtime, filePath, event.toolName).autofixMode
+            : event.toolName === "edit"
+                ? "deferred"
+                : "immediate";
     // 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.
@@ -332,6 +396,7 @@ export async function handleToolResult(deps) {
         if (debounceMs > 0) {
             return scheduleDebounced(filePath, debounceMs, {
                 ...deps,
+                _autofixMode: autofixMode,
                 _telemetryParticipantIds: [readGuardCorrelationId],
                 _telemetryParticipantTotal: 1,
             });
@@ -469,12 +534,15 @@ export async function handleToolResult(deps) {
         cwd: dispatchCwd,
         projectRoot: turnStateCwd,
         toolName: event.toolName,
+        autofixMode,
         modifiedRanges,
         telemetry: {
             model: runtime.telemetryModel,
             sessionId: runtime.telemetrySessionId,
             turnIndex: runtime.turnIndex,
             writeIndex,
+            modelId: runtime.telemetryModelId,
+            provider: runtime.telemetryProviderId,
         },
         getFlag,
         getFlagSource,
@@ -638,11 +706,19 @@ export async function handleToolResult(deps) {
             }
         }
     }
+    let autofixNewlyQueued = false;
+    if (!result.isError && autofixMode === "deferred" && nodeFs.existsSync(filePath)) {
+        autofixNewlyQueued =
+            runtime.deferMutation?.call(runtime, filePath, dispatchCwd, event.toolName, turnStateCwd, "autofix", deps.sessionId) ?? false;
+        dbg(`tool_result: queued deferred autofix for ${filePath}`);
+    }
+    let formatQueued = false;
     if (!result.isError &&
         !getFlag("no-autoformat", filePath) &&
-        !getFlag("immediate-format") &&
+        (autofixMode === "deferred" || !getFlag("immediate-format")) &&
         nodeFs.existsSync(filePath)) {
         const isNewlyQueued = runtime.deferFormat(filePath, dispatchCwd, event.toolName, turnStateCwd, deps.sessionId);
+        formatQueued = true;
         dbg(`tool_result: queued deferred format for ${filePath}`);
         logLatency({
             type: "phase",
@@ -652,19 +728,21 @@ export async function handleToolResult(deps) {
             durationMs: 0,
             metadata: { cwd: dispatchCwd },
         });
-        // #673: only publish on first queue entry — a re-touch of an already
-        // queued file (a second edit before agent_end) is a structural no-op
-        // for a listener that just wants to know "has this file entered the
-        // queue", so re-emitting would be spam with zero new information.
-        if (isNewlyQueued) {
+        // Publish a file's first queue entry and each newly added kind. A same-kind
+        // re-touch before agent_end carries no new information and stays silent.
+        if (isNewlyQueued || autofixNewlyQueued) {
             publishFormatQueued({
                 filePath,
                 cwd: dispatchCwd,
                 tool: event.toolName,
                 dbg,
+                kinds: autofixMode === "deferred" ? ["autofix", "format"] : ["format"],
             });
         }
     }
+    if (autofixNewlyQueued && !formatQueued) {
+        publishFormatQueued({ filePath, cwd: dispatchCwd, tool: event.toolName, kinds: ["autofix"], dbg });
+    }
     for (const changedFile of result.changedFiles ?? []) {
         const resolvedChanged = path.resolve(changedFile);
         if (!nodeFs.existsSync(resolvedChanged))
@@ -764,9 +842,45 @@ export async function handleToolResult(deps) {
         result: output ? "completed" : "no_output",
     });
     runtime.reportedThisTurn.add(filePath);
-    if (!output)
+    const postMutation = result.postMutation;
+    const attachAuthoritativeContent = postMutation !== undefined &&
+        Buffer.byteLength(postMutation.content, "utf-8") <= AUTHORITATIVE_CONTENT_MAX_BYTES;
+    if (postMutation) {
+        const bytes = Buffer.byteLength(postMutation.content, "utf-8");
+        // S3e (#1432 review): when this call is the synthetic per-file
+        // `handleToolResult` recursion a multi-file bash write drives (see the
+        // bash branch above), the OUTER aggregate-budget loop may log a SECOND
+        // `authoritative_content_attachment_decision` row for this same
+        // `filePath` right after this one, downgrading an "attached" here to
+        // "aggregate-budget-degraded" once the shared budget is exhausted.
+        // Both rows are intentional (this one reflects the per-file cap
+        // decision; the outer one reflects the aggregate-budget decision that
+        // can override it) — the outer row, logged later, wins for that path.
+        logLatency({
+            type: "phase",
+            phase: "authoritative_content_attachment_decision",
+            filePath: postMutation.filePath,
+            durationMs: 0,
+            metadata: { path: postMutation.filePath, bytes, decision: attachAuthoritativeContent ? "attached" : "size-capped" },
+        });
+    }
+    const returnedContent = attachAuthoritativeContent
+        ? [
+            ...event.content,
+            {
+                type: "text",
+                text: `pi-lens applied autofix to ${postMutation.filePath}. The following full content is authoritative for subsequent edits:\n\n${postMutation.content}`,
+            },
+        ]
+        : event.content;
+    if (postMutation && !attachAuthoritativeContent) {
+        output = `${output ? `${output}\n\n` : ""}⚠️ **File was modified by auto-format/fix. You MUST re-read ${postMutation.filePath} before making any further edits — the authoritative content is too large to attach.**`;
+    }
+    if (!output && !result.postMutation)
         return;
     return {
-        content: [...event.content, { type: "text", text: output }],
+        content: output
+            ? [...returnedContent, { type: "text", text: output }]
+            : returnedContent,
     };
 }