@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,608 +0,0 @@
-import * as nodeFs from "node:fs";
-import * as path from "node:path";
-import { applyConservativeActionableWarningFixes, checkActionableWarningsReportFresh } from "./actionable-warnings.js";
-import { publishFilesTouched } from "./bus-publish.js";
-import { publishAutofixStart, 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 { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
-import { newLspMutationCorrelationId } from "./lsp-mutation.js";
-import { getGlobalActionableWarningMaxFixes } from "./lens-config.js";
-import { resyncLspFile, runAutofix, runFormatPhase } from "./pipeline.js";
-import { getAmbientAbortSignal } from "./safe-spawn.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;
-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}`)
-  });
-}
-export async function handleAgentEnd({ signal, ctxCwd, getFlag, getFlagSource, notify, dbg, runtime, cacheManager, getFormatService, biomeClient, ruffClient, getAutofixClients, currentSessionId, staleAfterMs = DEFERRED_FORMAT_STALE_AFTER_MS }) {
-  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;
-    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 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 (!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(`
-`).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",
-    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) {
-    publishFormatStart({
-      cwd: ctxCwd ?? runtime.projectRoot,
-      paths: records.map((r) => r.filePath),
-      dbg,
-      kinds: [...new Set(records.flatMap((record) => [...record.kinds]))]
-    });
-  }
-  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;
-    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);
-        started.add(index);
-        if (!nodeFs.existsSync(filePath)) {
-          work[index] = {
-            record,
-            filePath,
-            fileStart,
-            result: undefined,
-            missing: true
-          };
-          continue;
-        }
-        try {
-          work[index] = {
-            record,
-            filePath,
-            fileStart,
-            result: await bounded(runFormatPhase(filePath, getFormatService, dbg, ambientSignal, 30000, "agent_settled"), {
-              ms: HOOK_WALL_BUDGET_MS.agent_settled,
-              signal: ambientSignal,
-              hook: "agent_settled",
-              label: "deferred-format"
-            })
-          };
-        } 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;
-        recordProjectChange({
-          runtime,
-          cwd: bookkeepingCwd,
-          filePath,
-          source: "format",
-          dbg
-        });
-        if (!getFlag("no-read-guard")) {
-          runtime.readGuard.recordWritten(filePath);
-        }
-        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 });
-          }
-        }
-      }
-      if (result.fileContent) {
-        await resyncLspFile(filePath, result.fileContent, true, false, getFlag, dbg);
-      }
-      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
-      });
-    }
-  }
-  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 actionCwd = ctxCwd ?? runtime.projectRoot;
-    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) {
-        publishAutofixStart({
-          cwd: ctxCwd ?? runtime.projectRoot,
-          paths: eligibleReport.files.filter((file) => file.warnings.some((warning) => !warning.suppressed && warning.actions.some((action) => action.autoFixEligible))).map((file) => file.filePath),
-          eligibleCount: eligibleReport.summary.autoFixEligible,
-          dbg
-        });
-        const fixStart = Date.now();
-        const fixCwd = ctxCwd ?? runtime.projectRoot;
-        const mutationContext = {
-          cwd: fixCwd,
-          correlationId: newLspMutationCorrelationId(),
-          tool: "lsp-quickfix",
-          source: "autofix",
-          runtime,
-          cacheManager,
-          readGuard: getFlag("no-read-guard") ? undefined : runtime.readGuard,
-          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;
-}

package/extensions/dm-lens/dist/clients/runtime-config.js

@@ -1,39 +0,0 @@
-import { toPositiveFinite } from "./env-utils.js";
-import { loadDmLensGlobalConfig } from "./lens-config.js";
-let _runnerTimeoutFloorCache;
-export function getRunnerTimeoutFloorMs() {
-  if (_runnerTimeoutFloorCache !== undefined)
-    return _runnerTimeoutFloorCache;
-  const config = loadDmLensGlobalConfig();
-  const configFloor = toPositiveFinite(config?.dispatch?.runnerTimeoutFloorMs);
-  const envFloor = toPositiveFinite(process.env.DM_LENS_RUNNER_TIMEOUT_FLOOR_MS);
-  _runnerTimeoutFloorCache = Math.max(configFloor, envFloor, 0);
-  return _runnerTimeoutFloorCache;
-}
-export function _resetRunnerTimeoutFloorCacheForTests() {
-  _runnerTimeoutFloorCache = undefined;
-}
-export const RUNTIME_CONFIG = {
-  pipeline: {
-    lspMaxFileBytes: 2 * 1024 * 1024,
-    lspMaxFileLines: 5000,
-    cascadeMaxFiles: 5,
-    cascadeMaxDiagnosticsPerFile: 20,
-    lspSpawnBudgetMs: 5000
-  },
-  dispatch: {
-    runnerTimeoutMs: 30000
-  },
-  crashNotice: {
-    alwaysShowFirstN: 2,
-    showEveryNth: 5
-  },
-  reviewGraph: {
-    maxFiles: 1000,
-    maxFileBytes: 1 * 1024 * 1024
-  },
-  turnEnd: {
-    maxLines: 20,
-    maxChars: 1000
-  }
-};