@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1625 +0,0 @@
-import * as nodeFs from "node:fs";
-import * as path from "node:path";
-import { resetBoundedTelemetry } from "./bounded-telemetry.js";
-import { rotateMessageEndAttribution } from "./message-end-attribution.js";
-import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
-import { deadCodeIssueCount } from "./dead-code-client.js";
-import { logDeadCodeScan } from "./dead-code-logger.js";
-import { incrementDegradationCount, recordDegradationOnce, resetDegradationLedger } from "./degradation-ledger.js";
-import { getDiagnosticTracker } from "./diagnostic-tracker.js";
-import { resetPsScriptAnalyzerAvailability } from "./dispatch/runners/psscriptanalyzer.js";
-import { resetInstallRetryLatches } from "./dispatch/runners/utils/availability-policy.js";
-import { resetLazyInstallAttempts } from "./dispatch/runners/utils/lazy-installer.js";
-import { resetDispatchAvailabilityState } from "./dispatch/runners/utils/runner-helpers.js";
-import { resetObservedRunnerLatency } from "./dispatch/collect-later-tier.js";
-import { resetPendingRunnerFindings } from "./dispatch/pending-runner-findings.js";
-import { clearAllSessions as clearFileTimeSessions } from "./file-time.js";
-import { drainProjectDataDirMigrations, getGlobalDmLensDir, getKnipIgnorePatterns, getProjectDataDir, resetProjectDataDirSessionState } from "./file-utils.js";
-import { GitleaksClient } from "./gitleaks-client.js";
-import { resetGoAvailability } from "./go-client.js";
-import { GovulncheckClient } from "./govulncheck-client.js";
-import { sweepAtomicWriteStages } from "./instance-reaper.js";
-import { canRunStartupHeavyScans } from "./language-policy.js";
-import { detectProjectLanguageProfile, getDefaultStartupTools } from "./language-profile.js";
-import { logLatency } from "./latency-logger.js";
-import { runLogCleanup } from "./log-cleanup.js";
-import { resetCascadeTierSessionState } from "./lsp/cascade-tier.js";
-import { initLSPConfig, loadLSPConfig } from "./lsp/config.js";
-import { resetWorkspaceDiagnosticsCacheSession } from "./lsp/workspace-diagnostics-session.js";
-import { resetDirectLspCommandAvailability, resetLSPCaseSensitivityState } from "./lsp/server.js";
-import { loadLspService } from "./lsp-lazy.js";
-import { resetManagedToolRefreshSession } from "./installer/managed-tool-refresh-session.js";
-import { resetResolvedPathCache } from "./installer/index.js";
-import { _resetPackageManagerCache } from "./package-manager.js";
-import { clearFormatterCache } from "./formatters.js";
-import { isAtOrAboveHomeDir } from "./path-utils.js";
-import { isPrintMode } from "./print-mode.js";
-import { readLatestProjectSequence, readLatestProjectSequenceAsync } from "./project-changes.js";
-import { getProjectSnapshotPath, getProjectSnapshotLegacyPath, hydrateRuntimeFromProjectSnapshot, hydrateRuntimeFromProjectSnapshotIfIdle, isProjectSnapshotFresh, isProjectSnapshotMetaStale, loadProjectSnapshot, loadProjectSnapshotExportsAndRules, PROJECT_SNAPSHOT_VERSION, readProjectSnapshotMeta, saveRuntimeProjectSnapshot } from "./project-snapshot.js";
-import { scanProjectRules } from "./rules-scanner.js";
-import { resetRustAvailability } from "./rust-client.js";
-import { resetSafeSpawnWindowsCommandCache } from "./safe-spawn.js";
-import { resetAnalyzerBootstrapSessionState } from "./bootstrap.js";
-import { getSlowFsVerdict, isSlowFs, slowFsDegradationNotice } from "./slow-fs.js";
-import { countRecentSmells, formatSmellsSessionStartLine, resetSmellsSessionState } from "./smells-rollup.js";
-import { resetSituationalToolTelemetry } from "./situational-tool-telemetry.js";
-import { findNearestProjectRoot, getStartupScanMaxEntries, isStartupScanVerdictFresh, resolveStartupScanContext } from "./startup-scan.js";
-import { getSubagentIdentity, isSubagentSession, subagentLightModeNotice } from "./subagent-mode.js";
-import { TrivyClient } from "./trivy-client.js";
-import { isWarmAttached } from "./warm-attach.js";
-import { setSessionLanguages } from "./widget-state.js";
-import { logWordIndex } from "./word-index-logger.js";
-import { resetOpaqueMutationState } from "./opaque-mutation-scan.js";
-import { primePersistedMutationAttribution, resetMutationAttribution } from "./mutation-attribution.js";
-import { resetObservedMutationNet } from "./observed-mutation.js";
-import { resetPendingAuxiliaryCoverage } from "./lsp/pending-aux-coverage.js";
-import { resetWorkspaceTopology } from "./workspace-topology.js";
-import { resetZizmorTokenAvailability } from "./zizmor-config.js";
-import { resetSpawnTimeoutCooldowns } from "./spawn-timeout-cooldown.js";
-import { resetTestRunnerDelivery } from "./test-runner-delivery.js";
-import { resetLspMutationNoBridgeDbgLatch } from "./lsp-mutation.js";
-async function demandBootstrapDeps(deps, reason) {
-  const clients = await deps.bootstrap.request(reason);
-  if (!clients)
-    return null;
-  return { ...deps, ...clients };
-}
-const HOST_STALL_THRESHOLD_MS = 30000;
-function logHostReadyDelay(deps, cwd) {
-  if (!deps.emitHostReadyDelay || deps.sessionStartMonotonicAt === undefined || deps.extensionLoadedAt === undefined) {
-    return;
-  }
-  const durationMs = Math.max(0, deps.sessionStartMonotonicAt - deps.extensionLoadedAt);
-  logLatency({
-    type: "phase",
-    filePath: cwd,
-    phase: "host_ready_delay",
-    durationMs,
-    metadata: {
-      hostStallSuspected: durationMs > HOST_STALL_THRESHOLD_MS,
-      sessionStart: "first-process-session",
-      reason: deps.sessionReason
-    }
-  });
-}
-function resolveSnapshotRoot(cwd) {
-  const resolvedCwd = path.resolve(cwd);
-  const nearest = findNearestProjectRoot(resolvedCwd);
-  if (!nearest || isAtOrAboveHomeDir(nearest)) {
-    return resolvedCwd;
-  }
-  return nearest;
-}
-function snapshotSequenceBase(root) {
-  const meta = readProjectSnapshotMeta(root);
-  if (!meta || meta.version !== PROJECT_SNAPSHOT_VERSION)
-    return;
-  const index = meta.sequenceIndex;
-  if (!index)
-    return;
-  return {
-    projectSeq: index.projectSeq,
-    fileSeqByPath: index.fileSeqByPath,
-    sinceSeq: meta.seq
-  };
-}
-function recordSnapshotSequenceTimeout(args) {
-  let reason = "sequence read timed out; no snapshot on disk";
-  try {
-    const stat = nodeFs.statSync(args.snapshotPath);
-    reason = `sequence read timed out; snapshot age=${Math.round(Date.now() - stat.mtimeMs)}ms size=${stat.size}b`;
-  } catch {}
-  incrementDegradationCount({
-    kind: "snapshot-sequence-read-timeout",
-    subject: args.snapshotRoot,
-    reason
-  });
-}
-function retroactivelyHydrateAfterDeferredSequence(args) {
-  return (latestSeq) => {
-    const published = args.getWarmupOwnSnapshotRead();
-    const snapshot = published !== undefined ? published : loadProjectSnapshotExportsAndRules(args.snapshotRoot);
-    if (!snapshot || snapshot.version !== PROJECT_SNAPSHOT_VERSION || snapshot.seq !== latestSeq.projectSeq) {
-      return;
-    }
-    const hydrated = hydrateRuntimeFromProjectSnapshotIfIdle(args.runtime, snapshot);
-    if (hydrated) {
-      args.dbg(`session_start: deferred sequence read confirmed snapshot freshness — hydrating cachedExports/projectRulesScan late (seq=${snapshot.seq})`);
-    } else {
-      args.dbg(`session_start: deferred sequence read confirmed snapshot freshness (seq=${snapshot.seq}), but the runtime already has live state (warmup or another task got there first) — skipping late hydration to avoid clobbering it`);
-    }
-  };
-}
-function loadSnapshotBodyUnlessStale(args) {
-  const meta = readProjectSnapshotMeta(args.root);
-  if (meta && isProjectSnapshotMetaStale(meta, args.currentProjectSeq)) {
-    args.dbg(`project_snapshot: meta gate stale (metaSeq=${meta.seq} metaVersion=${meta.version} current=${args.currentProjectSeq}) — skipping body parse`);
-    return { snapshot: null, skippedStale: true };
-  }
-  return {
-    snapshot: loadProjectSnapshot(args.root),
-    skippedStale: false
-  };
-}
-function describeSnapshotMiss(snapshot, currentProjectSeq, args) {
-  if (args.skippedStale)
-    return "stale-meta-gate";
-  if (!snapshot)
-    return args.bodyPresent ? "invalid-body" : "missing";
-  if (snapshot.seq !== currentProjectSeq) {
-    return `stale(seq=${snapshot.seq}, current=${currentProjectSeq})`;
-  }
-  return "incompatible";
-}
-function logProjectSnapshotProbe(args) {
-  args.dbg(`project_snapshot: probe root=${args.root} path=${getProjectSnapshotPath(args.root)} currentSeq=${args.currentProjectSeq}`);
-  if (isProjectSnapshotFresh(args.snapshot, args.currentProjectSeq)) {
-    args.dbg(`project_snapshot: loaded seq=${args.snapshot.seq} exports=${args.snapshot.cachedExports.length} files=${Object.keys(args.snapshot.files ?? {}).length} reverseDeps=${Object.keys(args.snapshot.reverseDeps ?? {}).length} startupScan=${Boolean(args.snapshot.startupScan)} languageProfile=${Boolean(args.snapshot.languageProfile)}`);
-  } else {
-    args.dbg(`project_snapshot: miss reason=${args.missReason}`);
-  }
-}
-function resolveStartupMode(projectConfig, globalConfig) {
-  const envMode = (process.env.DM_LENS_STARTUP_MODE ?? "").trim().toLowerCase();
-  if (envMode === "full" || envMode === "minimal" || envMode === "quick") {
-    return envMode;
-  }
-  const configMode = projectConfig?.startup?.mode ?? globalConfig?.startup?.mode;
-  if (configMode)
-    return configMode;
-  if (isPrintMode()) {
-    return "quick";
-  }
-  return "full";
-}
-function sequenceReadBudgetMs() {
-  const raw = Number(process.env.DM_LENS_SEQUENCE_READ_BUDGET_MS ?? 250);
-  return Number.isFinite(raw) && raw > 0 ? raw : 250;
-}
-const UNKNOWN_PROJECT_SEQ = -1;
-async function readSequenceWithBudget(args) {
-  const { snapshotRoot, base, cwd, runtime, sessionGeneration, dbg, onDeferredSequenceResolved } = args;
-  const readPromise = readLatestProjectSequenceAsync(snapshotRoot, base);
-  let timeoutHandle;
-  const timeoutPromise = new Promise((resolve) => {
-    timeoutHandle = setTimeout(() => resolve({ timedOut: true }), sequenceReadBudgetMs());
-    timeoutHandle.unref();
-  });
-  const raced = await Promise.race([
-    readPromise.then((latestSeq) => ({ timedOut: false, latestSeq })),
-    timeoutPromise
-  ]);
-  if (timeoutHandle)
-    clearTimeout(timeoutHandle);
-  if (!raced.timedOut) {
-    return { latestSeq: raced.latestSeq, timedOut: false };
-  }
-  dbg(`session_start: sequence read exceeded ${sequenceReadBudgetMs()}ms budget — falling back to cold-start sequence`);
-  if (!isPrintMode()) {
-    readPromise.then((latestSeq) => {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      if (runtime.projectSeq > 0) {
-        dbg("session_start: deferred sequence read completed, but the session already advanced (in-window edit) — skipping reseed to avoid clobbering it");
-        return;
-      }
-      const reseedStartedAt = Date.now();
-      runtime.seedProjectSequence?.(latestSeq.projectSeq, latestSeq.fileSeqByPath);
-      logLatency({
-        type: "phase",
-        phase: "session_start_sequence_read_deferred_reseed",
-        filePath: cwd,
-        startedAt: new Date(reseedStartedAt).toISOString(),
-        durationMs: Date.now() - reseedStartedAt,
-        metadata: { entries: latestSeq.fileSeqByPath.size, deferred: true }
-      });
-      dbg(`session_start: deferred sequence read completed — reseeded projectSeq=${latestSeq.projectSeq} fileSeqEntries=${latestSeq.fileSeqByPath.size}`);
-      onDeferredSequenceResolved?.(latestSeq);
-    }).catch((err) => {
-      dbg(`session_start: deferred sequence read failed: ${err}`);
-    });
-  }
-  return {
-    latestSeq: { projectSeq: 0, fileSeqByPath: new Map },
-    timedOut: true
-  };
-}
-async function igniteWarmFiles(cwd, warmFiles, runtime, sessionGeneration, dbg) {
-  try {
-    dbg(`session_start lsp-warm: ${warmFiles.length} warm file(s) configured`);
-    await initLSPConfig(cwd);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const lspService = (await loadLspService()).getLSPService();
-    const total = warmFiles.length;
-    let loaded = 0;
-    let errors = 0;
-    for (const relPath of warmFiles) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      const filePath = path.isAbsolute(relPath) ? relPath : path.resolve(cwd, relPath);
-      if (!nodeFs.existsSync(filePath)) {
-        dbg(`session_start lsp-warm: not found: ${relPath}`);
-        errors++;
-        continue;
-      }
-      try {
-        const content = nodeFs.readFileSync(filePath, "utf-8");
-        await lspService.touchFile(filePath, content, {
-          diagnostics: "none",
-          source: "startup-warm",
-          clientScope: "primary",
-          maxClientWaitMs: 2000
-        });
-        loaded++;
-      } catch (err) {
-        dbg(`session_start lsp-warm: error ${relPath}: ${err}`);
-        errors++;
-      }
-    }
-    dbg(`session_start lsp-warm: ${loaded}/${total} opened (${errors} err)`);
-  } catch (err) {
-    dbg(`session_start lsp-warm: config/init error: ${err}`);
-  }
-}
-async function igniteDominantLanguageWarm(cwd, runtime, sessionGeneration, dbg) {
-  try {
-    await initLSPConfig(cwd);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const lspService = (await loadLspService()).getLSPService();
-    const { collectSourceFilesAsync } = await import("./source-filter.js");
-    const { CODE_KINDS, detectFileKind } = await import("./file-kinds.js");
-    const files = await collectSourceFilesAsync(cwd, {
-      inspectGeneratedHeaders: false
-    });
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const counts = new Map;
-    for (const f of files) {
-      const kind = detectFileKind(f);
-      if (kind)
-        counts.set(kind, (counts.get(kind) ?? 0) + 1);
-    }
-    if (counts.size === 0) {
-      dbg("session_start lsp-warm: no detected languages to auto-warm");
-      return;
-    }
-    const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1]);
-    const warmOrder = [
-      ...ranked.filter(([kind]) => CODE_KINDS.has(kind)),
-      ...ranked.filter(([kind]) => !CODE_KINDS.has(kind))
-    ];
-    for (const [kind] of warmOrder) {
-      const sample = files.find((f) => detectFileKind(f) === kind && lspService.supportsLSP(f));
-      if (!sample)
-        continue;
-      const content = await nodeFs.promises.readFile(sample, "utf-8");
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      await lspService.touchFile(sample, content, {
-        diagnostics: "none",
-        source: "startup-warm-dominant",
-        clientScope: "primary",
-        maxClientWaitMs: 2000
-      });
-      dbg(`session_start lsp-warm: dominant=${kind} via ${path.basename(sample)}`);
-      return;
-    }
-    dbg("session_start lsp-warm: no dominant-language LSP file found to warm");
-  } catch (err) {
-    dbg(`session_start lsp-warm: dominant warm error: ${err}`);
-  }
-}
-function firePreinstallDefaults(ensureTool, dbg, startupDefaults) {
-  for (const tool of startupDefaults) {
-    const startedAt = Date.now();
-    dbg(`session_start preinstall ${tool}: start`);
-    ensureTool(tool).then((toolPath) => {
-      if (toolPath) {
-        dbg(`session_start: ${tool} ready at ${toolPath}`);
-        dbg(`session_start preinstall ${tool}: success (${Date.now() - startedAt}ms)`);
-      } else {
-        dbg(`session_start: ${tool} installation unavailable`);
-        dbg(`session_start preinstall ${tool}: unavailable (${Date.now() - startedAt}ms)`);
-      }
-    }).catch((err) => {
-      dbg(`session_start: ${tool} pre-install error: ${err}`);
-      dbg(`session_start preinstall ${tool}: error (${Date.now() - startedAt}ms)`);
-    });
-  }
-}
-const MANAGED_TOOL_REFRESH_DELAY_MS = 30000;
-function scheduleManagedToolRefresh(dbg) {
-  const delayMs = Number(process.env.DM_LENS_TOOL_REFRESH_DELAY_MS ?? MANAGED_TOOL_REFRESH_DELAY_MS);
-  const timer = setTimeout(() => {
-    (async () => {
-      try {
-        const refresh = await import("./installer/managed-tool-refresh.js");
-        const outcome = await refresh.runManagedToolRefresh();
-        if (outcome.skipped) {
-          dbg(`session_start tool-refresh: skipped (${outcome.skipped})`);
-          return;
-        }
-        for (const result of outcome.refreshed) {
-          dbg(`session_start tool-refresh: ${result.toolId} ${result.ok ? "ok" : "failed"}${result.changed ? ` ${result.previousVersion ?? "unknown"} → ${result.currentVersion}` : " (unchanged)"}`);
-        }
-      } catch (err) {
-        dbg(`session_start tool-refresh: error ${err}`);
-      }
-    })();
-  }, Number.isFinite(delayMs) ? delayMs : MANAGED_TOOL_REFRESH_DELAY_MS);
-  timer.unref?.();
-}
-async function probePrettierInstall(ensureTool, dbg, analysisRoot) {
-  const pkgPath = path.join(analysisRoot, "package.json");
-  try {
-    const raw = await nodeFs.promises.readFile(pkgPath, "utf-8");
-    const pkg = JSON.parse(raw);
-    const usesPrettier = !!pkg.devDependencies?.prettier || !!pkg.dependencies?.prettier || pkg.prettier !== undefined;
-    if (usesPrettier) {
-      dbg("session_start: project uses prettier, ensuring install...");
-      ensureTool("prettier").then((p) => {
-        if (p)
-          dbg(`session_start: prettier ready at ${p}`);
-        else
-          dbg("session_start: prettier install failed silently");
-      }).catch((err) => dbg(`session_start: prettier install error: ${err}`));
-    }
-  } catch {}
-}
-function scanOneTodoFile(scanner, filePath, items) {
-  if (typeof scanner.scanFile !== "function")
-    return;
-  try {
-    const result = scanner.scanFile(filePath);
-    if (Array.isArray(result))
-      items.push(...result);
-  } catch {}
-}
-async function collectTodoBaselineItems(scanner, analysisRoot, stillCurrent) {
-  const items = [];
-  try {
-    const { getSourceFilesAsync } = await import("./scan-utils.js");
-    const files = await getSourceFilesAsync(analysisRoot, true);
-    if (!stillCurrent())
-      return items;
-    const deadline = createDeadline(8);
-    for (const file of files) {
-      if (!stillCurrent())
-        return items;
-      scanOneTodoFile(scanner, file, items);
-      await yieldIfOverBudget(deadline);
-    }
-  } catch {
-    const todoResult = scanner.scanDirectory(analysisRoot);
-    items.push(...todoResult.items);
-  }
-  return items;
-}
-async function buildOrRefreshWordIndex(args) {
-  const { runtime, sessionGeneration, analysisRoot, snapshotRoot, dbg } = args;
-  if (!runtime.isCurrentSession(sessionGeneration))
-    return;
-  const startMs = Date.now();
-  let rebuildPreflightFiles;
-  const latestSeq = readLatestProjectSequence(snapshotRoot, snapshotSequenceBase(snapshotRoot));
-  const effectiveSeq = runtime.projectSeq ?? latestSeq.projectSeq;
-  const snapshotLoadStartMs = Date.now();
-  const snapshot = loadProjectSnapshot(snapshotRoot);
-  const snapshotLoadMs = Date.now() - snapshotLoadStartMs;
-  if (snapshot?.wordIndex) {
-    const { deserializeWordIndex, refreshWordIndexIncrementally, countWordIndexPostingEntries, estimateWordIndexResidentBytes } = await import("./word-index.js");
-    const deserializeStartMs = Date.now();
-    const index = deserializeWordIndex(snapshot.wordIndex);
-    const deserializeMs = Date.now() - deserializeStartMs;
-    if (index) {
-      try {
-        const result = await refreshWordIndexIncrementally(index, analysisRoot, () => runtime.isCurrentSession(sessionGeneration));
-        if (!runtime.isCurrentSession(sessionGeneration))
-          return;
-        if (result.mode === "full-required") {
-          rebuildPreflightFiles = result.preflightFiles;
-          dbg(`session_start word-index: incremental preflight selected full rebuild (${result.reason})`);
-          logWordIndex({
-            phase: "incremental_fallback",
-            cwd: snapshotRoot,
-            trigger: "session_start",
-            reason: result.reason,
-            phaseDurationsMs: {
-              snapshotLoadMs,
-              deserializeMs,
-              ...result.timings
-            }
-          });
-        } else {
-          runtime.wordIndex = index;
-          let snapshotSaveSyncMs = 0;
-          if (!isProjectSnapshotFresh(snapshot, effectiveSeq) || result.refreshed > 0 || result.dropped > 0 || snapshot.wordIndex.truncated !== index.truncated) {
-            const serializeSaveEnqueueStartMs = Date.now();
-            saveRuntimeProjectSnapshot({ cwd: snapshotRoot, runtime, dbg });
-            snapshotSaveSyncMs = Date.now() - serializeSaveEnqueueStartMs;
-          }
-          const phases = `snapshot-load=${snapshotLoadMs}ms, deserialize=${deserializeMs}ms, source-walk=${result.timings.sourceWalkMs}ms, stat-walk=${result.timings.statWalkMs}ms, refresh-reads=${result.timings.refreshReadsMs}ms, snapshot-save-sync=${snapshotSaveSyncMs}ms`;
-          dbg(`session_start word-index: incremental (seq=${effectiveSeq}, refreshed=${result.refreshed}, dropped=${result.dropped}, skipped=${result.skipped}, reused=${result.reused}, ${Date.now() - startMs}ms, phases: ${phases})`);
-          logWordIndex({
-            phase: "incremental_refresh",
-            cwd: snapshotRoot,
-            trigger: "session_start",
-            durationMs: Date.now() - startMs,
-            indexedFileCount: index.docCount,
-            tokens: index.postings.size,
-            postingEntries: countWordIndexPostingEntries(index),
-            residentBytes: estimateWordIndexResidentBytes(index),
-            truncated: index.truncated,
-            phaseDurationsMs: {
-              snapshotLoadMs,
-              deserializeMs,
-              ...result.timings,
-              snapshotSaveSyncMs
-            },
-            refreshed: result.refreshed,
-            dropped: result.dropped,
-            skipped: result.skipped,
-            reused: result.reused
-          });
-          return result;
-        }
-      } catch (err) {
-        if (!runtime.isCurrentSession(sessionGeneration)) {
-          dbg("session_start word-index: incremental refresh superseded");
-          return;
-        }
-        dbg(`session_start word-index: incremental refresh failed; falling back to full rebuild (${err})`);
-        logWordIndex({
-          phase: "incremental_fallback",
-          cwd: snapshotRoot,
-          trigger: "session_start",
-          reason: err instanceof Error ? err.message : String(err),
-          phaseDurationsMs: { snapshotLoadMs, deserializeMs }
-        });
-      }
-    }
-  }
-  const { buildWordIndexAsync, collectWordIndexDocs, countWordIndexPostingEntries, estimateWordIndexResidentBytes } = await import("./word-index.js");
-  const docs = await collectWordIndexDocs(analysisRoot, () => runtime.isCurrentSession(sessionGeneration), rebuildPreflightFiles);
-  if (!runtime.isCurrentSession(sessionGeneration))
-    return;
-  let rebuiltIndex;
-  try {
-    rebuiltIndex = await buildWordIndexAsync(docs, () => runtime.isCurrentSession(sessionGeneration));
-  } catch (err) {
-    if (!runtime.isCurrentSession(sessionGeneration)) {
-      dbg("session_start word-index: rebuild superseded");
-      return;
-    }
-    throw err;
-  }
-  if (!runtime.isCurrentSession(sessionGeneration))
-    return;
-  runtime.wordIndex = rebuiltIndex;
-  saveRuntimeProjectSnapshot({ cwd: snapshotRoot, runtime, dbg });
-  dbg(`session_start word-index: rebuilt (absent/stale, seq=${effectiveSeq}) ${runtime.wordIndex.docCount} files, ${runtime.wordIndex.postings.size} tokens (${Date.now() - startMs}ms)`);
-  logWordIndex({
-    phase: "full_rebuild",
-    cwd: snapshotRoot,
-    trigger: "session_start",
-    durationMs: Date.now() - startMs,
-    indexedFileCount: runtime.wordIndex.docCount,
-    tokens: runtime.wordIndex.postings.size,
-    postingEntries: countWordIndexPostingEntries(runtime.wordIndex),
-    residentBytes: estimateWordIndexResidentBytes(runtime.wordIndex),
-    truncated: runtime.wordIndex.truncated,
-    skipped: docs.skipped
-  });
-  return {
-    mode: "full",
-    refreshed: runtime.wordIndex.docCount,
-    dropped: 0,
-    skipped: docs.skipped,
-    reused: 0
-  };
-}
-function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
-  (async () => {
-    const resolved = await demandBootstrapDeps(deps, "session-start-scans");
-    if (!resolved) {
-      dbg("session_start scans: analyzer bootstrap unavailable — skipped");
-      return;
-    }
-    scheduleStartupScansWithClients(resolved, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg);
-  })();
-}
-function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
-  const { todoScanner, cacheManager, knipClient, jscpdClient, deadCodeClients, govulncheckClient, gitleaksClient, trivyClient, opengrepClient, astGrepClient, depChecker } = deps;
-  const analyzerEnabled = (flag) => !deps.getFlag(flag);
-  if (!analyzerEnabled("no-complexity")) {
-    dbg("session_start complexity: skipped (disabled by config)");
-    recordDegradationOnce({
-      kind: "startup-analyzer-disabled",
-      subject: "complexity",
-      reason: "skipped (disabled by config)"
-    });
-  }
-  const taskDeferMsByName = {
-    "call-graph": 5000,
-    "codebase-model": 5200,
-    "ast-grep exports": 5400,
-    "project index": 5400
-  };
-  const runTask = (name, task) => {
-    const queuedAt = Date.now();
-    dbg(`session_start task ${name}: scheduled`);
-    runtime.markStartupScanInFlight(name, sessionGeneration);
-    const completion = new Promise((resolve) => {
-      const fire = () => {
-        const startedAt = Date.now();
-        dbg(`session_start task ${name}: start queuedMs=${startedAt - queuedAt}`);
-        task().then(() => {
-          dbg(`session_start task ${name}: success runMs=${Date.now() - startedAt} queuedMs=${startedAt - queuedAt}`);
-        }).catch((err) => {
-          dbg(`session_start: ${name} background scan failed: ${err}`);
-          dbg(`session_start task ${name}: failed runMs=${Date.now() - startedAt} queuedMs=${startedAt - queuedAt}`);
-        }).finally(() => {
-          runtime.clearStartupScanInFlight(name, sessionGeneration);
-          dbg(`session_start task ${name}: end`);
-          resolve();
-        });
-      };
-      const delay = taskDeferMsByName[name] ?? 0;
-      if (delay > 0) {
-        setTimeout(fire, delay).unref?.();
-      } else {
-        setImmediate(fire);
-      }
-    });
-    return completion;
-  };
-  const canRunJsTsHeavyScans = canRunStartupHeavyScans(languageProfile, "jsts");
-  const scanNames = ["todo", "dead-code"];
-  if (canRunJsTsHeavyScans) {
-    scanNames.push("knip", "jscpd", "ast-grep exports", "project index");
-  }
-  dbg(`session_start: launching background scans (${scanNames.join(", ")})`);
-  runTask("todo", async () => {
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const items = await collectTodoBaselineItems(todoScanner, analysisRoot, () => runtime.isCurrentSession(sessionGeneration));
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    dbg(`session_start TODO scan: ${items.length} items (baseline stored)`);
-    cacheManager.writeCache("todo-baseline", { items }, analysisRoot);
-  });
-  if (!canRunJsTsHeavyScans) {
-    dbg("session_start: skipping JS/TS startup scans (requires JS/TS language + project config)");
-    return;
-  }
-  const isSubagent = isSubagentSession();
-  const skipHeavyweightScans = isSlowFs(analysisRoot) || isSubagent;
-  const runHeavyweightTask = (name, task) => {
-    const flag = `no-${name}`;
-    if (name !== "opengrep" && name !== "trivy" && !analyzerEnabled(flag)) {
-      dbg(`session_start ${name}: skipped (disabled by config)`);
-      recordDegradationOnce({
-        kind: "startup-analyzer-disabled",
-        subject: name,
-        reason: "skipped (disabled by config)"
-      });
-      return;
-    }
-    if (skipHeavyweightScans)
-      return;
-    runTask(name, task);
-  };
-  if (skipHeavyweightScans) {
-    dbg(`session_start: skipping knip/jscpd/madge/dead-code/govulncheck/gitleaks/trivy/opengrep (${isSubagent ? "subagent" : "slow-fs"})`);
-    deps.notify(`⏭️ Skipped background code-quality scans (knip/jscpd/madge/dead-code/govulncheck/gitleaks/trivy/opengrep): ${isSubagent ? subagentLightModeNotice() : slowFsDegradationNotice()}`, "info");
-  }
-  runHeavyweightTask("knip", async () => {
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const cached = cacheManager.readCache("knip", analysisRoot);
-    if (cached) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg(`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`);
-    } else {
-      const startMs = Date.now();
-      const knipResult = await knipClient.analyze(analysisRoot, getKnipIgnorePatterns(), { projectSeq: runtime.projectSeq });
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      if (knipResult.success) {
-        cacheManager.writeCache("knip", knipResult, analysisRoot, {
-          scanDurationMs: Date.now() - startMs
-        });
-      }
-      dbg(`session_start Knip scan done (${Date.now() - startMs}ms)`);
-    }
-  });
-  runHeavyweightTask("jscpd", async () => {
-    if (await jscpdClient.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      const isTsProject = nodeFs.existsSync(path.join(analysisRoot, "tsconfig.json"));
-      const scannerKey = isTsProject ? "jscpd-ts" : "jscpd";
-      const cached = cacheManager.readCache(scannerKey, analysisRoot);
-      if (cached) {
-        if (!runtime.isCurrentSession(sessionGeneration))
-          return;
-        dbg(`session_start jscpd: cache hit (${scannerKey})`);
-      } else {
-        const startMs = Date.now();
-        const jscpdResult = await jscpdClient.scan(analysisRoot, undefined, undefined, isTsProject);
-        if (!runtime.isCurrentSession(sessionGeneration))
-          return;
-        if (jscpdResult.success) {
-          cacheManager.writeCache(scannerKey, jscpdResult, analysisRoot, {
-            scanDurationMs: Date.now() - startMs
-          });
-        }
-        dbg(`session_start jscpd scan done (${Date.now() - startMs}ms, isTsProject=${isTsProject})`);
-      }
-    } else {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg("session_start jscpd: not available");
-    }
-  });
-  runHeavyweightTask("dead-code", async () => {
-    const applicable = deadCodeClients.filter((c) => c.detect(analysisRoot));
-    if (applicable.length === 0)
-      return;
-    await Promise.all(applicable.map(async (client) => {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      const cacheKey = `dead-code-${client.id}`;
-      const cached = cacheManager.readCache(cacheKey, analysisRoot);
-      if (cached) {
-        dbg(`session_start dead-code(${client.id}): cache hit`);
-        return;
-      }
-      const startMs = Date.now();
-      const result = await client.analyze(analysisRoot);
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      if (result.success) {
-        cacheManager.writeCache(cacheKey, result, analysisRoot, {
-          scanDurationMs: Date.now() - startMs
-        });
-      }
-      logDeadCodeScan({
-        language: client.language,
-        success: result.success,
-        cached: false,
-        unusedExports: result.unusedExports.length,
-        unusedFiles: result.unusedFiles.length,
-        unusedDeps: result.unusedDeps.length,
-        unlistedDeps: result.unlistedDeps.length,
-        durationMs: result.durationMs ?? Date.now() - startMs,
-        ...!result.success && { reason: result.summary }
-      });
-      dbg(`session_start dead-code(${client.id}) done (${Date.now() - startMs}ms, ${deadCodeIssueCount(result)} issues)`);
-    }));
-  });
-  runHeavyweightTask("govulncheck", async () => {
-    if (!GovulncheckClient.hasGoModule(analysisRoot)) {
-      dbg("session_start govulncheck: no go.mod — skipped");
-      return;
-    }
-    if (!await govulncheckClient.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg("session_start govulncheck: not installed (go install golang.org/x/vuln/cmd/govulncheck@latest)");
-      return;
-    }
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const cached = cacheManager.readCache("govulncheck", analysisRoot);
-    if (cached) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg(`session_start govulncheck: cache hit (${cached.data.findings.length} findings)`);
-      return;
-    }
-    const startMs = Date.now();
-    const result = await govulncheckClient.analyze(analysisRoot);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    if (result.success) {
-      cacheManager.writeCache("govulncheck", result, analysisRoot, {
-        scanDurationMs: Date.now() - startMs
-      });
-    }
-    dbg(`session_start govulncheck: ${result.findings.length} reachable findings (${Date.now() - startMs}ms)`);
-  });
-  runHeavyweightTask("gitleaks", async () => {
-    if (!GitleaksClient.hasGitleaksSignal(analysisRoot)) {
-      dbg("session_start gitleaks: no opt-in signal — skipped");
-      return;
-    }
-    if (!await gitleaksClient.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg("session_start gitleaks: not available (install failed?)");
-      return;
-    }
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const cached = cacheManager.readCache("gitleaks", analysisRoot);
-    if (cached) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg(`session_start gitleaks: cache hit (${cached.data.findings.length} findings)`);
-      return;
-    }
-    const startMs = Date.now();
-    const result = await gitleaksClient.scan(analysisRoot);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    if (result.success) {
-      cacheManager.writeCache("gitleaks", result, analysisRoot, {
-        scanDurationMs: Date.now() - startMs
-      });
-    }
-    dbg(`session_start gitleaks: ${result.findings.length} findings (${Date.now() - startMs}ms)`);
-  });
-  runHeavyweightTask("opengrep", async () => {
-    if (!await opengrepClient.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg("session_start opengrep: not available (install failed?)");
-      return;
-    }
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const cached = cacheManager.readCache("opengrep", analysisRoot);
-    if (cached) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg(`session_start opengrep: cache hit (${cached.data.findings.length} findings)`);
-      return;
-    }
-    const startMs = Date.now();
-    const result = await opengrepClient.scan(analysisRoot);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    if (result.success) {
-      cacheManager.writeCache("opengrep", result, analysisRoot, {
-        scanDurationMs: Date.now() - startMs
-      });
-    }
-    dbg(`session_start opengrep: ${result.findings.length} findings (${Date.now() - startMs}ms)`);
-  });
-  runHeavyweightTask("madge", async () => {
-    if (!await depChecker.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg("session_start madge: not available");
-      return;
-    }
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const cached = cacheManager.readCache("madge", analysisRoot);
-    if (cached) {
-      dbg(`session_start madge: cache hit (${cached.data.circular.length} cycles)`);
-      return;
-    }
-    const startMs = Date.now();
-    const result = await depChecker.scanProject(analysisRoot);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    cacheManager.writeCache("madge", result, analysisRoot, {
-      scanDurationMs: Date.now() - startMs
-    });
-    dbg(`session_start madge: ${result.circular.length} circular dependency chain(s) (${Date.now() - startMs}ms)`);
-  });
-  runHeavyweightTask("trivy", async () => {
-    if (!TrivyClient.shouldScan(analysisRoot)) {
-      dbg("session_start trivy: not enabled / no dependency manifest — skipped");
-      return;
-    }
-    if (!await trivyClient.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg("session_start trivy: not available (install failed?)");
-      return;
-    }
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const cached = cacheManager.readCache("trivy", analysisRoot);
-    if (cached) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg(`session_start trivy: cache hit (${cached.data.findings.length} findings)`);
-      return;
-    }
-    const startMs = Date.now();
-    const result = await trivyClient.scan(analysisRoot);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    if (result.success) {
-      cacheManager.writeCache("trivy", result, analysisRoot, {
-        scanDurationMs: Date.now() - startMs
-      });
-    }
-    dbg(`session_start trivy: ${result.findings.length} CVE findings (${Date.now() - startMs}ms)`);
-  });
-  let callGraphIdentity;
-  const callGraphTask = runTask("call-graph", async () => {
-    const { FactStore } = await import("./dispatch/fact-store.js");
-    const { buildOrUpdateGraph, extractSymbolsAndRefsFromGraph, getReviewGraphCacheIdentity } = await import("./review-graph/builder.js");
-    const { buildCallGraph, saveCallGraph, loadCallGraph } = await import("./call-graph.js");
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const startMs = Date.now();
-    const sessionFacts = new FactStore("runtime-session-call-graph");
-    const graph = await buildOrUpdateGraph(analysisRoot, [], sessionFacts);
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    const identity = getReviewGraphCacheIdentity(analysisRoot, graph);
-    if (!identity) {
-      dbg("session_start call-graph: canonical review-graph identity unavailable");
-      return;
-    }
-    callGraphIdentity = {
-      reviewGraphVersion: identity.version,
-      reviewGraphSignature: identity.signature
-    };
-    const cached = loadCallGraph(snapshotRoot, {
-      reviewGraphVersion: identity.version,
-      reviewGraphSignature: identity.signature
-    });
-    if (cached) {
-      runtime.callGraph = cached.graph;
-      dbg(`session_start call-graph: loaded from cache (${cached.graph.edges.length} edges, ${cached.graph.callers.size} callee entries, ${Date.now() - startMs}ms)`);
-      return;
-    }
-    const { allSymbols, allRefs, coverage } = extractSymbolsAndRefsFromGraph(graph);
-    const callGraph = buildCallGraph(allSymbols, allRefs, coverage);
-    runtime.callGraph = callGraph;
-    saveCallGraph(snapshotRoot, callGraph, {
-      reviewGraphVersion: identity.version,
-      reviewGraphSignature: identity.signature
-    });
-    dbg(`session_start call-graph: built ${callGraph.edges.length} edges, ${callGraph.callers.size} callee entries (${Date.now() - startMs}ms)`);
-  });
-  runTask("codebase-model", async () => {
-    await callGraphTask;
-    if (!runtime.isCurrentSession(sessionGeneration))
-      return;
-    if (!runtime.callGraph)
-      return;
-    const { buildCodebaseModel, saveCodebaseModel, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET } = await import("./codebase-model.js");
-    if (!callGraphIdentity)
-      return;
-    const model = buildCodebaseModel(runtime.callGraph, analysisRoot, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, callGraphIdentity);
-    saveCodebaseModel(snapshotRoot, model);
-    const top3 = model.entries.slice(0, 3).map((e) => e.name).join(", ");
-    dbg(`session_start codebase-model: ${model.entries.length} entries, ${model.totalTokens} tokens, top symbols: ${top3 || "(none)"}`);
-  });
-  runTask("ast-grep-exports", async () => {
-    if (await astGrepClient.ensureAvailable()) {
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      const exports = await astGrepClient.scanExports(analysisRoot, "typescript");
-      if (!runtime.isCurrentSession(sessionGeneration))
-        return;
-      dbg(`session_start exports scan: ${exports.size} functions found`);
-      for (const [name, file] of exports) {
-        runtime.cachedExports.set(name, file);
-      }
-      saveRuntimeProjectSnapshot({ cwd: snapshotRoot, runtime, dbg });
-    }
-  });
-  runTask("word-index", async () => {
-    await buildOrRefreshWordIndex({
-      runtime,
-      sessionGeneration,
-      analysisRoot,
-      snapshotRoot,
-      dbg
-    });
-  });
-}
-function scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
-  (async () => {
-    const resolved = await demandBootstrapDeps(deps, "session-start-tool-probes");
-    if (!resolved) {
-      dbg("session_start tools: analyzer bootstrap unavailable — no probes");
-      return;
-    }
-    scheduleDeferredToolProbesWithClients(resolved, languageProfile, startupDefaults, startupScansWillRun, dbg);
-  })();
-}
-function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
-  const { biomeClient, ruffClient, depChecker } = deps;
-  const defaultTools = new Set(startupDefaults);
-  const probes = [];
-  if (languageProfile.present.jsts && !defaultTools.has("biome")) {
-    probes.push(["biome", () => biomeClient.ensureAvailable()]);
-  }
-  if (languageProfile.present.python && !defaultTools.has("ruff")) {
-    probes.push(["ruff", () => ruffClient.ensureAvailable()]);
-  }
-  if (startupScansWillRun) {
-    probes.push(["madge", () => depChecker.ensureAvailable()]);
-  }
-  if (probes.length === 0) {
-    dbg("session_start tools: no deferred availability probes needed");
-    return;
-  }
-  (async () => {
-    const warmStart = Date.now();
-    const results = await Promise.all(probes.map(async ([name, run]) => {
-      try {
-        return [name, await run()];
-      } catch (err) {
-        dbg(`session_start: ${name} availability check failed: ${err}`);
-        return [name, false];
-      }
-    }));
-    const summary = results.map(([name, ready]) => `${name}=${ready}`).join(" ");
-    dbg(`session_start tools (deferred probes complete, ${Date.now() - warmStart}ms): ${summary}`);
-  })();
-}
-export const SESSION_START_GUIDANCE = [
-  `\uD83D\uDCCC dm-lens active — automated checks run on every edit/write; blocking errors (including pre-existing) show inline and must be fixed.
-` + `Key tools (see each tool's own description for args):
-` + `• lens_diagnostics — source=session reads cache; empty cache ≠ clean; use source=lsp scope=paths for changed files with absent or stale findings (aggregate hosts: lens(action=diagnostics)).
-` + `• symbol_search → module_report → read_symbol/read_enclosing — ranked identifier search, then navigable outline/callback handles + exact body reads; cheaper than reading a whole file before editing.
-` + "• Situational (activate via dm_lens_activate_tools): lsp_navigation, ast_grep_search, ast_grep_replace. Use ast_grep_search with dump=true to inspect AST nodes."
-];
-export async function handleSessionStart(deps) {
-  resetDegradationLedger();
-  resetAnalyzerBootstrapSessionState();
-  resetProjectDataDirSessionState();
-  resetTestRunnerDelivery();
-  resetLspMutationNoBridgeDbgLatch();
-  resetBoundedTelemetry();
-  rotateMessageEndAttribution();
-  const handlerEnteredAt = Date.now();
-  const sessionStartMs = deps.sessionStartFiredAt ?? handlerEnteredAt;
-  const cwdForTelemetry = deps.ctxCwd ?? process.cwd();
-  if (deps.sessionStartFiredAt !== undefined) {
-    logLatency({
-      type: "phase",
-      filePath: cwdForTelemetry,
-      phase: "session_start_prehandler",
-      startedAt: new Date(deps.sessionStartFiredAt).toISOString(),
-      durationMs: (deps.handlerEnteredAt ?? handlerEnteredAt) - deps.sessionStartFiredAt,
-      metadata: { reason: deps.sessionReason }
-    });
-  }
-  let startupMode = resolveStartupMode(deps.projectConfig, deps.globalConfig);
-  const processGlobals = globalThis;
-  const isFirstSessionOfProcess = !processGlobals.__piLensFirstSessionDone;
-  if (isFirstSessionOfProcess && process.env.DM_LENS_COLD_START_QUICK !== "0" && !process.env.DM_LENS_STARTUP_MODE && !deps.projectConfig?.startup?.mode && !deps.globalConfig?.startup?.mode) {
-    startupMode = deps.startupModeOverride ?? "quick";
-  }
-  processGlobals.__piLensFirstSessionDone = true;
-  let warmupOwnSnapshotRead;
-  if (startupMode === "quick" && !isPrintMode() && process.env.DM_LENS_COLD_START_QUICK !== "0" && !processGlobals.__piLensWarmupScheduled) {
-    processGlobals.__piLensWarmupScheduled = true;
-    const warmupDelayMs = Number(process.env.DM_LENS_WARMUP_DELAY_MS ?? 2000);
-    const warmupCwd = deps.ctxCwd ?? process.cwd();
-    const warmupDbg = deps.dbg;
-    const warmupTimer = setTimeout(() => {
-      const warmupStartedAt = Date.now();
-      (async () => {
-        try {
-          warmupDbg("warmup: starting background warmup");
-          const scanContextStartedAt = Date.now();
-          const startupScanModule = await import("./startup-scan.js");
-          const languageProfileModule = await import("./language-profile.js");
-          const warmupSnapshotRoot = resolveSnapshotRoot(warmupCwd);
-          const cachedSnapshot = loadProjectSnapshot(warmupSnapshotRoot);
-          warmupOwnSnapshotRead = cachedSnapshot ? {
-            version: cachedSnapshot.version,
-            seq: cachedSnapshot.seq,
-            cachedExports: cachedSnapshot.cachedExports,
-            projectRulesScan: cachedSnapshot.projectRulesScan
-          } : null;
-          const cachedVerdict = cachedSnapshot?.startupScan;
-          let scan;
-          if (cachedVerdict && startupScanModule.isStartupScanVerdictFresh(cachedVerdict)) {
-            scan = { ...cachedVerdict, cwd: path.resolve(warmupCwd) };
-            warmupDbg(`warmup: scan-context reused from cache (canWarm=${scan.canWarmCaches}${scan.reason ? `, reason=${scan.reason}` : ""})`);
-          } else {
-            scan = await startupScanModule.resolveStartupScanContextAsync(warmupCwd);
-            logLatency({
-              type: "phase",
-              phase: "session_start_scan_context_compute",
-              filePath: warmupCwd,
-              startedAt: new Date(scanContextStartedAt).toISOString(),
-              durationMs: Date.now() - scanContextStartedAt,
-              metadata: { mode: "quick-background" }
-            });
-            warmupDbg(`warmup: scan-context done in ${Date.now() - warmupStartedAt}ms (canWarm=${scan.canWarmCaches})`);
-            saveRuntimeProjectSnapshot({
-              cwd: warmupSnapshotRoot,
-              runtime: deps.runtime,
-              startupScan: scan,
-              dbg: warmupDbg
-            });
-          }
-          logLatency({
-            type: "phase",
-            phase: "warmup_scan_context",
-            filePath: warmupCwd,
-            startedAt: new Date(scanContextStartedAt).toISOString(),
-            durationMs: Date.now() - scanContextStartedAt
-          });
-          if (!scan.canWarmCaches) {
-            warmupDbg(`warmup: skipping language-profile (canWarm=false, reason=${scan.reason ?? "unknown"})`);
-            return;
-          }
-          const languageRoot = scan.projectRoot ?? warmupCwd;
-          const languageProfileStartedAt = Date.now();
-          await languageProfileModule.detectProjectLanguageProfileAsync(languageRoot);
-          warmupDbg(`warmup: language-profile done in ${Date.now() - languageProfileStartedAt}ms`);
-          logLatency({
-            type: "phase",
-            phase: "warmup_language_profile",
-            filePath: warmupCwd,
-            startedAt: new Date(languageProfileStartedAt).toISOString(),
-            durationMs: Date.now() - languageProfileStartedAt
-          });
-          const wordIndexStartedAt = Date.now();
-          const wordIndexResult = await buildOrRefreshWordIndex({
-            runtime: deps.runtime,
-            sessionGeneration: deps.runtime.sessionGeneration,
-            analysisRoot: languageRoot,
-            snapshotRoot: warmupSnapshotRoot,
-            dbg: warmupDbg
-          });
-          warmupDbg(`warmup: word-index done in ${Date.now() - wordIndexStartedAt}ms`);
-          logLatency({
-            type: "phase",
-            phase: "warmup_word_index",
-            filePath: warmupCwd,
-            startedAt: new Date(wordIndexStartedAt).toISOString(),
-            durationMs: Date.now() - wordIndexStartedAt,
-            metadata: wordIndexResult ? { ...wordIndexResult } : undefined
-          });
-          const lspPrewarmStartedAt = Date.now();
-          if (deps.getFlag("no-lsp")) {
-            warmupDbg("warmup: skipping LSP pre-warm (no-lsp)");
-          } else if (isSubagentSession()) {
-            warmupDbg("warmup: skipping LSP pre-warm (subagent session)");
-          } else if (isWarmAttached()) {
-            warmupDbg("warmup: skipping LSP pre-warm (attached to incumbent)");
-          } else {
-            const lspConfig = await loadLSPConfig(warmupCwd).catch(() => ({
-              warmFiles: []
-            }));
-            const warmFiles = lspConfig.warmFiles ?? [];
-            if (warmFiles.length > 0) {
-              await igniteWarmFiles(warmupCwd, warmFiles, deps.runtime, deps.runtime.sessionGeneration, warmupDbg);
-            } else {
-              await igniteDominantLanguageWarm(languageRoot, deps.runtime, deps.runtime.sessionGeneration, warmupDbg);
-            }
-            logLatency({
-              type: "phase",
-              phase: "warmup_lsp_prewarm",
-              filePath: warmupCwd,
-              startedAt: new Date(lspPrewarmStartedAt).toISOString(),
-              durationMs: Date.now() - lspPrewarmStartedAt
-            });
-            warmupDbg(`warmup: lsp-prewarm done in ${Date.now() - lspPrewarmStartedAt}ms`);
-          }
-          warmupDbg(`warmup: total ${Date.now() - warmupStartedAt}ms`);
-        } catch (err) {
-          warmupDbg(`warmup: error ${err}`);
-          processGlobals.__piLensWarmupScheduled = false;
-        } finally {
-          logLatency({
-            type: "phase",
-            phase: "warmup_total",
-            filePath: warmupCwd,
-            startedAt: new Date(warmupStartedAt).toISOString(),
-            durationMs: Date.now() - warmupStartedAt
-          });
-        }
-      })();
-    }, warmupDelayMs);
-    warmupTimer.unref?.();
-  }
-  const allowBootstrapTasks = startupMode === "full";
-  const quickMode = startupMode === "quick";
-  const { ctxCwd, getFlag, notify, dbg, log, runtime, cacheManager, ensureTool, cleanStaleTsBuildInfo, resetDispatchBaselines, resetLSPService } = deps;
-  let _phaseT = Date.now();
-  const phase = (name) => {
-    dbg(`session_start phase ${name}: ${Date.now() - _phaseT}ms`);
-    _phaseT = Date.now();
-  };
-  deps.bootstrap.peek()?.metricsClient.reset();
-  getDiagnosticTracker().reset();
-  clearFileTimeSessions();
-  runtime.complexityBaselines.clear();
-  resetDispatchBaselines(ctxCwd);
-  resetWorkspaceTopology();
-  resetOpaqueMutationState();
-  resetObservedMutationNet();
-  resetMutationAttribution();
-  primePersistedMutationAttribution(ctxCwd);
-  resetPendingAuxiliaryCoverage();
-  resetSafeSpawnWindowsCommandCache();
-  resetDispatchAvailabilityState();
-  resetObservedRunnerLatency();
-  resetPendingRunnerFindings();
-  resetSpawnTimeoutCooldowns();
-  clearFormatterCache();
-  resetZizmorTokenAvailability();
-  resetGoAvailability();
-  resetRustAvailability();
-  resetPsScriptAnalyzerAvailability();
-  resetInstallRetryLatches();
-  resetLazyInstallAttempts();
-  resetDirectLspCommandAvailability();
-  resetLSPCaseSensitivityState();
-  resetResolvedPathCache();
-  _resetPackageManagerCache();
-  resetManagedToolRefreshSession();
-  resetSmellsSessionState();
-  resetSituationalToolTelemetry();
-  resetWorkspaceDiagnosticsCacheSession(sessionStartMs);
-  deps.bootstrap.peek()?.knipClient.resetSessionState?.();
-  resetCascadeTierSessionState();
-  runtime.resetForSession(sessionStartMs);
-  logLatency({
-    type: "phase",
-    phase: "session_start_runtime_reset",
-    filePath: ctxCwd ?? process.cwd(),
-    startedAt: new Date(handlerEnteredAt).toISOString(),
-    durationMs: Date.now() - handlerEnteredAt,
-    metadata: { mode: startupMode, reason: deps.sessionReason }
-  });
-  const cleanupCwd = ctxCwd ?? process.cwd();
-  setImmediate(() => {
-    const logCleanupStartedAt = Date.now();
-    try {
-      const logCleanup = runLogCleanup(dbg);
-      logLatency({
-        type: "phase",
-        phase: "session_start_log_cleanup",
-        filePath: cleanupCwd,
-        startedAt: new Date(logCleanupStartedAt).toISOString(),
-        durationMs: Date.now() - logCleanupStartedAt,
-        metadata: {
-          mode: startupMode,
-          reason: deps.sessionReason,
-          deferred: true
-        }
-      });
-      if (logCleanup.cleaned > 0 || logCleanup.rotated > 0) {
-        notify(`\uD83E\uDDF9 ${logCleanup.report}`, "info");
-      }
-    } catch (err) {
-      dbg(`session_start: deferred log cleanup failed: ${err}`);
-    }
-  });
-  dbg(`session_start startup mode: ${startupMode}`);
-  if (!getFlag("no-lsp")) {
-    resetLSPService({ fast: true, reason: "session_start" });
-    dbg("session_start: LSP service reset");
-    dbg("session_start: phase0 workspace diagnostics observation enabled (capability probe only)");
-  }
-  const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
-  const cwd = ctxCwd ?? process.cwd();
-  const projectDataDir = getProjectDataDir(cwd);
-  for (const migration of drainProjectDataDirMigrations()) {
-    const targetName = path.basename(migration.to);
-    const hash = targetName.match(/([0-9a-f]{8})$/)?.[1] ?? "unknown";
-    recordDegradationOnce({
-      kind: "data_dir_migrated",
-      subject: hash,
-      reason: migration.outcome === "renamed" ? "using hashed directory after renaming legacy directory" : migration.outcome === "coexisting" ? "using hashed directory because legacy and hashed directories both exist" : migration.outcome === "rename-failed" ? "using legacy directory after hashed-directory rename failure" : "using resolved directory after realpath fallback"
-    });
-  }
-  const globalDir = getGlobalDmLensDir();
-  sweepAtomicWriteStages([
-    projectDataDir,
-    path.join(projectDataDir, "cache"),
-    path.join(projectDataDir, "sessions"),
-    globalDir,
-    path.join(globalDir, "bin"),
-    path.join(globalDir, "tools")
-  ]).catch(() => {});
-  if (quickMode) {
-    runtime.projectRoot = cwd;
-    const sequenceReadStartedAt = Date.now();
-    const snapshotRoot = resolveSnapshotRoot(cwd);
-    const { latestSeq, timedOut } = await readSequenceWithBudget({
-      snapshotRoot,
-      base: snapshotSequenceBase(snapshotRoot),
-      cwd,
-      runtime,
-      sessionGeneration: runtime.sessionGeneration,
-      dbg,
-      onDeferredSequenceResolved: retroactivelyHydrateAfterDeferredSequence({
-        getWarmupOwnSnapshotRead: () => warmupOwnSnapshotRead,
-        snapshotRoot,
-        runtime,
-        dbg
-      })
-    });
-    logLatency({
-      type: "phase",
-      phase: "session_start_sequence_read",
-      filePath: cwd,
-      startedAt: new Date(sequenceReadStartedAt).toISOString(),
-      durationMs: Date.now() - sequenceReadStartedAt,
-      metadata: { entries: latestSeq.fileSeqByPath.size, timedOut }
-    });
-    if (timedOut) {
-      recordSnapshotSequenceTimeout({
-        snapshotRoot,
-        snapshotPath: getProjectSnapshotPath(snapshotRoot)
-      });
-    }
-    runtime.seedProjectSequence?.(latestSeq.projectSeq, latestSeq.fileSeqByPath);
-    const effectiveSeq = runtime.projectSeq ?? latestSeq.projectSeq;
-    dbg(`session_start sequence: projectSeq=${effectiveSeq} fileSeqEntries=${latestSeq.fileSeqByPath.size}`);
-    const freshnessSeq = timedOut ? UNKNOWN_PROJECT_SEQ : effectiveSeq;
-    const snapshotLoadStartedAt = Date.now();
-    const snapshotPath = getProjectSnapshotPath(snapshotRoot);
-    let snapshotBytes = 0;
-    try {
-      snapshotBytes = nodeFs.statSync(snapshotPath).size;
-    } catch {}
-    const snapshotBodyPresent = nodeFs.existsSync(snapshotPath) || nodeFs.existsSync(getProjectSnapshotLegacyPath(snapshotRoot));
-    const snapshotGate = loadSnapshotBodyUnlessStale({
-      root: snapshotRoot,
-      currentProjectSeq: freshnessSeq,
-      dbg
-    });
-    const snapshot = snapshotGate.snapshot;
-    const snapshotFresh = isProjectSnapshotFresh(snapshot, freshnessSeq);
-    const snapshotMissReason = describeSnapshotMiss(snapshot, freshnessSeq, {
-      skippedStale: snapshotGate.skippedStale,
-      bodyPresent: snapshotBodyPresent
-    });
-    logLatency({
-      type: "phase",
-      phase: "session_start_snapshot_load",
-      filePath: cwd,
-      startedAt: new Date(snapshotLoadStartedAt).toISOString(),
-      durationMs: Date.now() - snapshotLoadStartedAt,
-      metadata: {
-        bytes: snapshotBytes,
-        fresh: snapshotFresh,
-        seq: snapshot?.seq ?? null,
-        reason: snapshotFresh ? undefined : snapshotMissReason,
-        ...snapshotGate.skippedStale ? { skippedStale: true } : {},
-        ...timedOut ? { sequenceUnknown: true } : {}
-      }
-    });
-    logProjectSnapshotProbe({
-      dbg,
-      root: snapshotRoot,
-      currentProjectSeq: freshnessSeq,
-      snapshot,
-      missReason: snapshotMissReason
-    });
-    if (snapshotFresh) {
-      hydrateRuntimeFromProjectSnapshot(runtime, snapshot);
-    }
-    const quickTools = [];
-    if (!getFlag("no-lsp")) {
-      quickTools.push("LSP Service");
-    }
-    log(`Active tools: ${quickTools.join(", ")}`);
-    dbg(`session_start tools: ${quickTools.join(", ") || "deferred (quick mode)"}`);
-    dbg("session_start: quick mode active - skipping slow tool probes, language profiling, preinstall, scans, and error debt baseline");
-    logLatency({
-      type: "phase",
-      phase: "session_start_skipped_steps",
-      filePath: cwd,
-      durationMs: 0,
-      metadata: {
-        mode: startupMode,
-        reason: deps.sessionReason,
-        steps: [
-          "slow_tool_probes",
-          "language_profiling",
-          "tool_preinstall",
-          "startup_scans",
-          "error_debt_baseline"
-        ]
-      }
-    });
-    const totalDurationMs = Date.now() - sessionStartMs;
-    dbg(`session_start total: ${totalDurationMs}ms (interactive path)`);
-    logLatency({
-      type: "phase",
-      phase: "session_start_total",
-      filePath: cwd,
-      startedAt: new Date(sessionStartMs).toISOString(),
-      durationMs: totalDurationMs,
-      metadata: {
-        mode: startupMode,
-        reason: deps.sessionReason,
-        classification: deps.sessionStartClassification,
-        sameRoot: deps.sessionStartSameRoot ?? "unknown"
-      }
-    });
-    logHostReadyDelay(deps, cwd);
-    emitSmellsSessionStartLine(dbg, sessionStartMs);
-    return;
-  }
-  const tools = [];
-  if (!getFlag("no-lsp"))
-    tools.push("LSP Service");
-  if (allowBootstrapTasks && !getFlag("no-lsp")) {
-    const cleaned = cleanStaleTsBuildInfo(ctxCwd ?? process.cwd());
-    if (cleaned.length > 0) {
-      notify(`\uD83E\uDDF9 Deleted stale TypeScript build cache (${cleaned.map((f) => path.basename(f)).join(", ")}) — phantom errors suppressed.`, "warning");
-      dbg(`session_start: cleaned stale tsbuildinfo: ${cleaned.join(", ")}`);
-    }
-  }
-  const sessionGeneration = runtime.sessionGeneration;
-  const sequenceReadStartedAt = Date.now();
-  const snapshotRoot = resolveSnapshotRoot(cwd);
-  const { latestSeq, timedOut } = await readSequenceWithBudget({
-    snapshotRoot,
-    base: snapshotSequenceBase(snapshotRoot),
-    cwd,
-    runtime,
-    sessionGeneration,
-    dbg
-  });
-  logLatency({
-    type: "phase",
-    phase: "session_start_sequence_read",
-    filePath: cwd,
-    startedAt: new Date(sequenceReadStartedAt).toISOString(),
-    durationMs: Date.now() - sequenceReadStartedAt,
-    metadata: { entries: latestSeq.fileSeqByPath.size, timedOut }
-  });
-  if (timedOut) {
-    recordSnapshotSequenceTimeout({
-      snapshotRoot,
-      snapshotPath: getProjectSnapshotPath(snapshotRoot)
-    });
-  }
-  runtime.seedProjectSequence?.(latestSeq.projectSeq, latestSeq.fileSeqByPath);
-  const effectiveSeq = runtime.projectSeq ?? latestSeq.projectSeq;
-  dbg(`session_start sequence: projectSeq=${effectiveSeq} fileSeqEntries=${latestSeq.fileSeqByPath.size}`);
-  const freshnessSeq = timedOut ? UNKNOWN_PROJECT_SEQ : effectiveSeq;
-  const snapshotLoadStartedAt = Date.now();
-  const snapshotPath = getProjectSnapshotPath(snapshotRoot);
-  let snapshotBytes = 0;
-  try {
-    snapshotBytes = nodeFs.statSync(snapshotPath).size;
-  } catch {}
-  const snapshotBodyPresent = nodeFs.existsSync(snapshotPath) || nodeFs.existsSync(getProjectSnapshotLegacyPath(snapshotRoot));
-  const snapshotGate = loadSnapshotBodyUnlessStale({
-    root: snapshotRoot,
-    currentProjectSeq: freshnessSeq,
-    dbg
-  });
-  const snapshot = snapshotGate.snapshot;
-  const snapshotFresh = isProjectSnapshotFresh(snapshot, freshnessSeq);
-  const snapshotMissReason = describeSnapshotMiss(snapshot, freshnessSeq, {
-    skippedStale: snapshotGate.skippedStale,
-    bodyPresent: snapshotBodyPresent
-  });
-  logLatency({
-    type: "phase",
-    phase: "session_start_snapshot_load",
-    filePath: cwd,
-    startedAt: new Date(snapshotLoadStartedAt).toISOString(),
-    durationMs: Date.now() - snapshotLoadStartedAt,
-    metadata: {
-      bytes: snapshotBytes,
-      fresh: snapshotFresh,
-      seq: snapshot?.seq ?? null,
-      reason: snapshotFresh ? undefined : snapshotMissReason,
-      ...snapshotGate.skippedStale ? { skippedStale: true } : {},
-      ...timedOut ? { sequenceUnknown: true } : {}
-    }
-  });
-  logProjectSnapshotProbe({
-    dbg,
-    root: snapshotRoot,
-    currentProjectSeq: freshnessSeq,
-    snapshot,
-    missReason: snapshotMissReason
-  });
-  const freshSnapshot = snapshotFresh ? snapshot : null;
-  if (freshSnapshot) {
-    hydrateRuntimeFromProjectSnapshot(runtime, freshSnapshot);
-  }
-  const cachedStartupScan = freshSnapshot?.startupScan && isStartupScanVerdictFresh(freshSnapshot.startupScan) ? freshSnapshot.startupScan : undefined;
-  const startupScanSource = cachedStartupScan ? "snapshot" : "computed";
-  let startupScan;
-  if (cachedStartupScan) {
-    startupScan = { ...cachedStartupScan, cwd: path.resolve(cwd) };
-  } else {
-    const scanContextStartedAt = Date.now();
-    startupScan = resolveStartupScanContext(cwd);
-    logLatency({
-      type: "phase",
-      phase: "session_start_scan_context_compute",
-      filePath: cwd,
-      startedAt: new Date(scanContextStartedAt).toISOString(),
-      durationMs: Date.now() - scanContextStartedAt,
-      metadata: { mode: startupMode }
-    });
-  }
-  phase("scan-context");
-  dbg(`session_start scan-context source=${startupScanSource}`);
-  const scanRoot = startupScan.projectRoot ?? cwd;
-  const useScanRootForSignals = startupScan.canWarmCaches || startupScan.reason === "too-many-source-files" || startupScan.reason === "too-many-entries";
-  const analysisRoot = useScanRootForSignals ? scanRoot : cwd;
-  runtime.projectRoot = cwd;
-  const languageProfileSource = freshSnapshot?.languageProfile ? "snapshot" : "computed";
-  const languageProfile = freshSnapshot?.languageProfile ? freshSnapshot.languageProfile : detectProjectLanguageProfile(analysisRoot, startupScan.canWarmCaches ? undefined : []);
-  phase("language-profile");
-  dbg(`session_start language-profile source=${languageProfileSource}`);
-  dbg(`session_start cwd: ${cwd}`);
-  dbg(`session_start scan root: ${scanRoot} (warmCaches=${startupScan.canWarmCaches}${startupScan.reason ? `, reason=${startupScan.reason}` : ""})`);
-  dbg(`session_start analysis root: ${analysisRoot}`);
-  dbg(`session_start workspace root: ${runtime.projectRoot}`);
-  dbg(`session_start language profile: ${languageProfile.detectedKinds.join(", ") || "none"}`);
-  dbg(`session_start language counts: ${JSON.stringify(languageProfile.counts)} configured=${JSON.stringify(languageProfile.configured)}`);
-  dbg(`session_start workspace cwd available: ${hasWorkspaceCwd}`);
-  if (useScanRootForSignals && analysisRoot !== cwd) {
-    dbg(`session_start: monorepo analysis root override -> ${analysisRoot}`);
-  }
-  const slowFsVerdict = getSlowFsVerdict(analysisRoot);
-  logLatency({
-    type: "phase",
-    phase: "slow_fs_probe",
-    filePath: analysisRoot,
-    durationMs: 0,
-    metadata: {
-      slow: slowFsVerdict.slow,
-      medianStatMicros: slowFsVerdict.medianStatMicros,
-      samples: slowFsVerdict.samples
-    }
-  });
-  dbg(`session_start slow-fs probe: slow=${slowFsVerdict.slow} medianStatMicros=${slowFsVerdict.medianStatMicros.toFixed(1)} samples=${slowFsVerdict.samples}`);
-  if (slowFsVerdict.slow) {
-    notify(`\uD83D\uDC22 Slow filesystem detected (median ${slowFsVerdict.medianStatMicros.toFixed(0)}µs/stat) — reduced-scan mode engaged (set DM_LENS_ALLOW_SLOW_FS_SCAN=1 to override).`, "warning");
-  }
-  const subagentSession = isSubagentSession();
-  if (isWarmAttached()) {
-    dbg("session_start lsp-warm: skipping pre-warm (attached to incumbent)");
-  } else if (subagentSession) {
-    const identity = getSubagentIdentity();
-    logLatency({
-      type: "phase",
-      phase: "subagent_light_mode",
-      filePath: analysisRoot,
-      durationMs: 0,
-      metadata: {
-        runId: identity?.runId,
-        agentName: identity?.agentName,
-        marker: identity?.marker
-      }
-    });
-    dbg(`session_start subagent light mode: engaged (marker=${identity?.marker ?? "unknown"} runId=${identity?.runId ?? "unknown"} agentName=${identity?.agentName ?? "unknown"})`);
-  }
-  const lensLspEnabled = !getFlag("no-lsp");
-  const startupDefaults = getDefaultStartupTools(languageProfile).filter((tool) => {
-    if ((tool === "typescript-language-server" || tool === "pyright") && !lensLspEnabled) {
-      return false;
-    }
-    return true;
-  });
-  if (!allowBootstrapTasks) {
-    dbg("session_start: skipping tool preinstall (startup mode)");
-  } else if (startupDefaults.length > 0) {
-    dbg(`session_start: pre-install defaults -> ${startupDefaults.join(", ")}`);
-    firePreinstallDefaults(ensureTool, dbg, startupDefaults);
-  } else {
-    dbg("session_start: no language defaults selected for pre-install");
-  }
-  const startupScansEnabled = deps.projectConfig?.startup?.scans?.enabled ?? deps.globalConfig?.startup?.scans?.enabled ?? true;
-  const startupScansWillRun = allowBootstrapTasks && startupScan.canWarmCaches && startupScansEnabled;
-  const jstsHeavyScansWillRun = startupScansWillRun && canRunStartupHeavyScans(languageProfile, "jsts");
-  if (allowBootstrapTasks) {
-    scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, jstsHeavyScansWillRun, dbg);
-    scheduleManagedToolRefresh(dbg);
-  }
-  if (allowBootstrapTasks) {
-    probePrettierInstall(ensureTool, dbg, analysisRoot);
-  } else {
-    dbg("session_start: skipping prettier preinstall probe (startup mode)");
-  }
-  const summaryClients = await deps.bootstrap.request("session-start-tools");
-  const detectedRunner = summaryClients?.testRunnerClient.detectRunner(analysisRoot);
-  phase("test-runner-detect");
-  if (detectedRunner)
-    tools.push(`Test runner (${detectedRunner.runner})`);
-  if (await summaryClients?.goClient.isGoAvailableAsync())
-    tools.push("Go (go vet)");
-  if (await summaryClients?.rustClient.isAvailableAsync())
-    tools.push("Rust (cargo)");
-  log(`Active tools: ${tools.join(", ")}`);
-  dbg(`session_start tools: ${tools.join(", ")}`);
-  const agentStartupGuidance = SESSION_START_GUIDANCE;
-  runtime.projectRulesScan = scanProjectRules(analysisRoot);
-  saveRuntimeProjectSnapshot({
-    cwd: snapshotRoot,
-    runtime,
-    startupScan,
-    languageProfile,
-    dbg
-  });
-  phase("project-rules");
-  if (runtime.projectRulesScan.hasCustomRules) {
-    const ruleCount = runtime.projectRulesScan.rules.length;
-    const sources = [
-      ...new Set(runtime.projectRulesScan.rules.map((r) => r.source))
-    ];
-    dbg(`session_start: found ${ruleCount} project rule(s) from ${sources.join(", ")}`);
-  } else {
-    dbg("session_start: no project rules found");
-  }
-  cacheManager.writeCache("session-start-guidance", { content: agentStartupGuidance.join(`
-`) }, analysisRoot);
-  if (!allowBootstrapTasks) {
-    dbg("session_start: skipping startup background scans (startup mode)");
-  } else if (!startupScansEnabled) {
-    dbg("session_start: skipping startup background scans (disabled by config)");
-    recordDegradationOnce({
-      kind: "startup-analyzer-disabled",
-      subject: "startup-scans",
-      reason: "skipped (disabled by config)"
-    });
-  } else if (!startupScan.canWarmCaches) {
-    dbg(`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`);
-    dbg(`session_start: skipping TODO scan (${startupScan.reason ?? "unknown"})`);
-    if (startupScan.reason === "too-many-source-files" || startupScan.reason === "too-many-entries") {
-      const overrideHint = startupScan.reason === "too-many-entries" ? ` (set DM_LENS_STARTUP_SCAN_MAX_ENTRIES=<n> to override the ${getStartupScanMaxEntries()}-entry cap)` : "";
-      notify(`\uD83D\uDCE6 Project-size limits disabled background warm scans (heavy scans, TODO scan, LSP pre-warm)${overrideHint}.`, "warning");
-    }
-  } else {
-    scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg);
-  }
-  if (subagentSession) {
-    dbg("session_start lsp-warm: skipping pre-warm (subagent session)");
-  } else if (!getFlag("no-lsp") && allowBootstrapTasks) {
-    setImmediate(() => {
-      loadLSPConfig(cwd).then((lspConfig) => {
-        const warmFiles = lspConfig.warmFiles ?? [];
-        dbg(`session_start lsp-config: loaded (${warmFiles.length} warm file(s) configured)`);
-        if (warmFiles.length > 0) {
-          igniteWarmFiles(cwd, warmFiles, runtime, sessionGeneration, dbg).catch((err) => dbg(`session_start lsp-warm: unhandled error: ${err}`));
-        } else if (startupScan.canWarmCaches) {
-          igniteDominantLanguageWarm(analysisRoot, runtime, sessionGeneration, dbg).catch((err) => dbg(`session_start lsp-warm: unhandled dominant error: ${err}`));
-        } else {
-          dbg(`session_start lsp-warm: skipping dominant-language auto-warm (${startupScan.reason ?? "unknown"})`);
-        }
-      });
-    });
-    phase("lsp-config");
-  }
-  setSessionLanguages(languageProfile.detectedKinds);
-  const totalDurationMs = Date.now() - sessionStartMs;
-  dbg(`session_start total: ${totalDurationMs}ms (interactive path; background tasks may continue)`);
-  logLatency({
-    type: "phase",
-    phase: "session_start_total",
-    filePath: cwd,
-    startedAt: new Date(sessionStartMs).toISOString(),
-    durationMs: totalDurationMs,
-    metadata: {
-      mode: startupMode,
-      reason: deps.sessionReason,
-      classification: deps.sessionStartClassification,
-      sameRoot: deps.sessionStartSameRoot ?? "unknown"
-    }
-  });
-  logHostReadyDelay(deps, cwd);
-  emitSmellsSessionStartLine(dbg, sessionStartMs);
-}
-function emitSmellsSessionStartLine(dbg, sessionStartMs) {
-  try {
-    const line = formatSmellsSessionStartLine(countRecentSmells(undefined, sessionStartMs));
-    if (line)
-      dbg(line);
-  } catch {}
-}