@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

package/node_modules/pi-lens/dist/clients/mcp/session.js

@@ -25,25 +25,38 @@ import { CacheManager, MCP_TURN_STATE_OWNER_ID, } from "../cache-manager.js";
 import { resetDispatchBaselines } from "../dispatch/integration.js";
 import { resetFormatService } from "../format-service.js";
 import { getLSPService, resetLSPService } from "../lsp/index.js";
-import { consumeSessionStartGuidance, consumeTestFindings, consumeTurnEndFindings, peekTestFindings, peekTurnEndFindings, } from "../runtime-context.js";
+import { acknowledgeTestFindings, acknowledgeTurnEndFindings, consumeSessionStartGuidance, consumeTestFindings, consumeTurnEndFindings, peekTestFindings, peekTurnEndFindings, } from "../runtime-context.js";
 import { RuntimeCoordinator } from "../runtime-coordinator.js";
 import { handleSessionStart } from "../runtime-session.js";
 import { handleTurnEnd } from "../runtime-turn.js";
 import { createMcpHost } from "./host-shim.js";
 let contextPromise;
+let resolvedRuntime;
 /** Lazily build (once) the persistent session context shared across MCP calls. */
 export function getMcpSessionContext() {
-    contextPromise ??= (async () => ({
-        runtime: new RuntimeCoordinator(),
-        cacheManager: new CacheManager(),
-        astGrepClient: new AstGrepClient(),
-        clients: await loadBootstrapClients(),
-    }))();
+    contextPromise ??= (async () => {
+        const context = {
+            runtime: new RuntimeCoordinator(),
+            cacheManager: new CacheManager(),
+            astGrepClient: new AstGrepClient(),
+            clients: await loadBootstrapClients(),
+        };
+        resolvedRuntime = context.runtime;
+        return context;
+    })();
     return contextPromise;
 }
+/** Synchronous peek at the session runtime, for construction sites that cannot
+ * await (e.g. the MCP server's tool wiring). Returns undefined until a session
+ * context has actually been built — advisory validation then honestly skips
+ * the session-identity check instead of comparing against a phantom session. */
+export function peekMcpSessionRuntime() {
+    return resolvedRuntime;
+}
 /** Test hook — drop the cached context so a fresh one is built next call. */
 export function _resetMcpSessionContext() {
     contextPromise = undefined;
+    resolvedRuntime = undefined;
 }
 const noop = () => { };
 function joinMessages(consumed) {
@@ -219,13 +232,13 @@ async function runTurnEndNow(cwd, files = [], deferredDelivery = false) {
     });
     const outcome = deferredDelivery
         ? {
-            turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd)),
-            tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd)),
+            turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
+            tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
             filesRegistered: registered,
         }
         : {
-            turnEnd: joinMessages(consumeTurnEndFindings(ctx.cacheManager, cwd)),
-            tests: joinMessages(consumeTestFindings(ctx.cacheManager, cwd)),
+            turnEnd: joinMessages(consumeTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime)),
+            tests: joinMessages(consumeTestFindings(ctx.cacheManager, cwd, ctx.runtime)),
             filesRegistered: registered,
         };
     return {
@@ -233,8 +246,8 @@ async function runTurnEndNow(cwd, files = [], deferredDelivery = false) {
         commit: () => {
             if (!deferredDelivery)
                 return;
-            consumeTurnEndFindings(ctx.cacheManager, cwd);
-            consumeTestFindings(ctx.cacheManager, cwd);
+            acknowledgeTurnEndFindings(ctx.cacheManager, cwd);
+            acknowledgeTestFindings(ctx.cacheManager, cwd);
         },
     };
 }
@@ -306,16 +319,16 @@ function runTurnEndForIpcNow(cwd) {
         }
         const ctx = await getMcpSessionContext();
         const cachedOutcome = {
-            turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd)),
-            tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd)),
+            turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
+            tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
             filesRegistered: 0,
         };
         const transaction = hasTurnEndFindings(cachedOutcome)
             ? {
                 outcome: cachedOutcome,
                 commit: () => {
-                    consumeTurnEndFindings(ctx.cacheManager, cwd);
-                    consumeTestFindings(ctx.cacheManager, cwd);
+                    acknowledgeTurnEndFindings(ctx.cacheManager, cwd);
+                    acknowledgeTestFindings(ctx.cacheManager, cwd);
                 },
             }
             : await runTurnEndNow(cwd, [], true);

package/node_modules/pi-lens/dist/clients/model-provider.js

@@ -0,0 +1,53 @@
+/**
+ * Provider derivation for worklog/disposition attribution (#1448).
+ *
+ * The host reports `provider` and `model` as separate fields on its telemetry
+ * events (see `updateRuntimeIdentityFromEvent` in index.ts and the
+ * `tool_result` handler in clients/runtime-tool-result.ts) MOST of the time —
+ * so the common case needs no parsing at all. This parser exists only for the
+ * fallback: a model id supplied without an explicit provider.
+ *
+ * Derivation rule (conservative — returns "" rather than guess):
+ *   1. A single `/` or `:` separator splits the id into `<provider>/<rest>`
+ *      or `<provider>:<rest>` — e.g. "anthropic/claude-sonnet-4-5",
+ *      "openai:gpt-5". The left segment is lowercased and returned AS-IS
+ *      (no allowlist check) since an explicit separator is deliberate host
+ *      structure, not a guess.
+ *   2. No separator: match a known model-id PREFIX against a small table of
+ *      vendor naming conventions (claude- -> anthropic; gpt-, o1-, o3- ->
+ *      openai; gemini- -> google; llama- -> meta; mistral-, mixtral- ->
+ *      mistral; command- -> cohere). First match wins.
+ *   3. Anything else (unrecognized prefix, multiple separators, empty
+ *      string) is ambiguous -> "".
+ */
+const KNOWN_PREFIXES = [
+    ["claude-", "anthropic"],
+    ["gpt-", "openai"],
+    ["o1-", "openai"],
+    ["o3-", "openai"],
+    ["gemini-", "google"],
+    ["llama-", "meta"],
+    ["mistral-", "mistral"],
+    ["mixtral-", "mistral"],
+    ["command-", "cohere"],
+];
+export function deriveProviderFromModelId(modelId) {
+    const id = modelId?.trim().toLowerCase();
+    if (!id)
+        return "";
+    const separators = [...id].filter((c) => c === "/" || c === ":").length;
+    if (separators === 1) {
+        const sep = id.includes("/") ? "/" : ":";
+        const [providerPart, ...rest] = id.split(sep);
+        if (providerPart && rest.join(sep).length > 0)
+            return providerPart;
+        return "";
+    }
+    if (separators > 1)
+        return "";
+    for (const [prefix, provider] of KNOWN_PREFIXES) {
+        if (id.startsWith(prefix))
+            return provider;
+    }
+    return "";
+}

package/node_modules/pi-lens/dist/clients/pipeline.js

@@ -843,7 +843,25 @@ export async function runPipeline(ctx, deps) {
     });
     // --- 3. Auto-fix ---
     phase.start("autofix");
-    const { fixedCount, autofixTools, attemptedTools, changedFiles: autofixChangedFiles, needsContentRefresh: fixRefresh, skipReason: autofixSkipReason, } = await runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource);
+    let fixedCount = 0;
+    let autofixTools = [];
+    let attemptedTools = [];
+    let autofixChangedFiles = [];
+    let fixRefresh = false;
+    let autofixSkipReason;
+    if (ctx.autofixMode === "deferred") {
+        autofixSkipReason = "deferred_to_agent_end";
+        dbg(`autofix: deferred until agent_end for ${filePath}`);
+    }
+    else
+        ({
+            fixedCount,
+            autofixTools,
+            attemptedTools,
+            changedFiles: autofixChangedFiles,
+            needsContentRefresh: fixRefresh,
+            skipReason: autofixSkipReason,
+        } = await runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource));
     for (const changedFile of autofixChangedFiles) {
         piChangedFiles.add(path.resolve(changedFile));
     }
@@ -903,6 +921,8 @@ export async function runPipeline(ctx, deps) {
     }, {
         projectRoot: ctx.projectRoot,
         writeIndex: ctx.telemetry?.writeIndex,
+        telemetryModel: ctx.telemetry?.modelId,
+        telemetryProvider: ctx.telemetry?.provider,
     });
     recordDiagnostics(filePath, dispatchResult.diagnostics, ctx.telemetry?.writeIndex);
     // #502: emit the write batch's FINAL diagnostic state immediately after
@@ -999,7 +1019,11 @@ export async function runPipeline(ctx, deps) {
         const fileList = changedList.length
             ? "\nModified files:\n" + topFiles + overflow
             : "";
-        output += `\n\n⚠️ **File was modified by auto-format/fix. You MUST re-read modified file(s) before making any further edits — the content on disk has changed (whitespace, indentation, quotes, or code). Editing from memory will produce mismatches.**${fileList}`;
+        const targetHasAuthoritativeAttachment = ctx.autofixMode !== "deferred" &&
+            autofixChangedFiles.some((changedFile) => path.resolve(changedFile) === path.resolve(filePath));
+        output += targetHasAuthoritativeAttachment
+            ? `\n\n⚠️ **The attached full content for ${toRunnerDisplayPath(cwd, filePath)} is authoritative after autofix. You MUST re-read any other modified side-effect files before editing them.**${fileList}`
+            : `\n\n⚠️ **File was modified by auto-format/fix. You MUST re-read modified file(s) before making any further edits — the content on disk has changed (whitespace, indentation, quotes, or code). Editing from memory will produce mismatches.**${fileList}`;
     }
     phase.end("dispatch_lint", {
         hasOutput: !!dispatchResult.output,
@@ -1088,5 +1112,8 @@ export async function runPipeline(ctx, deps) {
         formattersUsed,
         fixedCount,
         autofixTools,
+        postMutation: ctx.autofixMode !== "deferred" && autofixChangedFiles.some((f) => path.resolve(f) === path.resolve(filePath)) && fileContent !== undefined
+            ? { filePath: path.resolve(filePath), content: fileContent, source: "autofix" }
+            : undefined,
     };
 }

package/node_modules/pi-lens/dist/clients/project-diagnostics/fresh-fetch.js

@@ -383,7 +383,7 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
                 cold.push("test-runner");
                 return;
             }
-            record("test-runner", testRunnerFindingsToProjectDiagnostics(cached.data), Date.now() - startMs);
+            record("test-runner", testRunnerFindingsToProjectDiagnostics(cached.data, analysisRoot, options.runtime), Date.now() - startMs);
         }),
     ];
     // Swallow any later rejection so an aborted-and-abandoned task can never

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/runner-findings.js

@@ -1,3 +1,6 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { advisoryPathKey, validateAdvisoryProvenance, } from "../../advisory-provenance.js";
 function failureMessage(failure) {
     const firstLine = failure.message.split("\n")[0]?.slice(0, 300) ?? "";
     return firstLine ? `${failure.name}: ${firstLine}` : failure.name;
@@ -71,8 +74,26 @@ export function testResultToProjectDiagnostics(result, stale = false) {
         },
     ];
 }
-export function testRunnerFindingsToProjectDiagnostics(cache) {
+export function testRunnerFindingsToProjectDiagnostics(cache, cwd, runtime) {
     if (!cache.results || cache.results.length === 0)
         return [];
-    return cache.results.flatMap((r) => testResultToProjectDiagnostics(r, cache.stale));
+    const validation = cwd
+        ? validateAdvisoryProvenance(cache, cwd, runtime)
+        : { status: "unknown", reasons: ["validation-context-missing"] };
+    const root = cwd ?? process.cwd();
+    const missingKeys = new Set((cache.provenance?.files ?? [])
+        .filter((file) => !fs.existsSync(path.resolve(root, file.path)))
+        .map((file) => advisoryPathKey(file.path, root)));
+    const historical = cache.superseded === true || cache.stale === true || validation.status !== "current";
+    return cache.results
+        .filter((result) => !missingKeys.has(advisoryPathKey(result.file, root)))
+        .flatMap((result) => testResultToProjectDiagnostics(result, historical))
+        .map((diagnostic) => historical ? {
+        ...diagnostic,
+        severity: "info",
+        semantic: "none",
+        message: diagnostic.message.startsWith("[stale")
+            ? diagnostic.message
+            : `[historical — re-run to confirm] ${diagnostic.message}`,
+    } : diagnostic);
 }

package/node_modules/pi-lens/dist/clients/review-graph/query.js

@@ -1,3 +1,4 @@
+import { detectFileRole } from "../file-role.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { findModuleForPath, getDownstreamModules, getModuleSourceFiles, } from "./workspace-modules.js";
 function dedupe(items) {
@@ -76,6 +77,29 @@ export function computeImpactCascade(graph, changedFile, moduleGraph) {
     const normalizedFile = normalizeMapKey(changedFile);
     const fileNodeId = graph.fileNodes.get(normalizedFile);
     if (!fileNodeId) {
+        // #1445: a missing node has two causes that look identical here but mean
+        // opposite things — "the graph SHOULD know this file but doesn't" (a real
+        // gap) versus "this file's role is excluded from the graph by design"
+        // (test files, #260 — every graph-admission chokepoint in builder.ts
+        // guards on this exact condition, `detectFileRole(file) === "test"`;
+        // reused verbatim here rather than a second role list). A test edit not
+        // cascading is expected behavior, not a graph failure, so it must not
+        // produce the "review graph was unavailable" advisory that misled agents
+        // into distrusting a healthy graph 19% of the time in dogfooding.
+        if (detectFileRole(normalizedFile) === "test") {
+            return {
+                filePath: normalizedFile,
+                changedSymbols: [],
+                directImporters: [],
+                directCallers: [],
+                neighborFiles: [],
+                riskFlags: [],
+                indeterminate: {
+                    reason: "excluded_by_role",
+                    detail: "test-role file — excluded from the review graph by design (#260)",
+                },
+            };
+        }
         // #1023: the changed file has no node in the graph — we CANNOT enumerate
         // its dependents, so this empty result is "couldn't compute", NOT "nothing
         // depends on it". Mark it indeterminate so callers surface an honest

package/node_modules/pi-lens/dist/clients/run-duration.js

@@ -0,0 +1,55 @@
+/**
+ * #1479/#1480: one place decides whether a test run was actually timed, and
+ * one place renders the answer.
+ *
+ * `TestResult.duration` is optional, and the two states are different facts.
+ * A present number is a MEASUREMENT — including `0`, because pytest really
+ * does print `in 0.00s` and a suite whose `startTime` equals its `endTime`
+ * really did run in under a millisecond. An absent value means no
+ * runner-reported figure was found at all.
+ *
+ * That contract was written down once, in the doc comment on
+ * `TestResult.duration`, and then re-derived at every site that reads or
+ * produces a duration. A reader of any one of those sites cannot see the
+ * contract, and a producer that reaches for `0` when it means "did not
+ * measure" reintroduces exactly the defect #1479 removed. These three
+ * functions are the contract in executable form: `isMeasuredDuration`
+ * classifies, `toMeasuredDurationMs` normalises a freshly parsed figure into
+ * it, and `formatRunDurationMs` renders it.
+ *
+ * NOTE FOR ANYONE EDITING `isMeasuredDuration`: the predicate is `>= 0`, not
+ * `> 0`. A measured zero is real. `> 0` looks like a harmless tightening and
+ * is the single change that would silently restore the bug.
+ *
+ * Kept in its own module rather than exported from `test-runner-client.ts`:
+ * `runtime-turn.ts` needs it on the hot turn-end path, and the client is
+ * deliberately loaded lazily (`bootstrap.ts` dynamic-imports it), so a value
+ * import from there would drag the whole runner into startup.
+ */
+/**
+ * True only for a value that represents a real measurement.
+ *
+ * `0` is measured. `undefined`, `null`, `NaN`, the infinities, and a negative
+ * figure are not: the last three can only come from a garbled parse, and a
+ * garbled parse must degrade to "we did not measure this", never to a wrong
+ * number.
+ */
+export function isMeasuredDuration(duration) {
+    return (typeof duration === "number" && Number.isFinite(duration) && duration >= 0);
+}
+/**
+ * Normalise a parsed elapsed time to the `TestResult.duration` contract.
+ *
+ * Returns whole milliseconds for a real reading — `0` included — and
+ * `undefined` for anything that is not one, so a producer never has to spell
+ * out the absent case itself.
+ */
+export function toMeasuredDurationMs(duration) {
+    return isMeasuredDuration(duration) ? Math.round(duration) : undefined;
+}
+/** Render a duration for a log line: `123ms`, or `unmeasured` when absent. */
+export function formatRunDurationMs(duration) {
+    return isMeasuredDuration(duration)
+        ? `${Math.round(duration)}ms`
+        : "unmeasured";
+}

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

@@ -7,9 +7,10 @@ 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 { resyncLspFile, runAutofix, runFormatPhase } from "./pipeline.js";
 import { getAmbientAbortSignal } from "./safe-spawn.js";
 import { appendProjectChange, } from "./project-changes.js";
+import { getAutofixPolicyForFile, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasKtlintConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, } from "./tool-policy.js";
 /**
  * A queued file is claimed by any flush once it has sat unclaimed by its own
  * owning session for this long — recovery for an orphaned record whose
@@ -40,13 +41,49 @@ function recordProjectChange(args) {
         args.dbg(`project change log append failed for ${args.filePath}: ${err}`);
     }
 }
-export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, dbg, runtime, cacheManager, getFormatService, currentSessionId, staleAfterMs = DEFERRED_FORMAT_STALE_AFTER_MS, }) {
+export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, dbg, runtime, cacheManager, getFormatService, biomeClient, ruffClient, getAutofixClients, currentSessionId, staleAfterMs = DEFERRED_FORMAT_STALE_AFTER_MS, }) {
     // #791: ownership-filtered drain — records queued by a DIFFERENT known
     // session (e.g. a concurrent in-process secondary/subagent) stay queued
     // for their owner's own agent_end, unless they've been stale long enough
     // to fall back to "claim as orphaned" (see claimDeferredFormatFiles).
-    const { claimed, staleClaimed, deferredToOwner } = runtime.claimDeferredFormatFiles(currentSessionId, Date.now(), staleAfterMs);
+    const { claimed, staleClaimed, deferredToOwner } = runtime.claimDeferredMutations(currentSessionId, Date.now(), staleAfterMs);
     const records = [...claimed, ...staleClaimed];
+    const requeuedKinds = new Set();
+    // S2d (gap 4, #1432 review): the aggregate `agent_end_deferred_mutation_drain`
+    // row only carried a coalesced `requeuedKinds` set with no reason, per-call
+    // file count, or tool provenance — every requeue (abort mid-drain, missing
+    // autofix clients, an autofix/format failure) collapsed into one
+    // indistinguishable bucket. Log one bounded record PER requeue call instead,
+    // so a real incident can tell "aborted with N files still queued" apart
+    // from "M files failed to format".
+    const requeue = (pending, reason) => {
+        if (pending.length === 0)
+            return;
+        const kinds = new Set();
+        const toolNames = new Set();
+        for (const record of pending) {
+            for (const kind of record.kinds) {
+                requeuedKinds.add(kind);
+                kinds.add(kind);
+            }
+            for (const toolName of record.toolNames)
+                toolNames.add(toolName);
+        }
+        logLatency({
+            type: "phase",
+            toolName: "agent_end",
+            filePath: ctxCwd ?? runtime.projectRoot,
+            phase: "agent_end_deferred_mutation_requeue",
+            durationMs: 0,
+            metadata: {
+                reason,
+                kinds: [...kinds].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
+                fileCount: pending.length,
+                toolNames: [...toolNames].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
+            },
+        });
+        runtime.requeueDeferredMutations(pending);
+    };
     const rootActionableAutofixEnabled = !!getFlag("lens-actionable-warning-autofix");
     // A path-aware source resolver signals that nested configs may re-enable
     // actionable autofix even when the root default is off. Legacy/test hosts
@@ -97,6 +134,86 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
     // publishFilesTouched call so consumers can tell "pi-lens formatted this"
     // from an agent edit.
     const deferredFormatFixes = [];
+    const deferredAutofixFixes = [];
+    const deferredAutofixChanged = new Set();
+    // Mutation ordering is intentional: lint --write may disturb wrapping, so
+    // autofix reaches the final edited state first and formatting stabilizes it.
+    const ambientSignal = getAmbientAbortSignal();
+    const executedAutofixScopes = new Set();
+    const autofixRecords = records.filter((candidate) => candidate.kinds.has("autofix"));
+    if (autofixRecords.length > 0 && (!biomeClient || !ruffClient) && getAutofixClients) {
+        ({ biomeClient, ruffClient } = await getAutofixClients());
+    }
+    for (let autofixIndex = 0; autofixIndex < autofixRecords.length; autofixIndex++) {
+        const record = autofixRecords[autofixIndex];
+        if (ambientSignal?.aborted) {
+            requeue(autofixRecords.slice(autofixIndex).map((pending) => ({
+                ...pending,
+                kinds: new Set(["autofix"]),
+                toolNames: new Set(pending.toolNames),
+            })), "abort");
+            break;
+        }
+        const filePath = path.resolve(record.filePath);
+        if (!nodeFs.existsSync(filePath)) {
+            summary.skipped.push({ filePath, reason: "missing" });
+            continue;
+        }
+        if (!biomeClient || !ruffClient) {
+            dbg(`agent_end deferred_autofix: clients unavailable for ${filePath}`);
+            requeue([{ ...record, kinds: new Set(["autofix"]), toolNames: new Set(record.toolNames) }], "clients-unavailable");
+            continue;
+        }
+        const policy = getAutofixPolicyForFile(filePath, {
+            hasEslintConfig: hasEslintConfig(record.cwd),
+            hasStylelintConfig: hasStylelintConfig(record.cwd),
+            hasSqlfluffConfig: hasSqlfluffConfig(record.cwd),
+            hasRubocopConfig: hasRubocopConfig(record.cwd),
+            hasBiomeConfig: hasBiomeConfig(record.cwd),
+            hasGolangciConfig: hasGolangciConfig(record.cwd),
+            hasDetektConfig: hasDetektConfig(record.cwd),
+            hasOxlintConfig: hasOxlintConfig(record.cwd),
+            hasKtfmtConfig: hasKtfmtConfig(record.cwd),
+            hasKtlintConfig: hasKtlintConfig(record.cwd),
+        });
+        const scopeKey = policy?.scope && policy.scope !== "file"
+            ? `${policy.defaultTool ?? "unknown"}:${path.resolve(record.cwd)}`
+            : `${policy?.defaultTool ?? "unknown"}:${filePath}`;
+        if (executedAutofixScopes.has(scopeKey))
+            continue;
+        executedAutofixScopes.add(scopeKey);
+        try {
+            const result = await runAutofix(filePath, record.cwd, getFlag, dbg, { biomeClient, ruffClient, fixedThisTurn: runtime.fixedThisTurn }, getFlagSource);
+            const tools = result.autofixTools.map((label) => label.split(":")[0]);
+            for (const changed of result.changedFiles) {
+                const changedPath = path.resolve(changed);
+                deferredAutofixChanged.add(changedPath);
+                for (const tool of tools)
+                    deferredAutofixFixes.push({ path: changedPath, tool, kind: "autofix" });
+                if (!nodeFs.existsSync(changedPath))
+                    continue;
+                recordProjectChange({ runtime, cwd: record.turnStateCwd, filePath: changedPath, source: "autofix", dbg });
+                if (!getFlag("no-read-guard"))
+                    runtime.readGuard.recordWritten(changedPath);
+                const content = nodeFs.readFileSync(changedPath, "utf-8");
+                cacheManager.addModifiedRange(changedPath, { start: 1, end: content.split("\n").length }, /^import\s/m.test(content), record.turnStateCwd, currentSessionId ?? runtime.telemetrySessionId, "pi");
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            summary.failed.push({ filePath, errors: [message] });
+            requeue([{ ...record, kinds: new Set(["autofix"]), toolNames: new Set(record.toolNames) }], "autofix-failed");
+        }
+    }
+    if (deferredAutofixFixes.length > 0) {
+        publishFilesTouched({
+            reason: "autofix",
+            paths: [...new Set(deferredAutofixFixes.map((fix) => fix.path))],
+            cwd: ctxCwd ?? runtime.projectRoot,
+            dbg,
+            fixes: deferredAutofixFixes,
+        });
+    }
     dbg(`agent_end deferred_format: ${records.length} file(s)`);
     logLatency({
         type: "phase",
@@ -127,9 +244,10 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             cwd: ctxCwd ?? runtime.projectRoot,
             paths: records.map((r) => r.filePath),
             dbg,
+            kinds: [...new Set(records.flatMap((record) => [...record.kinds]))],
         });
     }
-    const formatRecords = records.filter((record) => {
+    const formatRecords = records.filter((record) => record.kinds.has("format")).filter((record) => {
         const disabled = !!getFlag("no-autoformat", record.filePath);
         if (disabled) {
             const source = getFlagSource?.("no-autoformat", record.filePath);
@@ -145,7 +263,6 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         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++;
@@ -179,7 +296,11 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         };
         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)));
+            requeue(formatRecords.filter((_, index) => !started.has(index)).map((record) => ({
+                ...record,
+                kinds: new Set(["format"]),
+                toolNames: new Set(record.toolNames),
+            })), "abort");
         }
         for (const entry of work) {
             if (!entry)
@@ -188,12 +309,15 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             const { record, filePath, fileStart } = entry;
             if (entry.missing) {
                 dbg(`agent_end deferred_format skipped missing file: ${filePath}`);
-                summary.skipped.push({ filePath, reason: "missing" });
+                if (!summary.skipped.some((item) => item.filePath === filePath && item.reason === "missing")) {
+                    summary.skipped.push({ filePath, reason: "missing" });
+                }
                 continue;
             }
             if (entry.error) {
                 dbg(`agent_end deferred_format failed for ${filePath}: ${entry.error}`);
                 summary.failed.push({ filePath, errors: [entry.error] });
+                requeue([{ ...record, kinds: new Set(["format"]), toolNames: new Set(record.toolNames) }], "format-failed");
                 continue;
             }
             const result = entry.result;
@@ -202,6 +326,7 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             summary.formatted++;
             if (result.formatFailures.length > 0) {
                 summary.failed.push({ filePath, errors: result.formatFailures });
+                requeue([{ ...record, kinds: new Set(["format"]), toolNames: new Set(record.toolNames) }], "format-failed");
             }
             if (result.formatChanged) {
                 summary.changed.push(filePath);
@@ -268,6 +393,14 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             });
         }
     }
+    // LSP sees only authoritative content after both mutation phases. In
+    // particular, never publish the autofix intermediate state before format.
+    for (const changedPath of deferredAutofixChanged) {
+        if (!nodeFs.existsSync(changedPath))
+            continue;
+        const content = nodeFs.readFileSync(changedPath, "utf-8");
+        await resyncLspFile(changedPath, content, true, false, getFlag, dbg);
+    }
     if (inspectActionableReport) {
         const actionReport = cacheManager.readCache("actionable-warnings", ctxCwd ?? runtime.projectRoot, 10 * 60_000);
         if (!actionReport?.data) {
@@ -384,6 +517,19 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             }
         }
     }
+    logLatency({
+        type: "phase",
+        toolName: "agent_end",
+        filePath: ctxCwd ?? runtime.projectRoot,
+        phase: "agent_end_deferred_mutation_drain",
+        durationMs: Date.now() - startedAt,
+        metadata: {
+            autofixRecords: autofixRecords.length,
+            formatRecords: formatRecords.length,
+            coalescedPaths: records.length,
+            requeuedKinds: [...requeuedKinds].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
+        },
+    });
     logLatency({
         type: "tool_result",
         toolName: "agent_end",