@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/index.js

@@ -0,0 +1,1973 @@
+import"./clients/console-guard-install.js";
+import { BoundedSet } from "./clients/bounded-cache.js";
+import { bounded, withDeadline } from "./clients/deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "./clients/hook-budgets.js";
+import { closeModuleLoadConsoleWindow, installConsoleGuard, logExtension, runInConsoleCaptureWindow, withConsoleCaptureWindows } from "./clients/extension-log.js";
+import { wireUserNotifier } from "./clients/user-notify.js";
+import { getDegradationSummary, incrementDegradationCount, recordDegradation, renderDegradationLines } from "./clients/degradation-ledger.js";
+import { TOOL_REGISTRY, toolRegistryEntryForPi } from "./clients/tool-config.js";
+import { adoptProjectTrustFromPorts, assertInstallAllowed, readProjectTrustFromContext } from "./clients/project-trust.js";
+import { modeSuppressionNote, readExtensionMode, suppressesUserNotify, supportsTuiWidget } from "./clients/extension-mode.js";
+import { randomUUID } from "node:crypto";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { performance } from "node:perf_hooks";
+import { createDefaultHostPorts } from "./clients/host-ports.js";
+import { AstGrepClient } from "./clients/ast-grep-client.js";
+import { loadBootstrapClients, markAnalyzerBootstrapShutdown, peekBootstrapClients, requestBootstrapClients, getAgentBehaviorClient } from "./clients/bootstrap.js";
+import { CacheManager } from "./clients/cache-manager.js";
+import { resolveSkillPaths } from "./clients/skills-resolver.js";
+import { getFailedLspServerIds, getSessionLanguages, reconcileCascadeNeighborLspErrors, renderWidget, scheduleStaleReconcile, setRenderCallback, wireWidgetDispositionSubscriber } from "./clients/widget-state.js";
+import { selectLspStatus } from "./clients/lsp-status.js";
+import { branchToolResultIds, logReadGuardBranchMove, READ_GUARD_CELL, readSessionHeaderId } from "./clients/read-guard-branch.js";
+import { adoptHandoff, beginScope, discardHandoff, forwardHandoff, logScopeTransition, retireScope, reserveSessionStart, scopeCell, startKey, stashHandoff, successorStartKey } from "./clients/session-scope.js";
+import { sanitizeCorrelationId } from "./clients/read-guard-logger.js";
+import { registerMutationBridge } from "./clients/mutation-bridge.js";
+import { OBSERVED_TRACKED_MAX_FILES, refreshObservedMutationLedger, runObservedSettledSweep } from "./clients/observed-mutation.js";
+import { collectTrackedPaths, replayThroughMutationBridge, storedLineHashesFor } from "./clients/observed-mutation-sources.js";
+import { classifyMutatingTool } from "./clients/mutating-tool.js";
+import { isEditClassToolResult } from "./clients/bash-file-access.js";
+import { resolveLanguageRootForFile } from "./clients/language-profile.js";
+import { countFileLines } from "./clients/read-guard-tool-lines.js";
+import { registerReadBridge } from "./clients/read-bridge.js";
+import { recordIOEntry, registerIOBridge } from "./clients/io-bridge.js";
+import { rebindableProcessBridgeDeps } from "./clients/process-bridge.js";
+import { isExternalOrVendorFile } from "./clients/path-utils.js";
+import { isPathIgnoredByProject, isRecordableProjectPath } from "./clients/file-utils.js";
+import { loadSessionState, persistScope } from "./clients/session-state-store.js";
+import { getDiagnosticTracker } from "./clients/diagnostic-tracker.js";
+import { warmDispatchIntegration, loadDispatchIntegration } from "./clients/dispatch/lazy.js";
+import { getFormatService, resetFormatService } from "./clients/format-service.js";
+import { getAllToolStatuses } from "./clients/installer/index.js";
+import { loadDmLensGlobalConfig, resolveDmLensFlag, resolveDmLensFlagWithSource } from "./clients/lens-config.js";
+import { LENS_FLAGS } from "./clients/lens-flag-registry.js";
+import { LENS_TOOL_NAMES, resolveLensToolEnabled } from "./clients/tool-config.js";
+import { recordDegradationOnce } from "./clients/degradation-ledger.js";
+import { flushAllNdjsonWriters } from "./clients/ndjson-logger.js";
+import { wrapToolsForCompactLine } from "./clients/tool-render.js";
+import { finalizeToolResultWithDelivery, renderToolText } from "./tools/render-compact.js";
+import { loadDmLensProjectConfig } from "./clients/project-lens-config.js";
+import { initLensEventsGetter } from "./clients/lens-events.js";
+import { wireBusEmitterGetter } from "./clients/bus-publish.js";
+import { wireDiagnosticsBusEmitterGetter } from "./clients/diagnostics-publish.js";
+import { wireDispositionBusEmitterGetter } from "./clients/disposition-publish.js";
+import { wireFormatEventsBusEmitterGetter } from "./clients/format-events-publish.js";
+import { emitBusEventRollupAtSessionEnd } from "./clients/bus-events-logger.js";
+import { emitFenceRollupAtSessionEnd } from "./clients/generation-guard.js";
+import { emitVerifiedPathAttributionRollup, resetVerifiedPathAttributionGuessCount } from "./clients/path-attribution-telemetry.js";
+import { consumeAgentNudge, recordCrossProcessTouches, wireAgentNudgeSubscriber } from "./clients/agent-nudge.js";
+import { readCrossProcessTouchesForSessionStart, readCrossProcessTouchesForTurnStart } from "./clients/recent-touches.js";
+import { registerCascadeTierReconcileTask } from "./clients/lsp/cascade-tier.js";
+import { buildResolvedFoundCascadeRun } from "./clients/cascade-format.js";
+import { initLSPConfig } from "./clients/lsp/config.js";
+import { getLSPService, resetLSPService } from "./clients/lsp/capabilities.js";
+import { shouldInitializeSessionRoot } from "./clients/lsp/session-roots.js";
+import { warmLspService } from "./clients/lsp-lazy.js";
+import { sweepOrphans, scheduleUntrackedOrphanSweep } from "./clients/instance-reaper.js";
+import { deregisterInstance, deregisterInstanceRoot, readInstanceRegistry, registerInstance, registerInstanceRoot } from "./clients/instance-registry.js";
+import { logVanishedInstances } from "./clients/vanished-instance-marker.js";
+import { buildMemorySample, formatMemoryHealthLine, recordMemorySampleOutcome, resetMemorySamplerCadence, shouldEmitMemorySampleAdaptive } from "./clients/memory-sampler.js";
+import { dumpActiveHandles } from "./clients/debug-handles.js";
+import { isDebugHeapEnabled, writeHeapSnapshotNow } from "./clients/debug-heap.js";
+import { checkSmellsAndNoteOnce, countRecentSmells, formatSmellsHealthLine, shouldCheckSmellsThisTurn } from "./clients/smells-rollup.js";
+import { configureWarmAttach } from "./clients/warm-attach.js";
+import { checkCrossProcessLspBudget } from "./clients/lsp-budget.js";
+import { handleAgentEnd } from "./clients/runtime-agent-end.js";
+import { consumeSessionStartGuidance, consumeTurnEndFindings } from "./clients/runtime-context.js";
+import { consumeStagedTestRunnerFindings, deliverStagedTestRunnerFindings, stageTestRunnerDelivery } from "./clients/test-runner-delivery.js";
+import { readHostModelIdentity, RuntimeCoordinator } from "./clients/runtime-coordinator.js";
+import { handleSessionStart } from "./clients/runtime-session.js";
+import { resetTurnContext } from "./clients/turn-context.js";
+import { handleToolCall } from "./clients/runtime-tool-call.js";
+import { isStaleExtensionCtxError, surfaceHandlerCrash, wrapSessionEventHandler, wrapSessionEventHandlerWithResult } from "./clients/session-event-guard.js";
+import { classifyCurrentSessionEmission, decideSessionStart, decrementSecondarySessionCount, getActivePrimaryRoot, namedSuccessorReason, expiredSuccessorReason, noteSessionShutdown, releasePrimarySession, probeCtxActive } from "./clients/session-lifecycle.js";
+import { clearLastAnalyzedStateCache, flushDebouncedToolResults, handleToolExecutionEnd, handleToolResult } from "./clients/runtime-tool-result.js";
+import { cancelLSPIdleReset, handleTurnEnd } from "./clients/runtime-turn.js";
+import { registerBuiltinQuietWindowTasks, registerQuietWindowTask, runQuietWindow } from "./clients/quiet-window.js";
+import { setAmbientAbortSignal } from "./clients/safe-spawn.js";
+import { initI18n, t } from "./i18n.js";
+import { createActivateToolsTool } from "./tools/activate-tools.js";
+import { createLensDiagnosticsTool } from "./tools/lens-diagnostics.js";
+import { createLensDiagnosticMarkTool } from "./tools/lens-diagnostic-mark.js";
+import { createAstGrepReplaceTool } from "./tools/ast-grep-replace.js";
+import { createAstGrepSearchTool } from "./tools/ast-grep-search.js";
+import { createAstGrepOutlineTool } from "./tools/ast-grep-outline.js";
+import { createLspNavigationTool } from "./tools/lsp-navigation.js";
+import { createModuleReportTool, createReadEnclosingTool, createReadSymbolTool } from "./tools/module-report.js";
+import { createProjectReportTool } from "./tools/project-report.js";
+import { createEffectiveConfigTool } from "./tools/effective-config.js";
+import { createSymbolSearchTool } from "./tools/symbol-search.js";
+import { getLastLoggedPhase, getPhaseForWindow, getRecentLoggedPhases, logLatency, resetCurrentPhaseForSession, resetOncePerSessionPhases } from "./clients/latency-logger.js";
+import { emitBounded } from "./clients/bounded-telemetry.js";
+import { getLastLiveMessageEndSessionId, noteLiveMessageEndSessionId } from "./clients/message-end-attribution.js";
+const LOOP_BLOCK_IDENTITY = "<dm-lens>";
+import { isFreshSessionStart, getRememberedLazyTools, planToolSet, recordToolSetMutation, rememberLazyTools, supportsDeferredTools } from "./clients/tool-set-policy.js";
+import { endSituationalToolTelemetry, observeSituationalToolActivation, observeSituationalToolCall, startSituationalToolTelemetrySession } from "./clients/situational-tool-telemetry.js";
+import { clearCachePrefixSession, emitCacheUsageSummaryAtSessionEnd, logCacheUsage, observeCacheContext, observeCachePrefix, recordToolResultDelivery, resetCacheFindingIdentitiesSession, recordTurnEndAdvisoryBytes } from "./clients/cache-observability.js";
+import { buildStartupTimingRecords, getDmLensEvalMs, markDmLensLoaded, getDmLensLoadedAtMs, consumeHostReadyDelayAnchor, DM_LENS_LOADED_FROM } from "./clients/startup-timing.js";
+import { toRunnerDisplayPath } from "./clients/dispatch/runner-context.js";
+import { formatTurnSummaryLine, TURN_SUMMARY_CUSTOM_TYPE } from "./clients/turn-summary.js";
+import { renderTurnSummaryMessage } from "./clients/turn-summary-render.js";
+import { getEventLoopStats, resetEventLoopMonitor, shouldLogLoopBlock, shouldLogWorstBlock, startEventLoopMonitor } from "./clients/event-loop-monitor.js";
+import { formatBuildIdentity, getBuildIdentity } from "./clients/build-identity.js";
+import { logSessionStart } from "./clients/sessionstart-logger.js";
+import { emitConcurrentSessionBindRollupAtSessionEnd, logConcurrentSessionBind, resetConcurrentSessionBindRollupCounts } from "./clients/session-start-observability.js";
+import { normalizeToolDefinition } from "./clients/tool-definition.js";
+import { warmFormatters } from "./clients/formatters-lazy.js";
+import { noteHostSessionManager, setHostFileMutationQueueLoader } from "./clients/file-mutation-queue.js";
+let loadedDispatchIntegration;
+const sessionBootstrapAccess = {
+  peek: () => peekBootstrapClients(),
+  request: (reason) => requestBootstrapClients({ reason, hook: "session_start" })
+};
+function warmDispatchAtSessionStart() {
+  warmDispatchIntegration().then((integration) => {
+    loadedDispatchIntegration = integration;
+  }).catch((err) => {
+    logExtension({
+      subsystem: "dispatch",
+      level: "warn",
+      message: `dispatch warm failed: ${err}`
+    });
+  });
+}
+function resetDispatchBaselines(cwd) {
+  loadDispatchIntegration().then(({ resetDispatchBaselines }) => {
+    resetDispatchBaselines(cwd);
+  });
+}
+const DM_LENS_LOAD_MS = markDmLensLoaded();
+const DM_LENS_LOADED_AT_MS = getDmLensLoadedAtMs();
+const DM_LENS_EVAL_MS = getDmLensEvalMs() ?? 0;
+startEventLoopMonitor();
+let lastLoggedLoopWorstMs = 0;
+let sessionWorstRealBlockMs = 0;
+let sessionSuspectedStalls = 0;
+function dbg(msg) {
+  logSessionStart(msg);
+}
+let latestEventCtx;
+function rememberEventCtx(ctx) {
+  if (ctx)
+    latestEventCtx = ctx;
+}
+function notifyUi(ctx, message, level = "info") {
+  const mode = readExtensionMode(ctx);
+  if (suppressesUserNotify(mode)) {
+    recordDegradation({
+      kind: "mode-suppression",
+      subject: "ctx.ui.notify",
+      reason: modeSuppressionNote(mode)
+    });
+    dbg(`notify ${modeSuppressionNote(mode)}: ${message.split(`
+`)[0]}`);
+    return;
+  }
+  ctx?.ui?.notify?.(message, level);
+}
+function getStableSessionId(ctx) {
+  try {
+    return ctx?.sessionManager?.getSessionId?.();
+  } catch {
+    return;
+  }
+}
+export function createHostPorts(pi, options) {
+  const context = () => options.getContext();
+  const currentMode = () => readExtensionMode(context());
+  const emit = (channel, payload) => {
+    const bus = pi.events;
+    bus?.emit?.call(bus, channel, payload);
+  };
+  const activeTools = pi;
+  return createDefaultHostPorts({
+    notify: {
+      user(message, level) {
+        const mode = currentMode();
+        if (mode === "print" || mode === "json") {
+          recordDegradation({
+            kind: "mode-suppression",
+            subject: "user degradation notice",
+            reason: modeSuppressionNote(mode)
+          });
+          return;
+        }
+        context()?.ui?.notify?.(message, level ?? "warning");
+      }
+    },
+    trust: { isProjectTrusted: () => readProjectTrustFromContext(context()) },
+    mode: {
+      current: currentMode,
+      supportsTuiWidget: () => supportsTuiWidget(currentMode()),
+      suppressesUserNotify: () => suppressesUserNotify(currentMode())
+    },
+    log: {
+      extension: logExtension,
+      debug: (message, metadata) => logExtension({ subsystem: "host", level: "debug", message, metadata }),
+      sink: (subsystem) => (entry) => logExtension({
+        subsystem,
+        level: "debug",
+        message: "host sink entry",
+        metadata: { entry }
+      })
+    },
+    emit: { bus: emit },
+    status: { set: (name, value) => context()?.ui?.setStatus?.(name, value) },
+    spawn: {
+      abortSignal: () => context()?.signal,
+      isAllowed: assertInstallAllowed
+    },
+    render: { invalidate: () => options.getRenderInvalidator?.()?.() },
+    session: { id: () => getStableSessionId(context()) },
+    workspace: {
+      cwd: () => context()?.cwd,
+      projectRoot: () => options.getProjectRoot?.()
+    },
+    flags: { get: (name) => pi.getFlag(name) },
+    tools: {
+      has: async (name) => typeof pi.getTool?.(name) !== "undefined",
+      getActive: () => activeTools.getActiveTools?.() ?? [],
+      setActive: (names) => activeTools.setActiveTools?.(names)
+    }
+  });
+}
+dbg(`dm-lens loaded: ${DM_LENS_LOAD_MS}ms after process start (from ${DM_LENS_LOADED_FROM})`);
+for (const record of buildStartupTimingRecords({
+  loadMs: DM_LENS_LOAD_MS,
+  evalMs: DM_LENS_EVAL_MS
+})) {
+  logLatency(record);
+}
+function log(_msg) {}
+const runtime = new RuntimeCoordinator;
+const cacheManager = new CacheManager;
+let _bridgeGetFlag;
+function getBridgeFlag(getter, bridge, name = "no-read-guard") {
+  try {
+    return getter?.(name);
+  } catch (err) {
+    if (!isStaleExtensionCtxError(err))
+      throw err;
+    recordDegradationOnce({
+      kind: "extension-ctx-stale",
+      subject: `${bridge}-bridge`,
+      reason: `${bridge}-bridge flag read met a stale extension ctx; treating the flag as unset`
+    });
+    return;
+  }
+}
+let _turnSummaryEmitRegistered = false;
+let _turnSummaryEmitCtxGetter;
+let _testRunnerDeliveryRegistered = false;
+let _nextTestRunnerDeliveryOwnerId = 0;
+const LSP_CONFIG_CWD_CAP = 128;
+const _lspConfigInitializedCwds = new BoundedSet(LSP_CONFIG_CWD_CAP);
+async function ensureLSPConfigInitialized(cwd) {
+  const normalizedCwd = path.resolve(cwd);
+  if (!shouldInitializeSessionRoot(normalizedCwd, _lspConfigInitializedCwds)) {
+    return;
+  }
+  await initLSPConfig(normalizedCwd);
+  _lspConfigInitializedCwds.add(normalizedCwd);
+}
+function updateRuntimeIdentityFromCtx(ctx) {
+  runtime.setTelemetryIdentity(readHostModelIdentity(ctx));
+}
+function normalizeCommandArgs(args) {
+  if (Array.isArray(args)) {
+    return args.filter((arg) => typeof arg === "string");
+  }
+  if (typeof args === "string") {
+    return args.trim().split(/\s+/).filter(Boolean);
+  }
+  return [];
+}
+function cleanStaleTsBuildInfo(cwd) {
+  const cleaned = [];
+  try {
+    const candidates = nodeFs.readdirSync(cwd).filter((f) => f.endsWith(".tsbuildinfo")).map((f) => path.join(cwd, f));
+    for (const infoPath of candidates) {
+      try {
+        const data = JSON.parse(nodeFs.readFileSync(infoPath, "utf-8"));
+        const root = data.root ?? [];
+        const dir = path.dirname(infoPath);
+        const isStale = root.some((f) => !nodeFs.existsSync(path.resolve(dir, f)));
+        if (isStale) {
+          nodeFs.unlinkSync(infoPath);
+          cleaned.push(infoPath);
+        }
+      } catch {}
+    }
+  } catch {}
+  return cleaned;
+}
+function activateExtension(hostPi) {
+  const pi = withConsoleCaptureWindows(hostPi);
+  setHostFileMutationQueueLoader(() => import("@duckmind/dm-coding-agent"));
+  const testRunnerDeliveryOwnerId = `activation-${++_nextTestRunnerDeliveryOwnerId}`;
+  let ownEventCtx;
+  let ownedSessionRole;
+  const secondaryRootHolder = `secondary:${randomUUID()}`;
+  let ownedSecondaryRoot;
+  let scope;
+  let turnStartScope;
+  let startInFlight;
+  const classifyOwnedSessionEmission = (ctx, sessionId) => ownedSessionRole ?? classifyCurrentSessionEmission(ctx, sessionId);
+  const classifyOwnedSessionShutdown = (ctx, sessionId, root) => ownedSessionRole === "concurrent-secondary" ? "secondary" : ownedSessionRole === "primary" ? "primary" : noteSessionShutdown(ctx, sessionId, root, startKey(getSessionFile(ctx), getSessionManager(ctx)));
+  const rememberOwnEventCtx = (ctx) => {
+    if (!ctx)
+      return;
+    ownEventCtx = ctx;
+    rememberEventCtx(ctx);
+  };
+  let renderInvalidator;
+  const hostPorts = createHostPorts(pi, {
+    getContext: () => latestEventCtx,
+    getProjectRoot: () => runtime.projectRoot,
+    getRenderInvalidator: () => renderInvalidator
+  });
+  installConsoleGuard();
+  initI18n(pi);
+  const refreshCtxDerivedPlumbing = () => {
+    wireUserNotifier(hostPorts);
+    const getLiveEmit = () => ({
+      emit: hostPorts.emit.bus,
+      ctx: ownEventCtx
+    });
+    initLensEventsGetter(getLiveEmit);
+    wireBusEmitterGetter(getLiveEmit);
+    wireDiagnosticsBusEmitterGetter(getLiveEmit);
+    wireDispositionBusEmitterGetter(getLiveEmit);
+    wireFormatEventsBusEmitterGetter(getLiveEmit);
+    setRenderCallback(() => hostPorts.render.invalidate());
+  };
+  refreshCtxDerivedPlumbing();
+  wireAgentNudgeSubscriber({
+    events: pi.events,
+    getReadGuard: () => runtime.readGuard,
+    dbg
+  });
+  wireWidgetDispositionSubscriber({ events: pi.events });
+  const astGrepClient = new AstGrepClient;
+  function updateLspStatus(setStatus, theme) {
+    try {
+      if (getLensFlag("lens-hide-lsp-status") === true) {
+        setStatus("dm-lens-lsp", undefined);
+        return;
+      }
+      const { activeIds, failedIds } = selectLspStatus(getLSPService().getAliveServerIds(), getFailedLspServerIds(), getSessionLanguages());
+      const parts = [];
+      const compact = getLensFlag("lens-compact-lsp-status") === true;
+      const activeText = compact ? "LSP ✓" : `LSP Active: ${activeIds.join(", ")}`;
+      const failedText = compact ? "LSP ✗" : `LSP Failed: ${failedIds.join(", ")}`;
+      const inactiveText = compact ? "LSP ✗" : "LSP Inactive";
+      if (activeIds.length > 0) {
+        parts.push(theme.fg("success", activeText));
+      }
+      if (failedIds.length > 0) {
+        parts.push(theme.fg("error", failedText));
+      }
+      setStatus("dm-lens-lsp", parts.length > 0 ? parts.join(" · ") : theme.fg("dim", inactiveText));
+    } catch (err) {
+      dbg(`lsp status update skipped: ${err}`);
+    }
+  }
+  function captureLspStatusRepaint(ctx) {
+    let ui;
+    try {
+      ui = ctx.ui;
+    } catch (err) {
+      dbg(`lsp status repaint capture skipped: ${err}`);
+      return;
+    }
+    if (!ui || typeof ui.setStatus !== "function" || !ui.theme) {
+      return;
+    }
+    const { setStatus, theme } = ui;
+    return () => updateLspStatus(setStatus, theme);
+  }
+  for (const spec of LENS_FLAGS) {
+    pi.registerFlag(spec.name, {
+      description: spec.description,
+      type: "boolean",
+      default: spec.default
+    });
+  }
+  pi.registerFlag("no-tool", {
+    description: "Disable a lens tool for this session (repeatable).",
+    type: "string"
+  });
+  const globalConfig = loadDmLensGlobalConfig();
+  function getLensFlag(name, editedFilePath) {
+    const projectConfig = loadDmLensProjectConfig(runtime.projectRoot);
+    return resolveDmLensFlag(name, pi.getFlag(name), globalConfig, projectConfig, editedFilePath, runtime.projectRoot);
+  }
+  function getLensFlagSource(name, editedFilePath) {
+    const projectConfig = loadDmLensProjectConfig(runtime.projectRoot);
+    return resolveDmLensFlagWithSource(name, pi.getFlag(name), globalConfig, projectConfig, editedFilePath, runtime.projectRoot).source;
+  }
+  const noToolFlag = () => {
+    const value = pi.getFlag("no-tool");
+    const cliValues = process.argv.filter((arg) => arg.startsWith("--no-tool=")).map((arg) => arg.slice("--no-tool=".length));
+    if (typeof value === "string")
+      cliValues.unshift(value);
+    return cliValues.length > 0 ? cliValues.join(",") : undefined;
+  };
+  const isToolEnabled = (name) => resolveLensToolEnabled(name, globalConfig, loadDmLensProjectConfig(runtime.projectRoot).raw, noToolFlag());
+  const disabledToolNames = LENS_TOOL_NAMES.filter((name) => !isToolEnabled(name));
+  const formatDisabledToolNames = (names) => {
+    const shown = names.slice(0, 8);
+    const omitted = names.length - shown.length;
+    const suffix = omitted > 0 ? ` and ${omitted} more` : "";
+    return `${shown.join(", ")}${suffix} (${names.length} total)`;
+  };
+  let lensEnabled = !getLensFlag("no-lens");
+  _bridgeGetFlag = getLensFlag;
+  const mutationBridgeDeps = {
+    getRuntime: () => runtime,
+    getCacheManager: () => cacheManager,
+    getProjectRoot: () => runtime.projectRoot || process.cwd(),
+    getDispatchCwd: (filePath) => resolveLanguageRootForFile(filePath, runtime.projectRoot || process.cwd()),
+    countFileLines,
+    isRecordable(filePath) {
+      return isRecordableProjectPath(filePath, runtime.projectRoot);
+    },
+    shouldStampReadGuard() {
+      return !getBridgeFlag(_bridgeGetFlag, "mutation");
+    },
+    dbg
+  };
+  const ioBridgeDeps = {
+    ...mutationBridgeDeps,
+    getReadGuard: () => runtime.readGuard,
+    getTurnIndex: () => runtime.turnIndex,
+    peekWriteIndex: () => runtime.peekWriteIndex(),
+    getFlag: (name, bridge) => getBridgeFlag(_bridgeGetFlag, bridge ?? "io", name),
+    isExternalOrVendorFile: (filePath) => isExternalOrVendorFile(filePath, runtime.projectRoot),
+    isPathIgnoredByProject: (filePath) => isPathIgnoredByProject(filePath, runtime.projectRoot, false),
+    notifyExternalFileChange: (filePath, type) => getLSPService().notifyExternalFileChange(filePath, type),
+    nodeFs: { existsSync: nodeFs.existsSync, statSync: nodeFs.statSync }
+  };
+  const recordBridgeUnavailable = () => {
+    recordDegradationOnce({
+      kind: "process-bridge-unavailable",
+      subject: "primary-session-gap",
+      reason: "bridge call refused while no live primary session owns its dependencies"
+    });
+  };
+  const preSessionActivation = { role: "pre-session" };
+  const registerPrimaryBridges = (activation) => {
+    const scopedActivation = activation && typeof activation === "object" && "role" in activation && (activation.role === "primary" || activation.role === "secondary") ? activation : undefined;
+    if (scopedActivation && (scopedActivation.role !== "primary" || !scopedActivation.isLive()))
+      return;
+    registerReadBridge({
+      onUnavailable: recordBridgeUnavailable,
+      isRecordable(filePath) {
+        if (getBridgeFlag(_bridgeGetFlag, "read"))
+          return false;
+        return isRecordableProjectPath(filePath, runtime.projectRoot);
+      },
+      forward: (entry) => recordIOEntry(entry, ioBridgeDeps)
+    }, activation);
+    registerMutationBridge({ ...mutationBridgeDeps, onUnavailable: recordBridgeUnavailable }, activation);
+    registerIOBridge({ ...ioBridgeDeps, onUnavailable: recordBridgeUnavailable }, activation);
+  };
+  registerPrimaryBridges(preSessionActivation);
+  let contextInjectionEnabled = !getLensFlag("no-lens-context");
+  let lensWidgetVisible = globalConfig?.widget?.visible !== false;
+  let mountedLensWidgetUi;
+  let widgetMountFailureLogged = false;
+  function mountLensWidget(ui, mode) {
+    if (!supportsTuiWidget(mode)) {
+      dbg(`widget mount ${modeSuppressionNote(mode)}`);
+      return false;
+    }
+    if (typeof ui?.setWidget !== "function") {
+      if (!widgetMountFailureLogged) {
+        widgetMountFailureLogged = true;
+        logExtension({
+          subsystem: "widget",
+          level: "debug",
+          message: "widget mount unavailable: host ui.setWidget is missing"
+        });
+      }
+      return false;
+    }
+    const setWidget = ui.setWidget;
+    setWidget("dm-lens", (tui, theme) => {
+      const compactWidget = getLensFlag("lens-compact-widget") === true;
+      renderInvalidator = () => tui.requestRender();
+      setRenderCallback(() => {
+        scheduleStaleReconcile();
+        hostPorts.render.invalidate();
+      });
+      return {
+        render: (width) => {
+          scheduleStaleReconcile();
+          return renderWidget(width, theme, { compact: compactWidget });
+        },
+        invalidate: () => {
+          renderInvalidator = undefined;
+          setRenderCallback(() => {});
+        }
+      };
+    }, { placement: "belowEditor" });
+    mountedLensWidgetUi = ui;
+    return true;
+  }
+  function unmountLensWidget(ui) {
+    renderInvalidator = undefined;
+    setRenderCallback(() => {});
+    if (typeof ui?.setWidget !== "function")
+      return false;
+    const setWidget = ui.setWidget;
+    setWidget("dm-lens", undefined);
+    mountedLensWidgetUi = undefined;
+    return true;
+  }
+  if (typeof pi.registerMessageRenderer === "function") {
+    try {
+      pi.registerMessageRenderer(TURN_SUMMARY_CUSTOM_TYPE, renderTurnSummaryMessage);
+    } catch (registerRendererErr) {
+      dbg(`turn-summary renderer registration failed: ${registerRendererErr}`);
+    }
+  }
+  pi.registerCommand("lens-toggle", {
+    description: "Toggle dm-lens on/off for the current session. Usage: /lens-toggle",
+    handler: async (_args, ctx) => {
+      lensEnabled = !lensEnabled;
+      notifyUi(ctx, lensEnabled ? "dm-lens enabled for this session." : "dm-lens disabled for this session. Run /lens-toggle again to resume.", lensEnabled ? "info" : "warning");
+    }
+  });
+  pi.registerCommand("lens-context-toggle", {
+    description: "Toggle automatic context injection on/off for the current session (tools/LSP/read-guard/formatting stay active). Usage: /lens-context-toggle",
+    handler: async (_args, ctx) => {
+      contextInjectionEnabled = !contextInjectionEnabled;
+      notifyUi(ctx, contextInjectionEnabled ? "dm-lens context injection enabled — findings will be added to the next turn." : "dm-lens context injection disabled — findings are still cached (lens_diagnostics, /lens-health) but not added to model context.", contextInjectionEnabled ? "info" : "warning");
+    }
+  });
+  pi.registerCommand("lens-widget-toggle", {
+    description: "Show or hide the dm-lens diagnostics widget below the editor. Usage: /lens-widget-toggle",
+    handler: async (_args, ctx) => {
+      const nextVisible = !lensWidgetVisible;
+      const mode = readExtensionMode(ctx);
+      if (nextVisible && !supportsTuiWidget(mode)) {
+        notifyUi(ctx, `dm-lens widget needs an interactive TUI — unavailable in "${mode}" mode.`, "warning");
+        return;
+      }
+      const changed = nextVisible ? mountLensWidget(ctx.ui, mode) : unmountLensWidget(ctx.ui);
+      if (!changed) {
+        notifyUi(ctx, "dm-lens widget is not supported by this DM version.", "warning");
+        return;
+      }
+      lensWidgetVisible = nextVisible;
+      notifyUi(ctx, lensWidgetVisible ? "dm-lens widget shown. Run /lens-widget-toggle to hide it." : "dm-lens widget hidden. Run /lens-widget-toggle to show it.", "info");
+    }
+  });
+  pi.registerCommand("lens-tdi", {
+    description: "Show Technical Debt Index (TDI) and project health trend. Usage: /lens-tdi",
+    handler: async (_args, ctx) => {
+      const { loadHistory, computeTDI } = await import("./clients/metrics-history.js");
+      const history = loadHistory();
+      const tdi = computeTDI(history);
+      let summary = "\uD83D\uDD34 High debt - run lens_diagnostics mode=full for details";
+      if (tdi.score <= 30) {
+        summary = "✅ Codebase is healthy!";
+      } else if (tdi.score <= 60) {
+        summary = "⚠️ Moderate debt - consider refactoring";
+      }
+      const lines = [
+        `\uD83D\uDCCA TECHNICAL DEBT INDEX: ${tdi.score}/100 (${tdi.grade})`,
+        ``,
+        `Files analyzed: ${tdi.filesAnalyzed}`,
+        `Files with debt: ${tdi.filesWithDebt}`,
+        `Avg MI: ${tdi.avgMI}`,
+        `Total cognitive complexity: ${tdi.totalCognitive}`,
+        ``,
+        `Debt breakdown:`,
+        `  Maintainability: ${tdi.byCategory.maintainability}% (MI-based)`,
+        `  Cognitive: ${tdi.byCategory.cognitive}%`,
+        `  Nesting: ${tdi.byCategory.nesting}%`,
+        `  Max Cyclomatic: ${tdi.byCategory.maxCyclomatic}% (worst function)`,
+        `  Entropy: ${tdi.byCategory.entropy}% (code unpredictability)`,
+        ``,
+        summary
+      ];
+      notifyUi(ctx, lines.join(`
+`), "info");
+    }
+  });
+  pi.registerCommand("lens-map", {
+    description: "Render the review graph as a self-contained interactive HTML project map (pan/zoom/hover/click) and write it to disk. Usage: /lens-map",
+    handler: async (_args, ctx) => {
+      const cwd = ctx.cwd ?? process.cwd();
+      try {
+        const { generateLensMap } = await import("./clients/lens-map.js");
+        const result = await generateLensMap(cwd);
+        const testNote = result.testFileCount > 0 ? `, ${result.testFileCount} test files excluded` : "";
+        const twinNote = result.compiledTwinCount > 0 ? `, ${result.compiledTwinCount} compiled twins merged` : "";
+        const ignoredNote = result.ignoredFileCount > 0 ? `, ${result.ignoredFileCount} gitignored files excluded` : "";
+        const lines = [
+          `\uD83D\uDDFA️ Project map written to ${result.filePath}`,
+          `${result.fileCount} files, ${result.edgeCount} edges, ${result.externalCount} external deps excluded${testNote}${twinNote}${ignoredNote}.`
+        ];
+        if (result.truncated) {
+          lines.push("Graph exceeded the map's node cap — showing the highest-degree files only (see the in-page note).");
+        }
+        notifyUi(ctx, lines.join(`
+`), "info");
+      } catch (err) {
+        notifyUi(ctx, `Failed to generate the project map: ${err instanceof Error ? err.message : String(err)}`, "error");
+      }
+    }
+  });
+  pi.registerCommand("lens-health", {
+    description: "Show dm-lens runtime health: pipeline crashes, slow runners, and last dispatch latency. Usage: /lens-health",
+    handler: async (_args, ctx) => {
+      const crashEntries = runtime.getCrashEntries().sort((a, b) => b[1] - a[1]);
+      const totalCrashes = crashEntries.reduce((sum, [, count]) => sum + count, 0);
+      const dispatchIntegration = loadedDispatchIntegration ?? await loadDispatchIntegration();
+      loadedDispatchIntegration = dispatchIntegration;
+      const reports = dispatchIntegration.getLatencyReports();
+      const last = reports.length > 0 ? reports[reports.length - 1] : undefined;
+      const diagStats = getDiagnosticTracker().getStats();
+      const slowRunners = last ? [...last.runners].sort((a, b) => b.durationMs - a.durationMs).slice(0, 3) : [];
+      const sessionAge = Date.now() - runtime.sessionStartedAt;
+      const sessionMins = Math.floor(sessionAge / 60000);
+      const sessionHrs = Math.floor(sessionMins / 60);
+      const sessionAgeStr = sessionHrs > 0 ? `${sessionHrs}h ${sessionMins % 60}m` : `${sessionMins}m`;
+      const startedAt = new Date(runtime.sessionStartedAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+      const lines = [
+        t("lens.health.title", "\uD83E\uDE7A DM-LENS HEALTH"),
+        `Session started: ${startedAt} (${sessionAgeStr} ago)`,
+        "",
+        t("lens.health.crashes", "Pipeline crashes (session): {count}", {
+          count: totalCrashes
+        }),
+        t("lens.health.files", "Files affected: {count}", {
+          count: crashEntries.length
+        })
+      ];
+      const effectiveTools = (await withDeadline(import("./clients/lens-engine.js").then(({ effectiveConfig }) => effectiveConfig({
+        cwd: runtime.projectRoot,
+        noTools: noToolFlag()
+      })), { ms: 5000 })).tools;
+      const enabledTools = effectiveTools.filter((tool) => tool.enabled).map((tool) => tool.name);
+      const disabledTools = effectiveTools.filter((tool) => !tool.enabled).map((tool) => tool.name);
+      lines.push("", `Tools enabled: ${enabledTools.join(", ") || "none"}`);
+      if (disabledTools.length > 0) {
+        lines.push(`Tools disabled: ${formatDisabledToolNames(disabledTools)}`);
+      }
+      lines.push("Skills: managed by pi package filters");
+      const slopScoreLine = dispatchIntegration.getDispatchSlopScoreLine();
+      if (crashEntries.length > 0) {
+        lines.push("", t("lens.health.topCrashFiles", "Top crash files:"));
+        for (const [file, count] of crashEntries.slice(0, 5)) {
+          lines.push(`  ${path.basename(file)}: ${count}`);
+        }
+      }
+      if (last) {
+        lines.push("", `Last dispatch: ${path.basename(last.filePath)} (${last.totalDurationMs}ms, ${last.totalDiagnostics} diagnostics)`);
+        if (slowRunners.length > 0) {
+          lines.push("Top runners (last dispatch):");
+          for (const runner of slowRunners) {
+            lines.push(`  ${runner.runnerId}: ${runner.durationMs}ms (${runner.status})`);
+          }
+        }
+      } else {
+        lines.push("", t("lens.health.noLatency", "No dispatch latency reports yet."));
+      }
+      lines.push("", t("lens.health.diagnosticsShown", "Diagnostics shown: {count}", {
+        count: diagStats.totalShown
+      }), t("lens.health.autoFixed", "Auto-fixed: {count}", {
+        count: diagStats.totalAutoFixed
+      }), t("lens.health.agentFixed", "Agent-fixed: {count}", {
+        count: diagStats.totalAgentFixed
+      }), t("lens.health.unresolved", "Unresolved carryover: {count}", {
+        count: diagStats.totalUnresolved
+      }));
+      const elStats = getEventLoopStats();
+      if (elStats) {
+        lines.push("", `Event loop: worst genuine block ${sessionWorstRealBlockMs}ms (session) · p99 ${elStats.p99Ms}ms · mean ${elStats.meanMs}ms (turn)`);
+        if (sessionWorstRealBlockMs > 100) {
+          lines.push("  ⚠ a >100ms synchronous block can stutter the TUI — check latency.log (#192)");
+        }
+        if (sessionSuspectedStalls > 0) {
+          lines.push(`  ${sessionSuspectedStalls} suspected system stall(s) (sleep/paging) this session — excluded from the block figure above (#1122)`);
+        }
+      }
+      try {
+        lines.push("", formatMemoryHealthLine(buildMemorySample(runtime.wordIndex)));
+      } catch {}
+      if (isDebugHeapEnabled()) {
+        try {
+          const snap = writeHeapSnapshotNow("lens_health");
+          if (snap) {
+            lines.push(`Heap snapshot written: ${snap.path} (RSS ${Math.round(snap.rssBytes / (1024 * 1024))}MB, ${snap.durationMs}ms) — open in Chrome DevTools › Memory`);
+          }
+        } catch {}
+      }
+      try {
+        lines.push(formatSmellsHealthLine(countRecentSmells()));
+      } catch {}
+      if (diagStats.repeatOffenders.length > 0) {
+        lines.push(t("lens.health.repeatOffenders", "Repeat offenders:"));
+        for (const offender of diagStats.repeatOffenders.slice(0, 5)) {
+          lines.push(`  ${path.basename(offender.filePath)}:${offender.line} ${offender.ruleId} (${offender.count}x)`);
+        }
+      }
+      if (diagStats.topViolations.length > 0) {
+        lines.push(t("lens.health.topNoisyRules", "Top noisy rules:"));
+        for (const v of diagStats.topViolations.slice(0, 5)) {
+          const samplePath = v.samplePaths.length > 0 ? path.relative(runtime.projectRoot, v.samplePaths[0]).replace(/\\/g, "/") : "";
+          const pathSuffix = samplePath ? ` (e.g. ${samplePath})` : "";
+          lines.push(`  ${v.ruleId}: ${v.count}${pathSuffix}`);
+        }
+      }
+      try {
+        lines.push(...renderDegradationLines(getDegradationSummary().filter((group) => group.kind === "warm-ipc-endpoint-missing")));
+      } catch {}
+      const lspClients = getLSPService().getStatus();
+      if (lspClients.length > 0) {
+        lines.push("", "LSP servers:");
+        for (const { serverId, root, connected } of lspClients) {
+          const state = connected ? "✓" : "✗";
+          const rootLabel = path.relative(runtime.projectRoot, root) || ".";
+          lines.push(`  ${state} ${serverId} (${rootLabel})`);
+        }
+      } else {
+        lines.push("", "LSP servers: none started");
+      }
+      const cascadeStats = dispatchIntegration.getCascadeSessionStats();
+      if (cascadeStats.runs > 0) {
+        lines.push("", `Cascade runs: ${cascadeStats.runs}`, `Cascade diagnostics surfaced: ${cascadeStats.diagnosticsSurfaced}`);
+        if (cascadeStats.coldSnapshotTouches > 0) {
+          lines.push(`Cold-snapshot touches: ${cascadeStats.coldSnapshotTouches}`);
+        }
+      }
+      if (slopScoreLine) {
+        lines.push("", slopScoreLine);
+      }
+      notifyUi(ctx, lines.join(`
+`), "info");
+    }
+  });
+  pi.registerCommand("lens-perf", {
+    description: "Show the slowest latency-log phases by p50 and p99 for the current process session and machine-wide active log window. Usage: /lens-perf",
+    handler: async (_args, ctx) => {
+      try {
+        const { collectLatencyPerformance, renderLatencyPerformanceReport } = await import("./clients/performance-report.js");
+        const report = await collectLatencyPerformance({
+          sessionStartedAt: runtime.sessionStartedAt
+        });
+        const degradationLines = renderDegradationLines(getDegradationSummary());
+        const degradationText = degradationLines.length ? `
+
+${degradationLines.join(`
+`)}` : "";
+        notifyUi(ctx, `${renderLatencyPerformanceReport(report)}${degradationText}`, "info");
+      } catch (err) {
+        notifyUi(ctx, `Failed to read performance telemetry: ${err instanceof Error ? err.message : String(err)}`, "error");
+      }
+    }
+  });
+  pi.registerCommand("lens-tools", {
+    description: "Show dm-lens tool installation status: globally installed, auto-installed, or npx fallback. Usage: /lens-tools",
+    handler: async (_args, ctx) => {
+      const statuses = await getAllToolStatuses();
+      const bySource = {
+        "global-path": statuses.filter((s) => s.source === "global-path"),
+        "npm-global": statuses.filter((s) => s.source === "npm-global"),
+        "pip-user": statuses.filter((s) => s.source === "pip-user"),
+        "dm-lens-auto": statuses.filter((s) => s.source === "dm-lens-auto"),
+        "github-release": statuses.filter((s) => s.source === "github-release"),
+        "npx-fallback": statuses.filter((s) => s.source === "npx-fallback"),
+        "not-installed": statuses.filter((s) => s.source === "not-installed")
+      };
+      const lines = [
+        "\uD83D\uDD27 DM-LENS TOOLS STATUS",
+        "",
+        `Installed: ${statuses.filter((s) => s.installed).length}/${statuses.length}`
+      ];
+      if (bySource["global-path"].length > 0) {
+        lines.push("", `\uD83D\uDCCD Global PATH (${bySource["global-path"].length}):`);
+        for (const tool of bySource["global-path"]) {
+          const version = tool.version ? ` (${tool.version})` : "";
+          lines.push(`  ✓ ${tool.name}${version}`);
+        }
+      }
+      if (bySource["npm-global"].length > 0) {
+        lines.push("", `\uD83D\uDCE6 npm global (${bySource["npm-global"].length}):`);
+        for (const tool of bySource["npm-global"]) {
+          lines.push(`  ✓ ${tool.name}`);
+        }
+      }
+      if (bySource["pip-user"].length > 0) {
+        lines.push("", `\uD83D\uDC0D pip user (${bySource["pip-user"].length}):`);
+        for (const tool of bySource["pip-user"]) {
+          lines.push(`  ✓ ${tool.name}`);
+        }
+      }
+      if (bySource["github-release"].length > 0) {
+        lines.push("", `⬇️ GitHub releases (${bySource["github-release"].length}):`);
+        for (const tool of bySource["github-release"]) {
+          lines.push(`  ✓ ${tool.name}`);
+        }
+      }
+      if (bySource["dm-lens-auto"].length > 0) {
+        lines.push("", `\uD83E\uDD16 Auto-installed (${bySource["dm-lens-auto"].length}):`);
+        for (const tool of bySource["dm-lens-auto"]) {
+          lines.push(`  ✓ ${tool.name}`);
+        }
+      }
+      if (bySource["npx-fallback"].length > 0) {
+        lines.push("", `\uD83D\uDCE6 npx fallback (${bySource["npx-fallback"].length} - on-demand install):`);
+        for (const tool of bySource["npx-fallback"]) {
+          lines.push(`  ⬜ ${tool.name}`);
+        }
+      }
+      const trulyMissing = bySource["not-installed"].filter((s) => s.strategy !== "npm");
+      if (trulyMissing.length > 0) {
+        lines.push("", `❌ Missing (${trulyMissing.length}):`);
+        for (const tool of trulyMissing) {
+          lines.push(`  ✗ ${tool.name} (${tool.strategy})`);
+        }
+        lines.push("", "Note: GitHub-release tools auto-install when you open files of those languages");
+      }
+      notifyUi(ctx, lines.join(`
+`), "info");
+    }
+  });
+  pi.registerCommand("lens-allow-edit", {
+    description: "Allow one edit to a file without a prior read. Usage: /lens-allow-edit <path>",
+    handler: async (args, ctx) => {
+      const [rawTarget] = normalizeCommandArgs(args);
+      if (!rawTarget) {
+        notifyUi(ctx, "Usage: /lens-allow-edit <path>", "warning");
+        return;
+      }
+      const targetPath = path.isAbsolute(rawTarget) ? rawTarget : path.resolve(ctx.cwd ?? runtime.projectRoot, rawTarget);
+      runtime.readGuard.addExemption(targetPath);
+      notifyUi(ctx, `Read guard override armed for next edit: ${targetPath}`, "info");
+    }
+  });
+  const alwaysActiveTools = [
+    createLensDiagnosticsTool(cacheManager, () => runtime.projectRoot, undefined, () => flushDebouncedToolResults(), () => runtime.nextWriteOrderToken(), captureLspStatusRepaint, () => runtime, () => Boolean(getLensFlag("lens-guard"))),
+    createSymbolSearchTool(() => runtime.projectRoot),
+    createEffectiveConfigTool(() => runtime.projectRoot, noToolFlag),
+    createProjectReportTool(() => runtime.projectRoot),
+    createModuleReportTool(() => runtime.projectRoot),
+    createReadSymbolTool(() => runtime.projectRoot, (filePath, symbol, toolCallId) => runtime.readGuard.recordSymbolRead(filePath, symbol, runtime.turnIndex, runtime.peekWriteIndex(), sanitizeCorrelationId(toolCallId))),
+    createReadEnclosingTool(() => runtime.projectRoot, (filePath, symbol, toolCallId) => runtime.readGuard.recordSymbolRead(filePath, symbol, runtime.turnIndex, runtime.peekWriteIndex(), sanitizeCorrelationId(toolCallId)))
+  ];
+  const lazyTools = [
+    createAstGrepSearchTool(astGrepClient),
+    createAstGrepReplaceTool(astGrepClient, () => runtime.captureSessionGeneration()),
+    createAstGrepOutlineTool(astGrepClient),
+    createLspNavigationTool((name, cwd) => getLensFlag(name, cwd), {
+      runtime,
+      cacheManager,
+      readGuard: runtime.readGuard,
+      dbg
+    }),
+    createLensDiagnosticMarkTool(() => runtime.projectRoot, () => ({
+      model: runtime.telemetryModelId,
+      provider: runtime.telemetryProviderId
+    }), () => runtime.captureSessionGeneration())
+  ];
+  const LAZY_TOOL_CATALOG = TOOL_REGISTRY.filter((entry) => ("situational" in entry) && entry.situational === true).map(({ name, summary }) => ({ name, summary }));
+  const enabledLazyTools = new Set(LAZY_TOOL_CATALOG.filter((tool) => isToolEnabled(tool.name)).map((tool) => tool.name));
+  const filteredLazyTools = lazyTools.filter((tool) => enabledLazyTools.has(tool.name));
+  const filteredLazyCatalog = LAZY_TOOL_CATALOG.filter((tool) => enabledLazyTools.has(tool.name));
+  const getSessionFile = (ctx) => {
+    try {
+      return ctx?.sessionManager?.getSessionFile?.();
+    } catch {
+      return;
+    }
+  };
+  const getSessionManager = (ctx) => {
+    try {
+      return ctx.sessionManager;
+    } catch {
+      return;
+    }
+  };
+  const activateToolsTool = createActivateToolsTool(pi, filteredLazyCatalog, {
+    onActivated: (names) => {
+      observeSituationalToolActivation(names);
+      rememberLazyTools(scope, names);
+    },
+    onRejected: (name) => {
+      if (LENS_TOOL_NAMES.includes(name)) {
+        recordDegradationOnce({
+          kind: "tool-disabled",
+          subject: name,
+          reason: `disabled by tools.${name}.enabled`
+        });
+      }
+    },
+    deferredToolSupport: (ctx) => {
+      try {
+        return supportsDeferredTools(ctx?.model);
+      } catch {
+        return false;
+      }
+    },
+    onMutation: recordToolSetMutation
+  });
+  const compactToolLineEnabled = getLensFlag("lens-compact-tool-line") === true;
+  const toolsToRegister = [
+    ...alwaysActiveTools,
+    activateToolsTool,
+    ...filteredLazyTools
+  ].filter((tool) => tool.name === "dm_lens_activate_tools" || isToolEnabled(tool.name));
+  for (const tool of compactToolLineEnabled ? wrapToolsForCompactLine(toolsToRegister) : toolsToRegister) {
+    try {
+      const normalized = normalizeToolDefinition(tool);
+      const execute = normalized.execute;
+      if (typeof execute === "function") {
+        const recordDelivery = (delivery, args) => {
+          if (!lensEnabled)
+            return;
+          try {
+            const ctx = args[4];
+            const sessionId = getStableSessionId(ctx);
+            recordToolResultDelivery({
+              sessionId,
+              sessionRole: classifyOwnedSessionEmission(ctx, sessionId),
+              bytes: delivery.deliveredBytes,
+              truncated: delivery.truncated
+            });
+          } catch {}
+        };
+        normalized.execute = (...args) => Promise.resolve(execute(...args)).then((result) => {
+          const delivery = finalizeToolResultWithDelivery(result);
+          recordDelivery(delivery, args);
+          return delivery.result;
+        }, (err) => {
+          const text = err instanceof Error ? err.message : String(err);
+          const delivery = finalizeToolResultWithDelivery({
+            ...renderToolText(text),
+            isError: true
+          });
+          recordDelivery(delivery, args);
+          return delivery.result;
+        });
+      }
+      pi.registerTool(normalized);
+    } catch {}
+  }
+  pi.on("resources_discover", async (_event, _ctx) => {
+    resolveSkillPaths(import.meta.url);
+  });
+  const applyToolSetPlan = (ctx, reason) => {
+    try {
+      const piWithActiveTools = pi;
+      if (getLensFlag("no-lazy-tools") === true || typeof piWithActiveTools.getActiveTools !== "function" || typeof piWithActiveTools.setActiveTools !== "function")
+        return;
+      const lazyNames = new Set(enabledLazyTools);
+      const plan = planToolSet(piWithActiveTools.getActiveTools(), lazyNames, getRememberedLazyTools(scope));
+      if (!plan.changed)
+        return;
+      piWithActiveTools.setActiveTools(plan.desired);
+      recordToolSetMutation({
+        addedCount: plan.addedCount,
+        removedCount: plan.removedCount,
+        reason: isFreshSessionStart(reason) ? "fresh_session_lazy_deactivation" : "session_rebuild_restore",
+        deferralApplies: supportsDeferredTools(ctx?.model)
+      });
+    } catch (toolSetErr) {
+      dbg(`dynamic tool set restore failed (older pi host lacking getActiveTools/setActiveTools, or a genuine host error): ${toolSetErr}`);
+    }
+  };
+  pi.on("session_start", wrapSessionEventHandler("session_start", async (event, ctx) => {
+    const sessionStartEvent = event;
+    const isNewSessionStartEvent = reserveSessionStart(sessionStartEvent);
+    const sessionStartReason = sessionStartEvent.reason;
+    const sessionIdentityParts = (() => {
+      try {
+        const sessionManager = ctx?.sessionManager;
+        noteHostSessionManager(sessionManager);
+        return {
+          sessionId: sessionManager?.getSessionId?.(),
+          sessionFile: getSessionFile(ctx)
+        };
+      } catch {
+        return { sessionId: undefined, sessionFile: undefined };
+      }
+    })();
+    if (!isNewSessionStartEvent) {
+      const duplicateSubject = sessionIdentityParts.sessionId ?? sessionIdentityParts.sessionFile ?? "session_start";
+      emitBounded("session_start_duplicate_suppressed", duplicateSubject, {
+        durationMs: 0,
+        metadata: {
+          reason: "duplicate start suppressed",
+          eventIdentity: "same-event-object"
+        }
+      }, {
+        ledgerKind: "session-start-duplicate",
+        risingEdgePer: "identity",
+        reason: "duplicate start suppressed"
+      });
+      return;
+    }
+    const sessionStartMonotonicAt = performance.now();
+    warmDispatchAtSessionStart();
+    warmLspService().catch((err) => logExtension({
+      subsystem: "lsp",
+      level: "warn",
+      message: `LSP warm failed: ${err}`
+    }));
+    warmFormatters().catch((err) => logExtension({
+      subsystem: "format",
+      level: "warn",
+      message: `formatter warm failed: ${err}`
+    }));
+    rememberOwnEventCtx(ctx);
+    refreshCtxDerivedPlumbing();
+    const sessionStartFiredAt = Date.now();
+    try {
+      dbg("session_start fired");
+      const buildIdentity = getBuildIdentity(import.meta.url);
+      if (buildIdentity)
+        dbg(formatBuildIdentity(buildIdentity));
+      const sessionReason = sessionStartReason;
+      if (disabledToolNames.length > 0) {
+        dbg(`session_start: disabled tools = ${formatDisabledToolNames(disabledToolNames)}`);
+      }
+      const trustState = adoptProjectTrustFromPorts(hostPorts);
+      if (trustState !== "unknown") {
+        dbg(`session_start: project trust = ${trustState}`);
+      }
+      if (trustState === "untrusted") {
+        dbg("session_start: untrusted project — tool auto-install and LSP spawns are disabled for this session");
+      }
+      const stableSessionId = (() => {
+        try {
+          return ctx?.sessionManager?.getSessionId?.();
+        } catch {
+          return;
+        }
+      })();
+      const sessionStartCwd = (() => {
+        try {
+          return ctx?.cwd;
+        } catch {
+          return;
+        }
+      })();
+      const sessionStartDecision = decideSessionStart(ctx, stableSessionId, sessionStartCwd, sessionStartReason, startKey(getSessionFile(ctx), getSessionManager(ctx)));
+      ownedSessionRole = sessionStartDecision.runFullSessionStart ? "primary" : "concurrent-secondary";
+      if (!sessionStartDecision.runFullSessionStart) {
+        dbg(`session_start: ${sessionStartDecision.classification} detected (count=${sessionStartDecision.secondaryCount}, sameRoot=${sessionStartDecision.sameRoot}) — skipping handleSessionStart`);
+        logConcurrentSessionBind({
+          secondaryCount: sessionStartDecision.secondaryCount,
+          sessionReason,
+          sameCwd: ctx?.cwd === process.cwd(),
+          classification: sessionStartDecision.classification,
+          sameRoot: sessionStartDecision.sameRoot,
+          primaryRoot: sessionStartDecision.primaryRoot
+        });
+        if (sessionStartDecision.sameRoot === false && typeof sessionStartCwd === "string") {
+          ownedSecondaryRoot = sessionStartCwd;
+          registerInstanceRoot(sessionStartCwd, secondaryRootHolder).catch(() => {});
+        }
+        const discardedSlot = discardHandoff({
+          reason: sessionReason,
+          sessionFile: getSessionFile(ctx),
+          sessionManager: getSessionManager(ctx)
+        });
+        scope = beginScope({ role: "secondary" });
+        logScopeTransition(scope, {
+          transition: "start",
+          reason: sessionReason,
+          sessionId: stableSessionId,
+          cwd: sessionStartCwd ?? runtime.projectRoot
+        });
+        if (sessionStartDecision.basis === "successor-pending")
+          logScopeTransition(scope, {
+            transition: "demote",
+            reason: sessionReason,
+            sessionId: stableSessionId,
+            cwd: sessionStartCwd ?? runtime.projectRoot,
+            detail: {
+              classification: sessionStartDecision.classification,
+              basis: sessionStartDecision.basis,
+              gapMs: sessionStartDecision.gapMs,
+              lineageMatch: sessionStartDecision.lineageMatch,
+              discardedSlot
+            }
+          });
+        return;
+      }
+      const inFlight = { reason: sessionReason, shutDown: false };
+      startInFlight = inFlight;
+      resetVerifiedPathAttributionGuessCount();
+      resetCurrentPhaseForSession();
+      resetCacheFindingIdentitiesSession(stableSessionId, ownedSessionRole);
+      resetOncePerSessionPhases();
+      startSituationalToolTelemetrySession("pi");
+      emitConcurrentSessionBindRollupAtSessionEnd(runtime.projectRoot);
+      resetConcurrentSessionBindRollupCounts();
+      await configureWarmAttach(ctx.cwd ?? process.cwd());
+      registerInstance(ctx.cwd ?? process.cwd()).catch(() => {});
+      readInstanceRegistry().then((registry) => logVanishedInstances(registry)).catch(() => {}).finally(() => {
+        sweepOrphans();
+      });
+      scheduleUntrackedOrphanSweep();
+      checkCrossProcessLspBudget();
+      readCrossProcessTouchesForSessionStart({
+        cwd: ctx.cwd ?? process.cwd()
+      }).then((entries) => {
+        if (entries.length === 0)
+          return;
+        recordCrossProcessTouches(entries.map((e) => ({
+          path: e.path,
+          reason: e.reason,
+          sessionId: e.sessionId
+        })));
+        dbg(`session_start: cross-process nudge — ${entries.length} file(s) from other instance(s)`);
+      }).catch((err) => {
+        dbg(`session_start: cross-process nudge read failed: ${err}`);
+      });
+      updateRuntimeIdentityFromCtx(ctx);
+      try {
+        await ensureLSPConfigInitialized(ctx.cwd ?? process.cwd());
+      } catch (cfgErr) {
+        dbg(`lsp config init failed: ${cfgErr}`);
+      }
+      const handlerEnteredAt = Date.now();
+      const emitHostReadyDelay = consumeHostReadyDelayAnchor();
+      resetMemorySamplerCadence();
+      resetTurnContext(stableSessionId);
+      const sessionStartWork = handleSessionStart({
+        ctxCwd: ctx.cwd,
+        sessionStartFiredAt,
+        sessionStartMonotonicAt,
+        extensionLoadedAt: DM_LENS_LOADED_AT_MS,
+        emitHostReadyDelay,
+        sessionReason,
+        handlerEnteredAt,
+        globalConfig,
+        projectConfig: loadDmLensProjectConfig(runtime.projectRoot),
+        disabledToolNames,
+        sessionStartClassification: sessionStartDecision.classification,
+        sessionStartSameRoot: sessionStartDecision.sameRoot,
+        sessionStartBasis: sessionStartDecision.basis,
+        sessionStartGapMs: sessionStartDecision.gapMs,
+        sessionStartLineageMatch: sessionStartDecision.lineageMatch,
+        getFlag: (name) => getLensFlag(name),
+        notify: (msg, level) => notifyUi(ctx, msg, level),
+        dbg,
+        log,
+        runtime,
+        cacheManager,
+        astGrepClient,
+        bootstrap: sessionBootstrapAccess,
+        ensureTool: async (name) => (await import("./clients/installer/index.js")).ensureTool(name),
+        cleanStaleTsBuildInfo,
+        resetDispatchBaselines,
+        resetLSPService
+      });
+      scope = runtime.sessionScope;
+      registerPrimaryBridges(scope);
+      _turnSummaryEmitCtxGetter = rebindableProcessBridgeDeps("turn-summary-emit-context", 1, scope, {
+        runtime,
+        pi,
+        getLensFlag: (name) => getLensFlag(name),
+        isLensEnabled: () => lensEnabled
+      });
+      runtime.setSessionLifecycle({
+        sessionId: stableSessionId,
+        reason: sessionReason
+      });
+      await bounded(sessionStartWork, {
+        ms: HOOK_WALL_BUDGET_MS.session_start,
+        signal: ctx.signal,
+        hook: "session_start",
+        label: "handleSessionStart"
+      });
+      if (ctx.ui)
+        updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
+      scopeCell(scope, READ_GUARD_CELL, () => runtime.readGuard);
+      if (inFlight.shutDown)
+        return;
+      const stateCwd = ctx.cwd ?? process.cwd();
+      const handoffSource = await adoptHandoff(scope, {
+        reason: sessionReason,
+        sessionFile: getSessionFile(ctx),
+        sessionManager: ctx.sessionManager,
+        cwd: stateCwd,
+        dbg,
+        loadOwnSidecar: () => loadSessionState(stateCwd, stableSessionId),
+        loadParentSidecar: async () => {
+          const parentFile = (() => {
+            try {
+              return ctx?.sessionManager?.getHeader?.()?.parentSession;
+            } catch {
+              return;
+            }
+          })();
+          const parentId = parentFile ? await readSessionHeaderId(parentFile) : undefined;
+          return loadSessionState(stateCwd, parentId);
+        }
+      });
+      logScopeTransition(scope, {
+        transition: "start",
+        reason: sessionReason,
+        sessionId: stableSessionId,
+        cwd: stateCwd,
+        handoffSource
+      });
+      dbg(`session_start: ${sessionReason ?? "startup"} — session stores from ${handoffSource}`);
+      if (lensWidgetVisible) {
+        mountLensWidget(ctx.ui, readExtensionMode(ctx));
+      }
+    } catch (sessionErr) {
+      if (isStaleExtensionCtxError(sessionErr))
+        throw sessionErr;
+      surfaceHandlerCrash("session_start", sessionErr, { dbg });
+    } finally {
+      startInFlight = undefined;
+      applyToolSetPlan(ctx, sessionStartReason);
+    }
+  }, { dbg }));
+  pi.on("session_tree", wrapSessionEventHandler("session_tree", (_event, ctx) => {
+    try {
+      if (ownedSessionRole !== "primary")
+        return;
+      const branch = branchToolResultIds(ctx?.sessionManager);
+      const retained = runtime.readGuard.retainBranch(branch.ids);
+      logReadGuardBranchMove({
+        trigger: "tree",
+        source: "live",
+        kept: retained.kept,
+        dropped: retained.dropped,
+        branch,
+        cwd: ctx?.cwd ?? runtime.projectRoot ?? process.cwd()
+      });
+      logScopeTransition(runtime.sessionScope, {
+        transition: "tree",
+        reason: "tree",
+        sessionId: runtime.telemetrySessionId,
+        cwd: ctx?.cwd ?? runtime.projectRoot ?? process.cwd()
+      });
+    } catch (treeErr) {
+      if (isStaleExtensionCtxError(treeErr))
+        throw treeErr;
+      surfaceHandlerCrash("session_tree", treeErr, { dbg });
+    }
+  }, { dbg }));
+  pi.on("tool_call", async (event, ctx) => {
+    const toolEntry = toolRegistryEntryForPi(event.toolName ?? "");
+    if (toolEntry && "situational" in toolEntry && toolEntry.situational) {
+      observeSituationalToolCall(toolEntry.name);
+    }
+    return handleToolCall({
+      event,
+      ctx,
+      lensEnabled,
+      getFlag: (name) => getLensFlag(name),
+      dbg,
+      runtime,
+      cacheManager,
+      ensureLSPConfigInitialized,
+      updateLspStatus,
+      resetLSPService,
+      sessionId: getStableSessionId(ctx)
+    });
+  });
+  const onToolResult = async (event, ctx) => {
+    rememberOwnEventCtx(ctx);
+    if (!lensEnabled)
+      return;
+    updateRuntimeIdentityFromCtx(ctx);
+    setAmbientAbortSignal(ctx?.signal);
+    const rtToolName = event?.toolName;
+    const rtMutation = classifyMutatingTool(event, { recognizeOnly: true });
+    const editClass = isEditClassToolResult(event, ctx?.cwd ?? runtime.projectRoot ?? process.cwd());
+    if (rtMutation) {
+      logLatency({
+        type: "phase",
+        phase: "tool_result_received",
+        filePath: rtMutation.path ?? event?.input?.path ?? "<unknown>",
+        durationMs: 0,
+        metadata: {
+          toolName: rtToolName,
+          mutationKind: rtMutation.kind,
+          mutationProvenance: rtMutation.provenance
+        }
+      });
+    }
+    try {
+      const resident = editClass ? await bounded(loadBootstrapClients(), {
+        ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+        signal: ctx.signal,
+        hook: "tool_result_edit",
+        label: "tool-result-bootstrap"
+      }) : peekBootstrapClients();
+      return await bounded(handleToolResult({
+        signal: ctx.signal,
+        event,
+        getFlag: (name, filePath) => getLensFlag(name, filePath),
+        getFlagSource: (name, filePath) => getLensFlagSource(name, filePath),
+        dbg,
+        runtime,
+        cacheManager,
+        biomeClient: resident?.biomeClient,
+        ruffClient: resident?.ruffClient,
+        metricsClient: resident?.metricsClient,
+        resetLSPService,
+        readGuard: runtime.readGuard,
+        agentBehaviorRecord: (toolName, filePath) => (resident?.agentBehaviorClient ?? getAgentBehaviorClient()).recordToolCall(toolName, filePath),
+        formatBehaviorWarnings: (warnings) => (resident?.agentBehaviorClient ?? getAgentBehaviorClient()).formatWarnings(warnings),
+        sessionId: getStableSessionId(ctx),
+        sessionRole: ownedSessionRole === "concurrent-secondary" ? "secondary" : "primary"
+      }), {
+        ms: editClass ? HOOK_WALL_BUDGET_MS.tool_result_edit : HOOK_WALL_BUDGET_MS.tool_result_read_only,
+        signal: ctx.signal,
+        hook: editClass ? "tool_result_edit" : "tool_result_read_only",
+        label: "handleToolResult"
+      });
+    } finally {
+      setAmbientAbortSignal(undefined);
+    }
+  };
+  pi.on("tool_result", wrapSessionEventHandler("tool_result", onToolResult, {
+    dbg,
+    budgetKey: (event, _ctx) => {
+      try {
+        return isEditClassToolResult(event, _ctx?.cwd ?? runtime.projectRoot ?? process.cwd()) ? "tool_result_edit" : "tool_result_read_only";
+      } catch {
+        return "tool_result_read_only";
+      }
+    }
+  }));
+  pi.on("tool_execution_end", (event) => {
+    handleToolExecutionEnd(event, runtime.readGuard);
+  });
+  const onTurnStart = (_event, ctx) => {
+    rememberOwnEventCtx(ctx);
+    adoptProjectTrustFromPorts(hostPorts);
+    if (lensWidgetVisible && ctx?.ui && (mountedLensWidgetUi === undefined || mountedLensWidgetUi !== ctx.ui)) {
+      mountLensWidget(ctx.ui, readExtensionMode(ctx));
+    }
+    runtime.beginTurn(getStableSessionId(ctx));
+    turnStartScope = scope ?? runtime.sessionScope;
+    if (ownedSessionRole === "concurrent-secondary" && getStableSessionId(ctx) !== undefined) {
+      cacheManager.ensureSecondaryTurnStatePartition(ctx?.cwd ?? process.cwd(), getStableSessionId(ctx));
+    }
+    clearLastAnalyzedStateCache();
+    const cwd = ctx?.cwd ?? process.cwd();
+    readCrossProcessTouchesForTurnStart({ cwd }).then((entries) => {
+      if (entries.length === 0)
+        return;
+      recordCrossProcessTouches(entries.map((e) => ({
+        path: e.path,
+        reason: e.reason,
+        sessionId: e.sessionId
+      })));
+      dbg(`turn_start: cross-process nudge — ${entries.length} file(s) from other instance(s)`);
+    }).catch((err) => {
+      dbg(`turn_start: cross-process nudge read failed: ${err}`);
+    });
+  };
+  pi.on("turn_start", wrapSessionEventHandler("turn_start", onTurnStart, { dbg }));
+  async function runObservedSettledSweepSafely(ctx, readGuardBranchEpoch, lineage) {
+    const cwd = ctx.cwd ?? runtime.projectRoot;
+    try {
+      const result = await runObservedSettledSweep({
+        turnIndex: runtime.turnIndex,
+        getTrackedPaths: () => collectTrackedPaths({
+          readGuard: runtime.readGuard,
+          cwd,
+          limit: OBSERVED_TRACKED_MAX_FILES
+        }),
+        record: (entry) => replayThroughMutationBridge({
+          ...entry,
+          readGuardBranchEpoch,
+          lineage
+        }),
+        getStoredLineHashes: (candidate) => storedLineHashesFor(runtime.readGuard, candidate),
+        isRecordable: (candidate) => isRecordableProjectPath(candidate, runtime.projectRoot),
+        signal: ctx?.signal,
+        dbg
+      });
+      if (result.drifted.length > 0 || result.unverifiable.length > 0) {
+        dbg(`observed_settled_sweep: ${result.drifted.length} drifted file(s), ${result.replayed} replayed, ` + `${result.unverifiable.length} unverifiable; scanned ${result.scanned}, ${result.notReachedThisPass} not reached this pass (cursor ${result.cursor})`);
+      }
+    } catch (sweepErr) {
+      surfaceHandlerCrash("observed_settled_sweep", sweepErr, { dbg });
+    }
+  }
+  async function refreshObservedLedgerSafely(ctx) {
+    const signal = ctx?.signal;
+    try {
+      await refreshObservedMutationLedger({
+        turnIndex: runtime.turnIndex,
+        getStoredLineHashes: (candidate) => storedLineHashesFor(runtime.readGuard, candidate),
+        signal
+      });
+    } catch (refreshErr) {
+      surfaceHandlerCrash("observed_ledger_refresh", refreshErr, { dbg });
+    }
+  }
+  async function runDeferredMutationDrain(ctx) {
+    const currentSessionId = getStableSessionId(ctx);
+    const emission = classifyOwnedSessionEmission(ctx, currentSessionId);
+    if (emission === "concurrent-secondary") {
+      dbg(`deferred_mutation_drain: concurrent secondary session detected — skipping (sessionId=${currentSessionId})`);
+      logLatency({
+        type: "phase",
+        filePath: ctx.cwd ?? "<dm-lens>",
+        phase: "agent_end_concurrent_secondary_skip",
+        durationMs: 0,
+        metadata: { sessionId: currentSessionId }
+      });
+      return;
+    }
+    await handleAgentEnd({
+      signal: ctx.signal,
+      ctxCwd: ctx.cwd,
+      getFlag: (name, filePath) => getLensFlag(name, filePath),
+      getFlagSource: (name, filePath) => getLensFlagSource(name, filePath),
+      notify: (msg, level) => notifyUi(ctx, msg, level),
+      dbg,
+      runtime,
+      cacheManager,
+      getFormatService: () => getFormatService(runtime.telemetrySessionId, true),
+      getAutofixClients: async () => {
+        const { biomeClient, ruffClient } = await loadBootstrapClients();
+        return { biomeClient, ruffClient };
+      },
+      currentSessionId
+    });
+    if (ctx.ui?.setStatus && ctx.ui.theme) {
+      updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
+    }
+  }
+  const onAgentEnd = async (_event, ctx) => {
+    if (!lensEnabled)
+      return;
+    try {
+      setAmbientAbortSignal(ctx?.signal);
+      await flushDebouncedToolResults();
+      if (ctx.ui)
+        updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
+    } catch (agentEndErr) {
+      if (isStaleExtensionCtxError(agentEndErr))
+        throw agentEndErr;
+      surfaceHandlerCrash("agent_end", agentEndErr, { dbg });
+    } finally {
+      setAmbientAbortSignal(undefined);
+    }
+  };
+  pi.on("agent_end", wrapSessionEventHandler("agent_end", onAgentEnd, { dbg }));
+  const onTurnEnd = async (_event, ctx) => {
+    if (!lensEnabled)
+      return;
+    try {
+      setAmbientAbortSignal(ctx?.signal);
+      const repaintLspStatus = captureLspStatusRepaint(ctx);
+      const elStats = getEventLoopStats();
+      const loopMaxMs = elStats?.maxMs ?? 0;
+      const suspectSystemStall = elStats?.suspectSystemStall ?? false;
+      if (shouldLogLoopBlock(loopMaxMs)) {
+        const lastPhase = getLastLoggedPhase();
+        const recentPhases = getRecentLoggedPhases(3);
+        const blockSampledAtMs = Date.now();
+        const inFlight = getPhaseForWindow(blockSampledAtMs - loopMaxMs, blockSampledAtMs);
+        const isNewSessionWorst = shouldLogWorstBlock(loopMaxMs, lastLoggedLoopWorstMs);
+        emitBounded("loop_block", LOOP_BLOCK_IDENTITY, {
+          type: "phase",
+          durationMs: Math.round(loopMaxMs),
+          metadata: {
+            worstSoFar: isNewSessionWorst,
+            turnIndex: runtime.turnIndex,
+            suspectSystemStall,
+            stallClass: elStats?.stallClass,
+            cpuCoverageRatio: elStats?.cpuCoverageRatio,
+            windowCpuMs: elStats?.windowCpuMs,
+            windowWallMs: elStats?.windowWallMs,
+            lastPhase: lastPhase?.phase,
+            lastPhaseAt: lastPhase?.ts,
+            recentPhases,
+            inFlightPhase: inFlight?.phase,
+            inFlightPhaseStartedAt: inFlight?.startedAt,
+            inFlightPhaseElapsedMs: inFlight?.elapsedMs,
+            inFlightPhaseStillRunning: inFlight?.stillRunning
+          }
+        });
+        if (suspectSystemStall) {
+          sessionSuspectedStalls += 1;
+        } else if (isNewSessionWorst) {
+          lastLoggedLoopWorstMs = loopMaxMs;
+          sessionWorstRealBlockMs = Math.max(sessionWorstRealBlockMs, loopMaxMs);
+        }
+      }
+      resetEventLoopMonitor();
+      const cadenceTurn = runtime.turnStartCount;
+      if (shouldEmitMemorySampleAdaptive(cadenceTurn)) {
+        try {
+          const sample = buildMemorySample(runtime.wordIndex, undefined, undefined, {
+            sessionAgeMs: Math.max(0, Date.now() - runtime.sessionStartedAt),
+            sessionStartedAt: runtime.sessionStartedAt,
+            turnCount: runtime.turnIndex,
+            root: getActivePrimaryRoot()
+          });
+          logLatency({
+            type: "phase",
+            filePath: "<dm-lens>",
+            phase: "memory_sample",
+            durationMs: 0,
+            metadata: { turnIndex: runtime.turnIndex, ...sample }
+          });
+          recordMemorySampleOutcome(sample.process.heapUsedBytes, cadenceTurn);
+        } catch {}
+      }
+      if (shouldCheckSmellsThisTurn(cadenceTurn)) {
+        try {
+          for (const note of checkSmellsAndNoteOnce(countRecentSmells(undefined, runtime.sessionStartedAt))) {
+            notifyUi(ctx, note, "warning");
+          }
+        } catch {}
+      }
+      await flushDebouncedToolResults();
+      const { knipClient, deadCodeClients, depChecker, testRunnerClient } = await loadBootstrapClients();
+      await handleTurnEnd({
+        ctxCwd: ctx.cwd,
+        getFlag: (name) => getLensFlag(name),
+        dbg,
+        runtime,
+        cacheManager,
+        knipClient,
+        deadCodeClients,
+        depChecker,
+        testRunnerClient,
+        sessionId: getStableSessionId(ctx),
+        sessionScope: turnStartScope ?? scope ?? runtime.sessionScope,
+        signal: ctx.signal,
+        onTestRunnerComplete: (delivery) => stageTestRunnerDelivery({
+          ...delivery,
+          owner: {
+            ownerId: testRunnerDeliveryOwnerId,
+            cacheManager,
+            runtime,
+            getCtx: () => ownEventCtx ?? {}
+          }
+        }),
+        resetLSPService: () => {
+          try {
+            resetLSPService({ reason: "idle" });
+          } finally {
+            repaintLspStatus?.();
+          }
+        },
+        resetFormatService
+      });
+      repaintLspStatus?.();
+      if (runtime.hasStableSessionId) {
+        persistScope(ctx.cwd ?? process.cwd(), runtime.telemetrySessionId, runtime.sessionScope);
+      }
+    } catch (turnEndErr) {
+      if (isStaleExtensionCtxError(turnEndErr))
+        throw turnEndErr;
+      surfaceHandlerCrash("turn_end", turnEndErr, { dbg });
+    } finally {
+      setAmbientAbortSignal(undefined);
+    }
+  };
+  pi.on("turn_end", wrapSessionEventHandler("turn_end", onTurnEnd, { dbg }));
+  registerBuiltinQuietWindowTasks(() => runtime);
+  if (!_testRunnerDeliveryRegistered) {
+    _testRunnerDeliveryRegistered = true;
+    registerQuietWindowTask("test_runner_delivery", (quietContext) => {
+      deliverStagedTestRunnerFindings(quietContext);
+    });
+  }
+  registerCascadeTierReconcileTask(() => getLSPService(), {
+    onResolvedFound: ({ filePath, diagnostics, publishedAt }) => {
+      const run = buildResolvedFoundCascadeRun(runtime.projectRoot, {
+        filePath,
+        diagnostics,
+        publishedAt
+      });
+      if (run)
+        runtime.appendCascadeRun(run);
+    },
+    onResolvedClean: ({ filePath, publishedAt }) => {
+      reconcileCascadeNeighborLspErrors(filePath, [], undefined, publishedAt);
+    }
+  });
+  if (!_turnSummaryEmitRegistered) {
+    _turnSummaryEmitRegistered = true;
+    registerQuietWindowTask("turn_summary_emit", () => {
+      const emitCtx = _turnSummaryEmitCtxGetter?.();
+      if (!emitCtx || !emitCtx.isLensEnabled())
+        return;
+      let turnSummaryEnabled;
+      try {
+        turnSummaryEnabled = emitCtx.getLensFlag("lens-turn-summary");
+      } catch (err) {
+        if (isStaleExtensionCtxError(err)) {
+          dbg("turn_summary_emit: skipped — captured pi ctx is stale (session replaced/reloaded before the quiet window ran)");
+          return;
+        }
+        throw err;
+      }
+      if (!turnSummaryEnabled)
+        return;
+      if (emitCtx.runtime.turnSummary.isEmpty())
+        return;
+      const summaryStart = Date.now();
+      const cwd = emitCtx.runtime.projectRoot || process.cwd();
+      const details = emitCtx.runtime.turnSummary.consume(emitCtx.runtime.turnIndex, (fp) => toRunnerDisplayPath(cwd, fp));
+      const line = formatTurnSummaryLine(details);
+      const sendMessage = emitCtx.pi.sendMessage;
+      if (typeof sendMessage === "function") {
+        try {
+          sendMessage.call(emitCtx.pi, {
+            customType: TURN_SUMMARY_CUSTOM_TYPE,
+            content: line,
+            display: true,
+            details
+          });
+          recordTurnEndAdvisoryBytes(emitCtx.runtime.telemetrySessionId, Buffer.byteLength(line, "utf8"));
+        } catch (sendErr) {
+          if (isStaleExtensionCtxError(sendErr)) {
+            dbg("turn_summary_emit: skipped emit — pi ctx went stale (session replaced/reloaded)");
+            return;
+          }
+          dbg(`turn-summary sendMessage failed: ${sendErr}`);
+        }
+      } else {
+        dbg("turn-summary: pi.sendMessage unavailable on this host, skipping emit");
+      }
+      logLatency({
+        type: "phase",
+        toolName: "agent_settled",
+        filePath: cwd,
+        phase: "turn_summary",
+        durationMs: Date.now() - summaryStart,
+        metadata: {
+          files: details.files.length,
+          diagnostics: details.counts.diagnostics,
+          autofixes: details.counts.autofixes,
+          formats: details.counts.formats
+        }
+      });
+    });
+  }
+  const onAgentSettled = async (_event, ctx) => {
+    if (!lensEnabled)
+      return;
+    const settleBranchEpoch = runtime.readGuard.currentBranchEpoch;
+    rememberOwnEventCtx(ctx);
+    try {
+      setAmbientAbortSignal(ctx?.signal);
+      const settleSession = runtime.captureSessionGeneration();
+      try {
+        await runObservedSettledSweepSafely(ctx, settleBranchEpoch, settleSession);
+        await runDeferredMutationDrain(ctx);
+        await settleSession.guardedWrite(`observed-ledger-refresh:${ctx?.cwd ?? runtime.projectRoot}`, () => refreshObservedLedgerSafely(ctx));
+      } catch (drainErr) {
+        if (isStaleExtensionCtxError(drainErr))
+          throw drainErr;
+        surfaceHandlerCrash("agent_settled deferred_mutation_drain", drainErr, {
+          dbg
+        });
+      } finally {
+        setAmbientAbortSignal(undefined);
+        const settledIndex = runtime.wordIndex;
+        if (settledIndex && settleSession.isCurrent() && classifyOwnedSessionEmission(ctx, getStableSessionId(ctx)) === "primary") {
+          import("./clients/word-index.js").then(({ releaseWordIndexMemoAtSettle }) => releaseWordIndexMemoAtSettle(settledIndex)).catch((err) => surfaceHandlerCrash("word_index_memo_release", err, {
+            dbg,
+            rethrow: false
+          }));
+        }
+      }
+      const cwd = ctx?.cwd;
+      runQuietWindow({
+        runtime,
+        dbg,
+        cwd,
+        sessionId: getStableSessionId(ctx),
+        ownerId: testRunnerDeliveryOwnerId
+      }).catch((err) => {
+        surfaceHandlerCrash("quiet_window", err, { dbg, rethrow: false });
+      });
+      dumpActiveHandles("agent_settled");
+    } catch (settledErr) {
+      setAmbientAbortSignal(undefined);
+      throw settledErr;
+    }
+  };
+  try {
+    pi.on("agent_settled", wrapSessionEventHandler("agent_settled", onAgentSettled, { dbg }));
+  } catch (registerErr) {
+    dbg(`agent_settled registration failed (older pi host?): ${registerErr}`);
+  }
+  const retireOwnScope = (reason, sessionId) => {
+    if (!scope)
+      return;
+    retireScope(scope, reason);
+    logScopeTransition(scope, {
+      transition: "shutdown",
+      reason: scope.retiredBy(),
+      sessionId,
+      cwd: runtime.projectRoot
+    });
+  };
+  pi.on("session_shutdown", (event, ctx) => {
+    const stableSessionId = (() => {
+      try {
+        return ctx?.sessionManager?.getSessionId?.();
+      } catch {
+        return;
+      }
+    })();
+    const shutdownCwd = (() => {
+      try {
+        return ctx?.cwd;
+      } catch {
+        return;
+      }
+    })();
+    const shutdownClassification = classifyOwnedSessionShutdown(ctx, stableSessionId, shutdownCwd);
+    if (shutdownClassification === "secondary") {
+      if (stableSessionId !== undefined && shutdownCwd !== undefined) {
+        cacheManager.clearTurnState(shutdownCwd, {
+          kind: "pi",
+          id: stableSessionId
+        }, stableSessionId);
+      }
+      emitCacheUsageSummaryAtSessionEnd(stableSessionId, "concurrent-secondary");
+      clearCachePrefixSession(stableSessionId, "concurrent-secondary");
+      runtime.forgetTurnSession(stableSessionId);
+      decrementSecondarySessionCount();
+      if (ownedSecondaryRoot !== undefined) {
+        deregisterInstanceRoot(ownedSecondaryRoot, secondaryRootHolder).catch(() => {});
+      }
+      retireOwnScope(event?.reason, stableSessionId);
+      dbg("session_shutdown: concurrent secondary — skipping shared-infra teardown");
+      return;
+    }
+    const shutdownEvent = event;
+    const shutdownReason = shutdownEvent?.reason;
+    const shutdownBudgetKey = shutdownReason === "quit" ? "session_shutdown_quit" : "session_shutdown";
+    const ndjsonDrain = bounded(flushAllNdjsonWriters(), {
+      ms: HOOK_WALL_BUDGET_MS[shutdownBudgetKey],
+      signal: undefined,
+      hook: "session_shutdown",
+      label: "ndjson-writers"
+    });
+    try {
+      const unstartedReason = startInFlight || scope !== undefined ? undefined : namedSuccessorReason() ?? expiredSuccessorReason();
+      if (startInFlight || unstartedReason !== undefined) {
+        if (startInFlight)
+          startInFlight.shutDown = true;
+        forwardHandoff({
+          startReason: startInFlight ? startInFlight.reason : unstartedReason,
+          reason: shutdownReason,
+          sessionFile: getSessionFile(ctx),
+          targetSessionFile: shutdownEvent?.targetSessionFile,
+          sessionManager: getSessionManager(ctx)
+        });
+      } else if (scope && stashHandoff(scope, {
+        reason: shutdownReason,
+        sessionFile: getSessionFile(ctx),
+        targetSessionFile: shutdownEvent?.targetSessionFile,
+        sessionManager: getSessionManager(ctx)
+      }) && runtime.hasStableSessionId) {
+        persistScope(shutdownCwd ?? process.cwd(), runtime.telemetrySessionId, scope);
+      }
+      const switchesSessionFile = typeof shutdownEvent?.targetSessionFile === "string" && shutdownEvent.targetSessionFile.length > 0;
+      if (switchesSessionFile || shutdownReason === "quit" || shutdownReason === undefined) {
+        endSituationalToolTelemetry();
+      }
+      emitCacheUsageSummaryAtSessionEnd(stableSessionId, "primary");
+      clearCachePrefixSession(stableSessionId, "primary");
+      cancelLSPIdleReset();
+      deregisterInstance();
+      releasePrimarySession(shutdownReason, successorStartKey({
+        reason: shutdownReason,
+        sessionFile: getSessionFile(ctx),
+        targetSessionFile: shutdownEvent?.targetSessionFile,
+        sessionManager: getSessionManager(ctx)
+      }));
+      markAnalyzerBootstrapShutdown();
+      resetLSPService({
+        fast: true,
+        processExiting: true,
+        reason: "session_shutdown"
+      });
+      emitBusEventRollupAtSessionEnd(runtime.projectRoot);
+      emitFenceRollupAtSessionEnd(runtime.projectRoot);
+      emitVerifiedPathAttributionRollup(runtime.projectRoot);
+      emitConcurrentSessionBindRollupAtSessionEnd(runtime.projectRoot);
+      dumpActiveHandles("session_shutdown");
+    } finally {
+      retireOwnScope(shutdownReason, stableSessionId);
+    }
+    return ndjsonDrain;
+  });
+  try {
+    pi.on?.("message_end", (event, ctx) => {
+      if (!lensEnabled)
+        return;
+      try {
+        const sessionId = getStableSessionId(ctx);
+        const ctxActive = probeCtxActive(ctx);
+        const staleCtx = ctxActive === false;
+        if (ctxActive === true) {
+          noteLiveMessageEndSessionId(sessionId);
+        }
+        logCacheUsage(event?.message, dbg, {
+          sessionId,
+          sessionRole: classifyOwnedSessionEmission(ctx, sessionId),
+          turnIndex: runtime.turnIndex
+        });
+        if (staleCtx) {
+          const degradation = {
+            kind: "cache-usage-attribution-stale",
+            subject: "message_end",
+            reason: "message_end met a stale extension ctx; cache_usage row wrote without a stable session id",
+            metadata: {
+              sessionId: getLastLiveMessageEndSessionId() ?? "unknown"
+            }
+          };
+          incrementDegradationCount(degradation);
+        }
+      } catch (err) {
+        surfaceHandlerCrash("message_end", err, { dbg });
+      }
+    });
+  } catch (err) {
+    dbg(`message_end subscribe failed (older pi host?): ${err}`);
+  }
+  const isPlainUserPrompt = (msg) => {
+    if (msg.role !== "user")
+      return false;
+    if (typeof msg.content === "string")
+      return true;
+    if (!Array.isArray(msg.content))
+      return false;
+    return !msg.content.some((block) => typeof block === "object" && block !== null && block.type === "tool_result");
+  };
+  const appendToUserPromptContent = (content, injectedText) => {
+    if (typeof content === "string") {
+      return content.length > 0 ? `${content}
+
+${injectedText}` : injectedText;
+    }
+    return [...content, { type: "text", text: injectedText }];
+  };
+  pi.on("context", wrapSessionEventHandlerWithResult("context", async (event, ctx) => {
+    const existingMessages = event?.messages ?? [];
+    const prefixSessionId = getStableSessionId(ctx);
+    const sessionRole = classifyOwnedSessionEmission(ctx, prefixSessionId);
+    observeCachePrefix(existingMessages, runtime.turnIndex, prefixSessionId, sessionRole, dbg);
+    const effectiveInjectionEnabled = lensEnabled && contextInjectionEnabled;
+    let telemetryLogged = false;
+    const logContextObservation = (resultMessages, placement, injectionSlices) => {
+      if (telemetryLogged)
+        return;
+      telemetryLogged = true;
+      observeCacheContext({
+        existingMessages,
+        resultMessages,
+        sessionId: prefixSessionId,
+        sessionRole,
+        turnIndex: runtime.turnIndex,
+        injectionEnabled: effectiveInjectionEnabled,
+        injectionSlices,
+        placement,
+        dbg
+      });
+    };
+    try {
+      const cwd = ctx.cwd ?? process.cwd();
+      if (!effectiveInjectionEnabled) {
+        logContextObservation(existingMessages, "none", []);
+        return;
+      }
+      const turnEndFindings = consumeTurnEndFindings(cacheManager, cwd, runtime);
+      const sessionGuidance = consumeSessionStartGuidance(cacheManager, cwd);
+      const testFindings = consumeStagedTestRunnerFindings({
+        cwd,
+        sessionId: runtime.telemetrySessionId,
+        ownerId: testRunnerDeliveryOwnerId,
+        cacheManager,
+        runtime
+      });
+      const agentNudge = consumeAgentNudge(dbg, scope);
+      const sourceMessages = [
+        {
+          source: "session-guidance",
+          messages: sessionGuidance?.messages ?? []
+        },
+        {
+          source: "turn-findings",
+          messages: turnEndFindings?.messages ?? []
+        },
+        {
+          source: "test-findings",
+          messages: testFindings?.messages ?? []
+        },
+        {
+          source: "agent-nudge",
+          messages: agentNudge?.messages ?? []
+        }
+      ].filter((source) => source.messages.length > 0);
+      const injectedMessages = sourceMessages.flatMap((source) => source.messages);
+      if (injectedMessages.length === 0) {
+        logContextObservation(existingMessages, "none", []);
+        return;
+      }
+      if (existingMessages.length === 0) {
+        const resultMessages = [...injectedMessages];
+        logContextObservation(resultMessages, "prepend", sourceMessages);
+        return { messages: resultMessages };
+      }
+      const lastMessage = existingMessages[existingMessages.length - 1];
+      if (!isPlainUserPrompt(lastMessage)) {
+        const resultMessages = [...existingMessages, ...injectedMessages];
+        logContextObservation(resultMessages, "append", sourceMessages);
+        return { messages: resultMessages };
+      }
+      const injectedText = injectedMessages.map((m) => m.content).join(`
+
+`);
+      if (!injectedText) {
+        logContextObservation(existingMessages, "none", []);
+        return;
+      }
+      const updatedLastMessage = {
+        ...lastMessage,
+        content: appendToUserPromptContent(lastMessage.content, injectedText)
+      };
+      const resultMessages = [
+        ...existingMessages.slice(0, -1),
+        updatedLastMessage
+      ];
+      logContextObservation(resultMessages, "append-to-last-user", sourceMessages);
+      return { messages: resultMessages };
+    } catch (err) {
+      if (isStaleExtensionCtxError(err))
+        throw err;
+      if (!telemetryLogged)
+        logContextObservation(existingMessages, "none", []);
+      dbg(`context event error: ${err}`);
+    }
+  }, {
+    dbg,
+    onStaleResult: () => {
+      return;
+    }
+  }));
+}
+export default function dist_default(pi) {
+  return runInConsoleCaptureWindow(() => activateExtension(pi));
+}
+closeModuleLoadConsoleWindow();