@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1782 +0,0 @@
-import"./clients/console-guard-install.js";
-import { BoundedSet } from "./clients/bounded-cache.js";
-import { bounded } 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 * 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 { clearWidgetState, exportWidgetState, getFailedLspServerIds, getSessionLanguages, importWidgetState, reconcileCascadeNeighborLspErrors, renderWidget, scheduleStaleReconcile, setRenderCallback, wireWidgetDispositionSubscriber } from "./clients/widget-state.js";
-import { selectLspStatus } from "./clients/lsp-status.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 { normalizeFilePath } from "./clients/path-utils.js";
-import { isRecordableProjectPath } from "./clients/file-utils.js";
-import { dropStaleFiles, loadSessionState, saveSessionState, sessionStartMode } 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 { 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 { 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/index.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, noteSessionShutdown, releasePrimarySession, probeCtxActive } from "./clients/session-lifecycle.js";
-import { clearLastAnalyzedStateCache, flushDebouncedToolResults, 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, clearRememberedLazyTools, getRememberedLazyTools, inheritRememberedLazyTools, 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";
-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 _readBridgeRegistered = false;
-let _bridgeGetFlag;
-let _mutationBridgeRegistered = false;
-function getBridgeFlag(getter, bridge) {
-  try {
-    return getter?.("no-read-guard");
-  } 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 _turnSummaryEmitCtx;
-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);
-  const testRunnerDeliveryOwnerId = `activation-${++_nextTestRunnerDeliveryOwnerId}`;
-  let ownEventCtx;
-  let ownedSessionRole;
-  const classifyOwnedSessionEmission = (ctx, sessionId) => ownedSessionRole ?? classifyCurrentSessionEmission(ctx, sessionId);
-  const classifyOwnedSessionShutdown = (ctx, sessionId, root) => ownedSessionRole === "concurrent-secondary" ? "secondary" : ownedSessionRole === "primary" ? "primary" : noteSessionShutdown(ctx, sessionId, root);
-  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));
-  let lensEnabled = !getLensFlag("no-lens");
-  _bridgeGetFlag = getLensFlag;
-  if (!_readBridgeRegistered) {
-    _readBridgeRegistered = true;
-    registerReadBridge({
-      getReadGuard: () => runtime.readGuard,
-      getTurnIndex: () => runtime.turnIndex,
-      peekWriteIndex: () => runtime.peekWriteIndex(),
-      isRecordable(filePath) {
-        if (getBridgeFlag(_bridgeGetFlag, "read"))
-          return false;
-        return isRecordableProjectPath(filePath, runtime.projectRoot);
-      }
-    });
-  }
-  if (!_mutationBridgeRegistered) {
-    _mutationBridgeRegistered = true;
-    registerMutationBridge({
-      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
-    });
-  }
-  let contextInjectionEnabled = !getLensFlag("no-lens-context");
-  let lensWidgetVisible = globalConfig?.widget?.visible !== false;
-  let mountedLensWidgetUi;
-  let widgetMountFailureLogged = false;
-  let pendingForkSnapshot;
-  let pendingForkReadGuard;
-  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) => {
-      renderInvalidator = () => tui.requestRender();
-      setRenderCallback(() => {
-        scheduleStaleReconcile();
-        hostPorts.render.invalidate();
-      });
-      return {
-        render: (width) => {
-          scheduleStaleReconcile();
-          return renderWidget(width, theme);
-        },
-        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 pi 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 PI-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 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 PI-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.nextWriteIndex(), captureLspStatusRepaint, () => runtime, () => Boolean(getLensFlag("lens-guard"))),
-    createSymbolSearchTool(() => runtime.projectRoot),
-    createEffectiveConfigTool(() => runtime.projectRoot, noToolFlag),
-    createProjectReportTool(() => runtime.projectRoot),
-    createModuleReportTool(() => runtime.projectRoot),
-    createReadSymbolTool(() => runtime.projectRoot, (filePath, symbol) => runtime.readGuard.recordSymbolRead(filePath, symbol, runtime.turnIndex, runtime.peekWriteIndex())),
-    createReadEnclosingTool(() => runtime.projectRoot, (filePath, symbol) => runtime.readGuard.recordSymbolRead(filePath, symbol, runtime.turnIndex, runtime.peekWriteIndex()))
-  ];
-  const lazyTools = [
-    createAstGrepSearchTool(astGrepClient),
-    createAstGrepReplaceTool(astGrepClient),
-    createAstGrepOutlineTool(astGrepClient),
-    createLspNavigationTool((name, cwd) => getLensFlag(name, cwd), {
-      runtime,
-      cacheManager,
-      readGuard: runtime.readGuard,
-      dbg
-    }),
-    createLensDiagnosticMarkTool(() => runtime.projectRoot, () => ({
-      model: runtime.telemetryModelId,
-      provider: runtime.telemetryProviderId
-    }))
-  ];
-  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;
-    }
-  };
-  let lastSessionStartIdentity;
-  const activateToolsTool = createActivateToolsTool(pi, filteredLazyCatalog, {
-    onActivated: (names, ctx) => {
-      observeSituationalToolActivation(names);
-      rememberLazyTools(getSessionFile(ctx), 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) => {
-    return {
-      skillPaths: resolveSkillPaths(import.meta.url)
-    };
-  });
-  pi.on("session_start", wrapSessionEventHandler("session_start", async (event, ctx) => {
-    const sessionStartReason = event.reason;
-    const previousSessionFile = event.previousSessionFile;
-    const sessionIdentityParts = (() => {
-      try {
-        const sessionManager = ctx?.sessionManager;
-        return {
-          sessionId: sessionManager?.getSessionId?.(),
-          sessionFile: getSessionFile(ctx)
-        };
-      } catch {
-        return { sessionId: undefined, sessionFile: undefined };
-      }
-    })();
-    const sessionStartKey = sessionIdentityParts.sessionId ?? sessionIdentityParts.sessionFile;
-    const sessionStartIdentity = sessionStartKey === undefined ? undefined : `${sessionStartReason ?? ""}\x00${sessionStartKey}`;
-    const liveToolPlan = (() => {
-      if (getLensFlag("no-lazy-tools") === true || typeof pi.getActiveTools !== "function") {
-        return;
-      }
-      try {
-        const piWithActiveTools = pi;
-        const lazyNames = new Set(LAZY_TOOL_CATALOG.map((tool) => tool.name));
-        return planToolSet(piWithActiveTools.getActiveTools(), lazyNames, isFreshSessionStart(sessionStartReason) ? new Set : getRememberedLazyTools(getSessionFile(ctx)));
-      } catch {
-        return;
-      }
-    })();
-    if (sessionStartIdentity !== undefined && lastSessionStartIdentity === sessionStartIdentity && liveToolPlan?.changed !== true) {
-      emitBounded("session_start_duplicate_suppressed", sessionStartIdentity, {
-        durationMs: 0,
-        metadata: { reason: "duplicate start suppressed" }
-      }, {
-        ledgerKind: "session-start-duplicate",
-        risingEdgePer: "identity",
-        reason: "duplicate start suppressed"
-      });
-      return;
-    }
-    lastSessionStartIdentity = sessionStartIdentity;
-    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;
-      dbg(`session_start: disabled tools = ${disabledToolNames.join(",") || "none"}`);
-      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);
-      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") {
-          registerInstanceRoot(sessionStartCwd).catch(() => {});
-        }
-        return;
-      }
-      resetVerifiedPathAttributionGuessCount();
-      resetCurrentPhaseForSession();
-      resetCacheFindingIdentitiesSession(stableSessionId, ownedSessionRole);
-      resetOncePerSessionPhases();
-      startSituationalToolTelemetrySession("pi");
-      emitConcurrentSessionBindRollupAtSessionEnd(runtime.projectRoot);
-      resetConcurrentSessionBindRollupCounts();
-      try {
-        const piWithActiveTools = pi;
-        const sessionFile = getSessionFile(ctx);
-        if (sessionStartReason === "fork") {
-          inheritRememberedLazyTools(previousSessionFile, sessionFile);
-        }
-        if (isFreshSessionStart(sessionReason)) {
-          clearRememberedLazyTools(sessionFile);
-        }
-        if (getLensFlag("no-lazy-tools") !== true && typeof piWithActiveTools.getActiveTools === "function" && typeof piWithActiveTools.setActiveTools === "function") {
-          const lazyNames = new Set(LAZY_TOOL_CATALOG.map((t) => t.name));
-          const plan = planToolSet(piWithActiveTools.getActiveTools(), lazyNames, getRememberedLazyTools(sessionFile));
-          if (plan.changed) {
-            piWithActiveTools.setActiveTools(plan.desired);
-            recordToolSetMutation({
-              addedCount: plan.addedCount,
-              removedCount: plan.removedCount,
-              reason: isFreshSessionStart(sessionReason) ? "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}`);
-      }
-      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 })));
-        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);
-      await bounded(handleSessionStart({
-        ctxCwd: ctx.cwd,
-        sessionStartFiredAt,
-        sessionStartMonotonicAt,
-        extensionLoadedAt: DM_LENS_LOADED_AT_MS,
-        emitHostReadyDelay,
-        sessionReason,
-        handlerEnteredAt,
-        globalConfig,
-        projectConfig: loadDmLensProjectConfig(runtime.projectRoot),
-        sessionStartClassification: sessionStartDecision.classification,
-        sessionStartSameRoot: sessionStartDecision.sameRoot,
-        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
-      }), {
-        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);
-      runtime.setSessionLifecycle({
-        sessionId: stableSessionId,
-        reason: sessionReason
-      });
-      const reasonLabel = sessionReason ?? "startup";
-      const startMode = sessionStartMode(sessionReason, !!pendingForkSnapshot);
-      if (startMode === "fork" && pendingForkSnapshot) {
-        clearWidgetState();
-        importWidgetState(pendingForkSnapshot);
-        const forkedFileCount = pendingForkSnapshot.files.length;
-        pendingForkSnapshot = undefined;
-        let forkReadImport;
-        if (pendingForkReadGuard) {
-          forkReadImport = runtime.readGuard.importState(pendingForkReadGuard);
-          pendingForkReadGuard = undefined;
-        }
-        if (stableSessionId) {
-          saveSessionState(ctx.cwd ?? process.cwd(), stableSessionId, exportWidgetState(), runtime.readGuard.exportState());
-        }
-        dbg(`session_start: fork — branched ${forkedFileCount} file(s) from source` + (forkReadImport ? `, read-guard +${forkReadImport.imported} (dropped ${forkReadImport.dropped})` : ""));
-      } else if (startMode === "keep") {
-        dbg("session_start: reload — keeping widget state");
-      } else if (startMode === "clean") {
-        pendingForkSnapshot = undefined;
-        pendingForkReadGuard = undefined;
-        clearWidgetState();
-        dbg("session_start: new — clean widget");
-      } else {
-        pendingForkSnapshot = undefined;
-        pendingForkReadGuard = undefined;
-        clearWidgetState();
-        if (stableSessionId) {
-          const persisted = await loadSessionState(ctx.cwd ?? process.cwd(), stableSessionId);
-          if (persisted?.widget) {
-            const fresh = await dropStaleFiles(persisted.widget, persisted.savedAt);
-            const dropped = persisted.widget.files.length - fresh.files.length;
-            importWidgetState(fresh);
-            const readImport = runtime.readGuard.importState(persisted.readGuard);
-            dbg(`session_start: ${reasonLabel} ${stableSessionId} — rehydrated ${fresh.files.length} file(s)` + (dropped > 0 ? `, dropped ${dropped} stale` : "") + (readImport.imported > 0 || readImport.dropped > 0 ? `; read-guard +${readImport.imported} read(s) (dropped ${readImport.dropped} stale)` : ""));
-          } else {
-            dbg(`session_start: ${reasonLabel} ${stableSessionId} — no persisted state (clean)`);
-          }
-        } else {
-          dbg(`session_start: ${reasonLabel} — no stable session id (clean)`);
-        }
-      }
-      if (lensWidgetVisible) {
-        mountLensWidget(ctx.ui, readExtensionMode(ctx));
-      }
-    } catch (sessionErr) {
-      if (isStaleExtensionCtxError(sessionErr))
-        throw sessionErr;
-      surfaceHandlerCrash("session_start", sessionErr, { dbg });
-    }
-  }, { dbg }));
-  pi.on("session_before_fork", () => {
-    try {
-      pendingForkSnapshot = exportWidgetState();
-      pendingForkReadGuard = runtime.readGuard.exportState();
-      dbg(`session_before_fork: stashed ${pendingForkSnapshot.files.length} file(s) + ${pendingForkReadGuard.reads.length} read-guard file(s) for the fork`);
-    } catch (forkErr) {
-      surfaceHandlerCrash("session_before_fork", forkErr, { 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
-    });
-  });
-  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)
-      }), {
-        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";
-      }
-    }
-  }));
-  const onTurnStart = (_event, ctx) => {
-    rememberOwnEventCtx(ctx);
-    adoptProjectTrustFromPorts(hostPorts);
-    if (lensWidgetVisible && ctx?.ui && (mountedLensWidgetUi === undefined || mountedLensWidgetUi !== ctx.ui)) {
-      mountLensWidget(ctx.ui, readExtensionMode(ctx));
-    }
-    runtime.beginTurn();
-    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 })));
-      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) {
-    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: replayThroughMutationBridge,
-        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();
-      if (shouldEmitMemorySampleAdaptive(runtime.turnIndex)) {
-        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, runtime.turnIndex);
-        } catch {}
-      }
-      if (shouldCheckSmellsThisTurn(runtime.turnIndex)) {
-        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),
-        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) {
-        saveSessionState(ctx.cwd ?? process.cwd(), runtime.telemetrySessionId, exportWidgetState(), runtime.readGuard.exportState());
-      }
-    } 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);
-    }
-  });
-  _turnSummaryEmitCtx = {
-    pi,
-    getLensFlag: (name) => getLensFlag(name),
-    isLensEnabled: () => lensEnabled
-  };
-  if (!_turnSummaryEmitRegistered) {
-    _turnSummaryEmitRegistered = true;
-    registerQuietWindowTask("turn_summary_emit", () => {
-      const emitCtx = _turnSummaryEmitCtx;
-      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 (runtime.turnSummary.isEmpty())
-        return;
-      const summaryStart = Date.now();
-      const cwd = runtime.projectRoot || process.cwd();
-      const details = runtime.turnSummary.consume(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(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;
-    rememberOwnEventCtx(ctx);
-    try {
-      setAmbientAbortSignal(ctx?.signal);
-      try {
-        await runObservedSettledSweepSafely(ctx);
-        await runDeferredMutationDrain(ctx);
-        await refreshObservedLedgerSafely(ctx);
-      } catch (drainErr) {
-        if (isStaleExtensionCtxError(drainErr))
-          throw drainErr;
-        surfaceHandlerCrash("agent_settled deferred_mutation_drain", drainErr, {
-          dbg
-        });
-      } finally {
-        setAmbientAbortSignal(undefined);
-      }
-      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}`);
-  }
-  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") {
-      emitCacheUsageSummaryAtSessionEnd(stableSessionId, "concurrent-secondary");
-      clearCachePrefixSession(stableSessionId, "concurrent-secondary");
-      decrementSecondarySessionCount();
-      try {
-        const secondaryRoot = shutdownCwd;
-        const primaryRoot = getActivePrimaryRoot();
-        if (typeof secondaryRoot === "string" && secondaryRoot.length > 0 && primaryRoot !== undefined && normalizeFilePath(secondaryRoot) !== primaryRoot) {
-          deregisterInstanceRoot(secondaryRoot).catch(() => {});
-        }
-      } catch {}
-      dbg("session_shutdown: concurrent secondary — skipping shared-infra teardown");
-      return;
-    }
-    const shutdownEvent = event;
-    const shutdownReason = shutdownEvent?.reason;
-    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();
-    markAnalyzerBootstrapShutdown();
-    resetLSPService({
-      fast: true,
-      processExiting: true,
-      reason: "session_shutdown"
-    });
-    emitBusEventRollupAtSessionEnd(runtime.projectRoot);
-    emitVerifiedPathAttributionRollup(runtime.projectRoot);
-    emitConcurrentSessionBindRollupAtSessionEnd(runtime.projectRoot);
-    dumpActiveHandles("session_shutdown");
-  });
-  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 (!Array.isArray(msg.content))
-      return true;
-    return !msg.content.some((block) => typeof block === "object" && block !== null && block.type === "tool_result");
-  };
-  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);
-      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 resultMessages = [
-        ...existingMessages.slice(0, -1),
-        ...injectedMessages,
-        lastMessage
-      ];
-      logContextObservation(resultMessages, "insert-before-final", 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();