@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/runtime-agent-end.js

@@ -0,0 +1,800 @@
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { applyConservativeActionableWarningFixes, checkActionableWarningsReportFresh, quickFixCreditEpoch } from "./actionable-warnings.js";
+import { publishFilesTouched } from "./bus-publish.js";
+import { publishAutofixStart, publishFormatDone, publishFormatStart } from "./format-events-publish.js";
+import { logLatency } from "./latency-logger.js";
+import { isPathIgnoredByProject } from "./file-utils.js";
+import { admitBounded, emitBounded } from "./bounded-telemetry.js";
+import { bounded } from "./deadline-utils.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
+import { newLspMutationCorrelationId } from "./lsp-mutation.js";
+import { getGlobalActionableWarningMaxFixes } from "./lens-config.js";
+import { captureLspServiceGeneration } from "./lsp/server.js";
+import { chainLateFormatResync, resyncHeldLspDocument, resyncLspFile, runAutofix, runFormatPhase } from "./pipeline.js";
+import { queueAgentAdvisory } from "./agent-nudge.js";
+import { holdFileMutationQueue } from "./file-mutation-queue.js";
+import { renderFixRunLoss } from "./fix-run-restore.js";
+import { getAmbientAbortSignal } from "./safe-spawn.js";
+import { recordDroppedRead, sessionFencedFixedThisTurn } from "./session-scope.js";
+import { getAutofixPolicyForFile, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasKtlintConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig } from "./tool-policy.js";
+const DEFERRED_FORMAT_STALE_AFTER_MS = 10 * 60000;
+const DEFERRED_FORMAT_CONCURRENCY = 3;
+const DEFERRED_FORMAT_BUDGET_MS = 30000;
+function recordProjectChange(args) {
+  args.runtime.recordProjectMutation?.({
+    filePath: args.filePath,
+    source: args.source,
+    cwd: args.cwd,
+    onAppendError: (err) => args.dbg(`project change log append failed for ${args.filePath}: ${err}`)
+  });
+}
+function retireChangedAuthorshipBeforeDrain(runtime, session, filePath, getFlag) {
+  if (getFlag("no-read-guard"))
+    return;
+  session.guardedWrite(filePath, () => runtime.readGuard.retireChangedAuthorship?.(filePath));
+}
+export async function handleAgentEnd({ signal, ctxCwd, getFlag, getFlagSource, notify, dbg, runtime, cacheManager, getFormatService, biomeClient, ruffClient, getAutofixClients, currentSessionId, staleAfterMs = DEFERRED_FORMAT_STALE_AFTER_MS }) {
+  runtime.readGuard.dropProvisionalReads();
+  const session = runtime.captureSessionGeneration();
+  const lspService = captureLspServiceGeneration();
+  const syncDrainWrite = async (filePath, read) => {
+    if (session.guardedWrite(filePath, () => lspService.guardedWrite(filePath, () => true))) {
+      const { content, readStamp } = read();
+      return resyncLspFile(filePath, content, true, false, getFlag, dbg, readStamp);
+    }
+    await resyncHeldLspDocument(filePath);
+    return;
+  };
+  const { claimed, staleClaimed, deferredToOwner, droppedOrphans } = runtime.claimDeferredMutations(currentSessionId, Date.now(), staleAfterMs, ctxCwd ?? runtime.projectRoot);
+  const records = [...claimed, ...staleClaimed];
+  const scheduledTurnId = records[0]?.queuedTurnId;
+  const requeuedKinds = new Set;
+  const requeue = (pending, reason) => {
+    if (pending.length === 0)
+      return;
+    session.guardedWrite(pending.map((queued) => queued.filePath).join(", "), () => {
+      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",
+        turnId: pending[0]?.queuedTurnId,
+        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");
+  const actionableWarningsWriterEnabled = !!getFlag("lens-actionable-warnings");
+  const inspectActionableReport = actionableWarningsWriterEnabled && typeof cacheManager.readCache === "function" && (rootActionableAutofixEnabled || getFlagSource !== undefined);
+  if (droppedOrphans.length > 0) {
+    dbg(`agent_end deferred_format: left ${droppedOrphans.length} orphaned file(s) queued due to a mismatched origin (unclaimed >${staleAfterMs}ms, not formatted by this flush): ${droppedOrphans.map((r) => `${r.filePath} origin=${r.originCwd}`).join(", ")}`);
+    const firstSeenOrphans = [];
+    for (const record of droppedOrphans) {
+      const isFirstOccurrence = admitBounded("agent_end_deferred_format_orphan_origin_mismatch", record.filePath, {
+        ledgerKind: "path-attribution-orphan-unresolved",
+        risingEdgePer: "identity",
+        reason: `origin=${record.originCwd} unclaimed >${staleAfterMs}ms`
+      });
+      if (isFirstOccurrence)
+        firstSeenOrphans.push(record);
+    }
+    if (firstSeenOrphans.length > 0) {
+      emitBounded("agent_end_deferred_format_orphan_origin_mismatch", ctxCwd ?? runtime.projectRoot, {
+        type: "phase",
+        toolName: "agent_end",
+        durationMs: 0,
+        metadata: {
+          fileCount: firstSeenOrphans.length,
+          staleAfterMs,
+          currentOriginCwd: ctxCwd ?? runtime.projectRoot,
+          files: firstSeenOrphans.map((r) => ({
+            filePath: r.filePath,
+            originCwd: r.originCwd,
+            ownerSessionId: r.ownerSessionId,
+            queuedTurnIndex: r.queuedTurnIndex,
+            ageMs: Date.now() - r.lastTouchedAt
+          }))
+        }
+      });
+    }
+  }
+  if (records.length === 0 && !inspectActionableReport)
+    return;
+  if (deferredToOwner.length > 0) {
+    dbg(`agent_end deferred_format: leaving ${deferredToOwner.length} file(s) queued for their owning session (${deferredToOwner.map((r) => `${r.filePath} owner=${r.ownerSessionId}`).join(", ")})`);
+  }
+  if (staleClaimed.length > 0) {
+    dbg(`agent_end deferred_format: staleness fallback claimed ${staleClaimed.length} orphaned file(s) (unclaimed >${staleAfterMs}ms): ${staleClaimed.map((r) => r.filePath).join(", ")}`);
+    logLatency({
+      type: "phase",
+      toolName: "agent_end",
+      filePath: ctxCwd ?? runtime.projectRoot,
+      phase: "agent_end_deferred_format_stale_claim",
+      turnId: scheduledTurnId,
+      durationMs: 0,
+      metadata: {
+        fileCount: staleClaimed.length,
+        staleAfterMs,
+        files: staleClaimed.map((r) => ({
+          filePath: r.filePath,
+          ownerSessionId: r.ownerSessionId,
+          queuedTurnIndex: r.queuedTurnIndex,
+          ageMs: Date.now() - r.lastTouchedAt
+        }))
+      }
+    });
+  }
+  const startedAt = Date.now();
+  const summary = {
+    queued: records.length,
+    formatted: 0,
+    changed: [],
+    failed: [],
+    skipped: [],
+    unavailable: []
+  };
+  const deferredFormatFixes = [];
+  const deferredAutofixFixes = [];
+  const deferredAutofixChanged = new Set;
+  const lateFormatCompletions = [];
+  const fixedThisTurn = sessionFencedFixedThisTurn(runtime.fixedThisTurn, session);
+  const skipReplaced = (filePath) => {
+    if (!summary.skipped.some((entry) => entry.filePath === filePath && entry.reason === "session-replaced"))
+      summary.skipped.push({ filePath, reason: "session-replaced" });
+  };
+  const ambientSignal = signal ?? 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 (session.guardedWrite(filePath, () => true) === undefined) {
+      skipReplaced(filePath);
+      continue;
+    }
+    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);
+    retireChangedAuthorshipBeforeDrain(runtime, session, filePath, getFlag);
+    const fixHold = holdFileMutationQueue(filePath);
+    let restoring;
+    try {
+      const result = await runAutofix(filePath, record.cwd, getFlag, dbg, { biomeClient, ruffClient, fixedThisTurn }, getFlagSource, fixHold, ctxCwd ?? runtime.projectRoot);
+      restoring = result.restoring;
+      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;
+        const queuedBranchEpoch = record.readGuardBranchEpoch;
+        const landed = session.guardedWrite(changedPath, () => {
+          recordProjectChange({
+            runtime,
+            cwd: record.turnStateCwd,
+            filePath: changedPath,
+            source: "autofix",
+            dbg
+          });
+          if (!getFlag("no-read-guard"))
+            runtime.readGuard.recordWritten(changedPath, {
+              authorship: "whole-file",
+              branchEpoch: queuedBranchEpoch,
+              stampFileTime: false
+            });
+          const content = nodeFs.readFileSync(changedPath, "utf-8");
+          cacheManager.addModifiedRange(changedPath, { start: 1, end: content.split(`
+`).length }, /^import\s/m.test(content), record.turnStateCwd, currentSessionId ?? runtime.telemetrySessionId, "pi");
+          return true;
+        });
+        if (landed === undefined && !getFlag("no-read-guard"))
+          recordDroppedRead(session, "deferred-autofix", queuedBranchEpoch);
+      }
+    } 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");
+    } finally {
+      fixHold?.release();
+    }
+    const loss = await restoring;
+    if (loss && (loss.lost.length > 0 || loss.possiblyLost.length > 0)) {
+      const text = renderFixRunLoss(loss);
+      queueAgentAdvisory(text, session);
+      notify(`dm-lens: ${text}`, "warning");
+    }
+  }
+  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",
+    toolName: "agent_end",
+    filePath: ctxCwd ?? runtime.projectRoot,
+    phase: "agent_end_deferred_format_start",
+    turnId: scheduledTurnId,
+    durationMs: 0,
+    metadata: {
+      fileCount: records.length,
+      currentSessionId,
+      records: records.map((r) => ({
+        filePath: r.filePath,
+        queuedTurnIndex: r.queuedTurnIndex,
+        ownerSessionId: r.ownerSessionId,
+        staleClaim: staleClaimed.includes(r)
+      })),
+      deferredToOwnerCount: deferredToOwner.length
+    }
+  });
+  if (records.length > 0) {
+    const batch = records[0];
+    publishFormatStart({
+      cwd: ctxCwd ?? runtime.projectRoot,
+      paths: records.map((r) => r.filePath),
+      dbg,
+      kinds: [...new Set(records.flatMap((record) => [...record.kinds]))],
+      ...batch.ownerSessionId === undefined ? {} : { ownerSessionId: batch.ownerSessionId },
+      turnIndex: batch.queuedTurnIndex,
+      batchId: batch.queuedTurnId
+    });
+  }
+  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);
+      dbg(`agent_end deferred_format: skipping ${record.filePath} (--no-autoformat${source ? `, source=${source}` : ""})`);
+      summary.skipped.push({
+        filePath: record.filePath,
+        reason: "no-autoformat"
+      });
+    }
+    return !disabled;
+  });
+  if (formatRecords.length > 0) {
+    const work = [];
+    work.length = formatRecords.length;
+    const started = new Set;
+    const unsettledFormatPaths = new Set;
+    let terminalFormatEventPublished = false;
+    const batchIdentity = records[0];
+    const publishUnsettled = () => {
+      if (terminalFormatEventPublished || unsettledFormatPaths.size === 0)
+        return;
+      terminalFormatEventPublished = true;
+      recordDegradationOnce({
+        kind: "deferred-format-unsettled",
+        subject: batchIdentity.queuedTurnId,
+        reason: "a deferred formatter remained unsettled after the bounded drain; the done event names the pending files and settled=false"
+      });
+      publishFormatDone({
+        cwd: ctxCwd ?? runtime.projectRoot,
+        paths: [...unsettledFormatPaths],
+        kinds: ["format"],
+        ...batchIdentity.ownerSessionId === undefined ? {} : { ownerSessionId: batchIdentity.ownerSessionId },
+        turnIndex: batchIdentity.queuedTurnIndex,
+        batchId: batchIdentity.queuedTurnId,
+        settled: false,
+        dbg
+      });
+    };
+    let nextIndex = 0;
+    const worker = async () => {
+      while (nextIndex < formatRecords.length) {
+        const index = nextIndex++;
+        if (ambientSignal?.aborted)
+          return;
+        const record = formatRecords[index];
+        const fileStart = Date.now();
+        const filePath = path.resolve(record.filePath);
+        if (session.guardedWrite(filePath, () => true) === undefined) {
+          skipReplaced(filePath);
+          continue;
+        }
+        started.add(index);
+        if (!nodeFs.existsSync(filePath)) {
+          work[index] = {
+            record,
+            filePath,
+            fileStart,
+            result: undefined,
+            missing: true
+          };
+          continue;
+        }
+        retireChangedAuthorshipBeforeDrain(runtime, session, filePath, getFlag);
+        const formatHold = holdFileMutationQueue(filePath);
+        try {
+          const phase = runFormatPhase(filePath, getFormatService, dbg, ambientSignal, DEFERRED_FORMAT_BUDGET_MS, "agent_settled", formatHold, ctxCwd ?? runtime.projectRoot).finally(() => formatHold?.release());
+          work[index] = {
+            record,
+            filePath,
+            fileStart,
+            result: await bounded(phase, {
+              ms: HOOK_WALL_BUDGET_MS.agent_settled,
+              signal: ambientSignal,
+              hook: "agent_settled",
+              label: "deferred-format"
+            })
+          };
+          const abandoned = work[index]?.result?.abandoned;
+          if (abandoned) {
+            lateFormatCompletions.push(chainLateFormatResync(abandoned, "deferred", { toolName: "agent_end", filePath, startedAt: fileStart }, dbg));
+          }
+          if (!work[index]?.result) {
+            if (!ambientSignal?.aborted) {
+              unsettledFormatPaths.add(filePath);
+              publishUnsettled();
+            }
+            (async () => {
+              let outcome = "stale-session";
+              try {
+                const formatterSettling = phase.then((summary) => summary.abandoned).then(() => true);
+                const formatterSettled = await bounded(formatterSettling, {
+                  ms: DEFERRED_FORMAT_BUDGET_MS,
+                  signal: ambientSignal,
+                  hook: "off_hook",
+                  label: "deferred-format-post-exit-resync"
+                });
+                if (formatterSettled === undefined) {
+                  outcome = "abandoned";
+                  lateFormatCompletions.push(chainLateFormatResync(formatterSettling, "deferred", { toolName: "agent_end", filePath, startedAt: fileStart }, dbg));
+                } else {
+                  outcome = await syncDrainWrite(filePath, () => {
+                    const readStamp = performance.now();
+                    return {
+                      readStamp,
+                      content: nodeFs.readFileSync(filePath, "utf-8")
+                    };
+                  }) ?? "stale-session";
+                }
+              } catch (err) {
+                outcome = "read-failed";
+                dbg(`agent_end deferred_format post-exit resync failed for ${filePath}: ${err}`);
+              }
+              logLatency({
+                type: "phase",
+                toolName: "agent_end",
+                filePath,
+                phase: "deferred_format_post_exit_resync",
+                durationMs: Date.now() - fileStart,
+                metadata: { outcome }
+              });
+            })();
+          }
+        } catch (err) {
+          work[index] = {
+            record,
+            filePath,
+            fileStart,
+            result: undefined,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(DEFERRED_FORMAT_CONCURRENCY, formatRecords.length) }, () => worker()));
+    if (ambientSignal?.aborted) {
+      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)
+        continue;
+      await new Promise((resolve) => setImmediate(resolve));
+      const { record, filePath, fileStart } = entry;
+      if (entry.missing) {
+        dbg(`agent_end deferred_format skipped missing file: ${filePath}`);
+        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;
+      if (!result) {
+        if (ambientSignal?.aborted)
+          continue;
+        const reason = entry.error ?? "deferred formatter exceeded agent_settled budget";
+        summary.failed.push({ filePath, errors: [reason] });
+        requeue([
+          {
+            ...record,
+            kinds: new Set(["format"]),
+            toolNames: new Set(record.toolNames)
+          }
+        ], "format-failed");
+        continue;
+      }
+      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.formatUnavailable.length > 0) {
+        for (const u of result.formatUnavailable) {
+          summary.unavailable.push({
+            filePath,
+            formatter: u.formatter,
+            reason: u.reason
+          });
+        }
+      }
+      if (result.formatChanged) {
+        summary.changed.push(filePath);
+        for (const tool of result.formattersUsed) {
+          deferredFormatFixes.push({ path: filePath, tool, kind: "format" });
+        }
+        const bookkeepingCwd = record.turnStateCwd;
+        const queuedBranchEpoch = record.readGuardBranchEpoch;
+        const landed = session.guardedWrite(filePath, () => {
+          recordProjectChange({
+            runtime,
+            cwd: bookkeepingCwd,
+            filePath,
+            source: "format",
+            dbg
+          });
+          if (!getFlag("no-read-guard")) {
+            runtime.readGuard.recordWritten(filePath, {
+              authorship: "whole-file",
+              branchEpoch: queuedBranchEpoch,
+              stampFileTime: false
+            });
+          }
+          try {
+            const content = nodeFs.readFileSync(filePath, "utf-8");
+            const lineCount = content.split(`
+`).length;
+            const hasImports = /^import\s/m.test(content);
+            cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, hasImports, bookkeepingCwd, currentSessionId ?? runtime.telemetrySessionId, "pi");
+          } catch (err) {
+            dbg(`agent_end deferred_format modified-range tracking failed for ${filePath}: ${err}`);
+          }
+          if (getFlag("lens-turn-summary")) {
+            for (const tool of result.formattersUsed) {
+              runtime.turnSummary.recordFormat(filePath, { tool });
+            }
+          }
+          return true;
+        });
+        if (landed === undefined && !getFlag("no-read-guard"))
+          recordDroppedRead(session, "deferred-format", queuedBranchEpoch);
+      }
+      if (result.fileContent) {
+        const fileContent = result.fileContent;
+        await syncDrainWrite(filePath, () => ({
+          content: fileContent,
+          readStamp: result.fileReadStamp
+        }));
+      }
+      dbg(`agent_end deferred_format file ${filePath}: changed=${result.formatChanged} duration=${Date.now() - fileStart}ms`);
+      logLatency({
+        type: "phase",
+        toolName: "agent_end",
+        filePath,
+        phase: "deferred_format_file",
+        turnId: record.queuedTurnId,
+        durationMs: Date.now() - fileStart,
+        metadata: {
+          changed: result.formatChanged,
+          formattersUsed: result.formattersUsed,
+          failureCount: result.formatFailures.length
+        }
+      });
+    }
+    if (summary.changed.length > 0) {
+      publishFilesTouched({
+        reason: "format",
+        paths: summary.changed,
+        cwd: ctxCwd ?? runtime.projectRoot,
+        dbg,
+        fixes: deferredFormatFixes
+      });
+    }
+    const publishDone = () => publishFormatDone({
+      cwd: ctxCwd ?? runtime.projectRoot,
+      paths: summary.changed,
+      kinds: ["format"],
+      ...records[0].ownerSessionId === undefined ? {} : { ownerSessionId: records[0].ownerSessionId },
+      turnIndex: records[0].queuedTurnIndex,
+      batchId: records[0].queuedTurnId,
+      settled: true,
+      dbg
+    });
+    if (!terminalFormatEventPublished) {
+      if (lateFormatCompletions.length === 0)
+        publishDone();
+      else
+        Promise.all(lateFormatCompletions).then(() => {
+          if (!terminalFormatEventPublished)
+            publishDone();
+        });
+    }
+  }
+  for (const changedPath of deferredAutofixChanged) {
+    if (!nodeFs.existsSync(changedPath))
+      continue;
+    await syncDrainWrite(changedPath, () => {
+      const readStamp = performance.now();
+      return {
+        readStamp,
+        content: nodeFs.readFileSync(changedPath, "utf-8")
+      };
+    });
+  }
+  const actionCwd = ctxCwd ?? runtime.projectRoot;
+  if (inspectActionableReport && session.guardedWrite(`actionable-warnings:${actionCwd}`, () => lspService.guardedWrite(`actionable-warnings:${actionCwd}`, () => true))) {
+    const actionableWarningsMaxAgeMs = 10 * 60000;
+    const actionReport = cacheManager.readCache("actionable-warnings", actionCwd, actionableWarningsMaxAgeMs);
+    if (!actionReport?.data) {
+      const inspection = typeof cacheManager.inspectCache === "function" ? cacheManager.inspectCache("actionable-warnings", actionCwd, actionableWarningsMaxAgeMs) : undefined;
+      if (inspection === "missing") {
+        dbg("agent_end actionable_warnings_autofix: cache absent, skipping fixes");
+      } else if (inspection === "stale") {
+        dbg("agent_end actionable_warnings_autofix: cache expired, skipping fixes");
+      } else {
+        dbg(`agent_end actionable_warnings_autofix: cache missing or expired${inspection ? ` (${inspection})` : ""}, skipping fixes`);
+      }
+    } else {
+      const enabledFiles = actionReport.data.files.filter((file) => {
+        if (isPathIgnoredByProject(file.filePath, ctxCwd ?? runtime.projectRoot)) {
+          dbg(`agent_end actionable_warnings_autofix: skipped ${file.filePath} (ignored by project)`);
+          return false;
+        }
+        const enabled = !!getFlag("lens-actionable-warning-autofix", file.filePath);
+        if (!enabled) {
+          const source = getFlagSource?.("lens-actionable-warning-autofix", file.filePath);
+          dbg(`agent_end actionable_warnings_autofix: skipped ${file.filePath} (disabled${source ? `, source=${source}` : ""})`);
+        }
+        return enabled;
+      });
+      const eligibleCount = enabledFiles.reduce((total, file) => total + file.warnings.reduce((count, warning) => count + (warning.suppressed ? 0 : warning.actions.filter((action) => action.autoFixEligible).length), 0), 0);
+      const eligibleReport = {
+        ...actionReport.data,
+        files: enabledFiles,
+        summary: {
+          ...actionReport.data.summary,
+          files: enabledFiles.length,
+          autoFixEligible: eligibleCount
+        }
+      };
+      const freshness = checkActionableWarningsReportFresh({
+        report: eligibleReport,
+        currentProjectSeq: runtime.projectSeq,
+        getFileSeq: (filePath) => runtime.getFileSeq(filePath)
+      });
+      if (!freshness.fresh) {
+        dbg(`agent_end actionable_warnings_autofix: stale report (${freshness.reason}; reportProjectSeqEnd=${freshness.reportProjectSeqEnd ?? "missing"}; currentProjectSeq=${freshness.currentProjectSeq}${freshness.filePath ? `; file=${freshness.filePath}; reportFileSeq=${freshness.reportFileSeq}; currentFileSeq=${freshness.currentFileSeq}` : ""}), skipping fixes`);
+      } else if (eligibleReport.summary.autoFixEligible > 0) {
+        const fixableFiles = eligibleReport.files.filter((file) => file.warnings.some((warning) => !warning.suppressed && warning.actions.some((action) => action.autoFixEligible)));
+        publishAutofixStart({
+          cwd: ctxCwd ?? runtime.projectRoot,
+          paths: fixableFiles.map((file) => file.filePath),
+          eligibleCount: eligibleReport.summary.autoFixEligible,
+          dbg
+        });
+        const fixStart = Date.now();
+        const fixCwd = ctxCwd ?? runtime.projectRoot;
+        const credit = quickFixCreditEpoch(fixableFiles, runtime.readGuard.lineageKey);
+        if (credit === undefined && !getFlag("no-read-guard")) {
+          recordDegradationOnce({
+            kind: "actionable-warnings-quickfix-uncredited",
+            subject: fixCwd,
+            reason: "an actionable-warnings entry the quick fix acts on was built under another read guard, or carries no valid branch stamp; its fixes are applied and credited to no branch"
+          });
+        }
+        for (const file of fixableFiles)
+          retireChangedAuthorshipBeforeDrain(runtime, session, file.filePath, getFlag);
+        const mutationContext = {
+          cwd: fixCwd,
+          correlationId: newLspMutationCorrelationId(),
+          tool: "lsp-quickfix",
+          source: "autofix",
+          runtime,
+          cacheManager,
+          readGuard: getFlag("no-read-guard") || credit === undefined ? undefined : {
+            recordWritten: (filePath) => runtime.readGuard.recordWritten(filePath, {
+              authorship: "whole-file",
+              branchEpoch: credit,
+              stampFileTime: false
+            })
+          },
+          session,
+          recordAutofix: getFlag("lens-turn-summary") ? (filePath) => runtime.turnSummary.recordAutofix(filePath, {
+            tool: "lsp-quickfix"
+          }) : undefined,
+          dbg
+        };
+        const fixSummary = await applyConservativeActionableWarningFixes({
+          cwd: fixCwd,
+          report: eligibleReport,
+          maxFixes: getGlobalActionableWarningMaxFixes(),
+          dbg,
+          mutationContext
+        });
+        if (fixSummary.changedFiles.length > 0) {
+          publishFilesTouched({
+            reason: "autofix",
+            paths: fixSummary.changedFiles,
+            cwd: ctxCwd ?? runtime.projectRoot,
+            dbg,
+            fixes: fixSummary.changedFiles.map((changedFile) => ({
+              path: changedFile,
+              tool: "lsp-quickfix",
+              kind: "autofix"
+            }))
+          });
+        }
+        logLatency({
+          type: "phase",
+          toolName: "agent_end",
+          filePath: ctxCwd ?? runtime.projectRoot,
+          phase: "actionable_warnings_autofix",
+          turnId: scheduledTurnId,
+          durationMs: Date.now() - fixStart,
+          metadata: {
+            considered: fixSummary.considered,
+            applied: fixSummary.applied,
+            changedFiles: fixSummary.changedFiles.length,
+            skipped: fixSummary.skipped.length
+          }
+        });
+        if (fixSummary.applied > 0) {
+          notify(`dm-lens applied ${fixSummary.applied} conservative LSP warning quickfix(es)`, "info");
+        }
+      } else {
+        dbg("agent_end actionable_warnings_autofix: fresh report, 0 autofix-eligible warnings, skipping");
+      }
+    }
+  }
+  logLatency({
+    type: "phase",
+    toolName: "agent_end",
+    filePath: ctxCwd ?? runtime.projectRoot,
+    phase: "agent_end_deferred_mutation_drain",
+    turnId: scheduledTurnId,
+    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",
+    filePath: ctxCwd ?? runtime.projectRoot,
+    durationMs: Date.now() - startedAt,
+    result: "deferred_format_complete",
+    turnId: scheduledTurnId,
+    metadata: {
+      queued: summary.queued,
+      formatted: summary.formatted,
+      changed: summary.changed.length,
+      failed: summary.failed.length,
+      skipped: summary.skipped.length,
+      unavailable: summary.unavailable.length
+    }
+  });
+  logLatency({
+    type: "phase",
+    toolName: "agent_end",
+    filePath: ctxCwd ?? runtime.projectRoot,
+    phase: "agent_end_deferred_format_done",
+    turnId: scheduledTurnId,
+    durationMs: Date.now() - startedAt,
+    metadata: {
+      formatted: summary.formatted,
+      changed: summary.changed.length,
+      failed: summary.failed.length,
+      skipped: summary.skipped.length,
+      unavailable: summary.unavailable.length
+    }
+  });
+  dbg(`agent_end deferred_format complete: formatted=${summary.formatted} changed=${summary.changed.length} failed=${summary.failed.length} skipped=${summary.skipped.length} unavailable=${summary.unavailable.length}`);
+  if (summary.failed.length > 0) {
+    notify(`dm-lens deferred format: ${summary.changed.length} changed, ${summary.failed.length} failed`, "warning");
+  } else if (summary.changed.length > 0 && !getFlag("lens-turn-summary")) {
+    const names = summary.changed.map((f) => path.basename(f)).join(", ");
+    notify(`dm-lens deferred format applied to ${summary.changed.length} file(s): ${names}`, "info");
+  }
+  return summary;
+}