@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/index.js

@@ -1,5 +1,7 @@
 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,
@@ -14,6 +16,10 @@ import {
   recordDegradation,
   renderDegradationLines
 } from "./clients/degradation-ledger.js";
+import {
+  TOOL_REGISTRY,
+  toolRegistryEntryForPi
+} from "./clients/tool-config.js";
 import {
   adoptProjectTrustFromPorts,
   assertInstallAllowed,
@@ -36,11 +42,11 @@ import {
   loadBootstrapClients,
   markAnalyzerBootstrapShutdown,
   peekBootstrapClients,
-  requestBootstrapClients
+  requestBootstrapClients,
+  getAgentBehaviorClient
 } from "./clients/bootstrap.js";
 import { CacheManager } from "./clients/cache-manager.js";
-import { retireInlineBlockerAndResyncGuard } from "./clients/git-guard.js";
-import { resolvePackagePath } from "./clients/package-root.js";
+import { resolveSkillPaths } from "./clients/skills-resolver.js";
 import {
   clearWidgetState,
   exportWidgetState,
@@ -50,7 +56,8 @@ import {
   reconcileCascadeNeighborLspErrors,
   renderWidget,
   scheduleStaleReconcile,
-  setRenderCallback
+  setRenderCallback,
+  wireWidgetDispositionSubscriber
 } from "./clients/widget-state.js";
 import { selectLspStatus } from "./clients/lsp-status.js";
 import { registerMutationBridge } from "./clients/mutation-bridge.js";
@@ -65,6 +72,7 @@ import {
   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";
@@ -92,7 +100,16 @@ import {
   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";
@@ -117,6 +134,7 @@ 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,
@@ -156,8 +174,8 @@ import {
   consumeTurnEndFindings
 } from "./clients/runtime-context.js";
 import {
+  consumeStagedTestRunnerFindings,
   deliverStagedTestRunnerFindings,
-  registerTestRunnerMessageRenderer,
   stageTestRunnerDelivery
 } from "./clients/test-runner-delivery.js";
 import {
@@ -165,9 +183,11 @@ import {
   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";
@@ -193,7 +213,6 @@ import {
 } from "./clients/quiet-window.js";
 import { setAmbientAbortSignal } from "./clients/safe-spawn.js";
 import { initI18n, t } from "./i18n.js";
-import { createAstGrepDumpTool } from "./tools/ast-dump.js";
 import {
   createActivateToolsTool
 } from "./tools/activate-tools.js";
@@ -202,7 +221,6 @@ 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 { createLspDiagnosticsTool } from "./tools/lsp-diagnostics.js";
 import { createLspNavigationTool } from "./tools/lsp-navigation.js";
 import {
   createModuleReportTool,
@@ -228,16 +246,29 @@ import {
 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
+  observeCachePrefix,
+  recordToolResultDelivery,
+  resetCacheFindingIdentitiesSession,
+  recordTurnEndAdvisoryBytes
 } from "./clients/cache-observability.js";
 import {
   buildStartupTimingRecords,
@@ -399,9 +430,22 @@ function log(_msg) {}
 const runtime = new RuntimeCoordinator;
 const cacheManager = new CacheManager;
 let _readBridgeRegistered = false;
-let _readBridgeGetFlag;
+let _bridgeGetFlag;
 let _mutationBridgeRegistered = false;
-let _mutationBridgeGetFlag;
+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;
@@ -410,8 +454,9 @@ const LSP_CONFIG_CWD_CAP = 128;
 const _lspConfigInitializedCwds = new BoundedSet(LSP_CONFIG_CWD_CAP);
 async function ensureLSPConfigInitialized(cwd) {
   const normalizedCwd = path.resolve(cwd);
-  if (_lspConfigInitializedCwds.has(normalizedCwd))
+  if (!shouldInitializeSessionRoot(normalizedCwd, _lspConfigInitializedCwds)) {
     return;
+  }
   await initLSPConfig(normalizedCwd);
   _lspConfigInitializedCwds.add(normalizedCwd);
 }
@@ -486,18 +531,27 @@ function activateExtension(hostPi) {
     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", `LSP Active: ${activeIds.join(", ")}`));
+        parts.push(theme.fg("success", activeText));
       }
       if (failedIds.length > 0) {
-        parts.push(theme.fg("error", `LSP Failed: ${failedIds.join(", ")}`));
+        parts.push(theme.fg("error", failedText));
       }
-      setStatus("dm-lens-lsp", parts.length > 0 ? parts.join(" · ") : theme.fg("dim", "LSP Inactive"));
+      setStatus("dm-lens-lsp", parts.length > 0 ? parts.join(" · ") : theme.fg("dim", inactiveText));
     } catch (err) {
       dbg(`lsp status update skipped: ${err}`);
     }
@@ -523,6 +577,10 @@ function activateExtension(hostPi) {
       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);
@@ -532,8 +590,17 @@ function activateExtension(hostPi) {
     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");
-  _readBridgeGetFlag = getLensFlag;
+  _bridgeGetFlag = getLensFlag;
   if (!_readBridgeRegistered) {
     _readBridgeRegistered = true;
     registerReadBridge({
@@ -541,13 +608,12 @@ function activateExtension(hostPi) {
       getTurnIndex: () => runtime.turnIndex,
       peekWriteIndex: () => runtime.peekWriteIndex(),
       isRecordable(filePath) {
-        if (_readBridgeGetFlag?.("no-read-guard"))
+        if (getBridgeFlag(_bridgeGetFlag, "read"))
           return false;
         return isRecordableProjectPath(filePath, runtime.projectRoot);
       }
     });
   }
-  _mutationBridgeGetFlag = getLensFlag;
   if (!_mutationBridgeRegistered) {
     _mutationBridgeRegistered = true;
     registerMutationBridge({
@@ -560,7 +626,7 @@ function activateExtension(hostPi) {
         return isRecordableProjectPath(filePath, runtime.projectRoot);
       },
       shouldStampReadGuard() {
-        return !_mutationBridgeGetFlag?.("no-read-guard");
+        return !getBridgeFlag(_bridgeGetFlag, "mutation");
       },
       dbg
     });
@@ -625,7 +691,6 @@ function activateExtension(hostPi) {
       dbg(`turn-summary renderer registration failed: ${registerRendererErr}`);
     }
   }
-  registerTestRunnerMessageRenderer(pi);
   pi.registerCommand("lens-toggle", {
     description: "Toggle dm-lens on/off for the current session. Usage: /lens-toggle",
     handler: async (_args, ctx) => {
@@ -807,6 +872,9 @@ function activateExtension(hostPi) {
           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:");
@@ -932,23 +1000,9 @@ ${degradationLines.join(`
     }
   });
   const alwaysActiveTools = [
-    createLensDiagnosticsTool(cacheManager, () => runtime.projectRoot, undefined, () => flushDebouncedToolResults(), () => runtime.nextWriteIndex(), captureLspStatusRepaint, () => runtime),
-    createLspDiagnosticsTool(() => runtime.nextWriteIndex(), ({ filePath, writeIndex, coveredSources, cwd }) => {
-      const retired = retireInlineBlockerAndResyncGuard({
-        runtime,
-        cacheManager,
-        cwd,
-        filePath,
-        writeIndex,
-        coveredSources,
-        lensGuardEnabled: getLensFlag("lens-guard") === true
-      });
-      if (retired) {
-        dbg(`inline_blocker: retired for ${filePath} — lsp_diagnostics confirmed clean (writeIndex ${writeIndex ?? "none"}, covered ${coveredSources.join(",") || "none"})`);
-      }
-    }),
+    createLensDiagnosticsTool(cacheManager, () => runtime.projectRoot, undefined, () => flushDebouncedToolResults(), () => runtime.nextWriteIndex(), captureLspStatusRepaint, () => runtime, () => Boolean(getLensFlag("lens-guard"))),
     createSymbolSearchTool(() => runtime.projectRoot),
-    createEffectiveConfigTool(() => 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())),
@@ -958,7 +1012,6 @@ ${degradationLines.join(`
     createAstGrepSearchTool(astGrepClient),
     createAstGrepReplaceTool(astGrepClient),
     createAstGrepOutlineTool(astGrepClient),
-    createAstGrepDumpTool(astGrepClient),
     createLspNavigationTool((name, cwd) => getLensFlag(name, cwd), {
       runtime,
       cacheManager,
@@ -970,37 +1023,31 @@ ${degradationLines.join(`
       provider: runtime.telemetryProviderId
     }))
   ];
-  const LAZY_TOOL_CATALOG = [
-    {
-      name: "ast_grep_search",
-      summary: "AST-aware structural code search across ~40 languages (ast-grep patterns)."
-    },
-    {
-      name: "ast_grep_replace",
-      summary: "AST-aware structural code rewrite/refactor (ast-grep patterns)."
-    },
-    {
-      name: "ast_grep_outline",
-      summary: "Syntax-only file/dir structure (symbols/imports/exports/members) via ast-grep outline — no index/LSP."
-    },
-    {
-      name: "ast_grep_dump",
-      summary: "Dump the tree-sitter AST for a source snippet to discover node kinds/field names."
-    },
-    {
-      name: "lsp_navigation",
-      summary: "IDE-style LSP navigation: definition, references, implementation, rename, call hierarchy."
-    },
-    {
-      name: "lens_diagnostic_mark",
-      summary: "Record a disposition for a diagnostic: false-positive / suppress (inline ignore comment) / defer (this session) / flagged (to fix)."
+  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 rememberedLazyTools = new Set;
-  const activateToolsTool = createActivateToolsTool(pi, LAZY_TOOL_CATALOG, {
-    onActivated: (names) => {
-      for (const name of names)
-        rememberedLazyTools.add(name);
+  };
+  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 {
@@ -1015,20 +1062,89 @@ ${degradationLines.join(`
   const toolsToRegister = [
     ...alwaysActiveTools,
     activateToolsTool,
-    ...lazyTools
-  ];
+    ...filteredLazyTools
+  ].filter((tool) => tool.name === "dm_lens_activate_tools" || isToolEnabled(tool.name));
   for (const tool of compactToolLineEnabled ? wrapToolsForCompactLine(toolsToRegister) : toolsToRegister) {
     try {
-      pi.registerTool(normalizeToolDefinition(tool));
+      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) => {
-    const skillsDir = resolvePackagePath(import.meta.url, "skills");
     return {
-      skillPaths: [skillsDir]
+      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({
@@ -1049,7 +1165,8 @@ ${degradationLines.join(`
       const buildIdentity = getBuildIdentity(import.meta.url);
       if (buildIdentity)
         dbg(formatBuildIdentity(buildIdentity));
-      const sessionReason = event.reason;
+      const sessionReason = sessionStartReason;
+      dbg(`session_start: disabled tools = ${disabledToolNames.join(",") || "none"}`);
       const trustState = adoptProjectTrustFromPorts(hostPorts);
       if (trustState !== "unknown") {
         dbg(`session_start: project trust = ${trustState}`);
@@ -1090,16 +1207,23 @@ ${degradationLines.join(`
       }
       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") {
-          if (isFreshSessionStart(sessionReason))
-            rememberedLazyTools.clear();
           const lazyNames = new Set(LAZY_TOOL_CATALOG.map((t) => t.name));
-          const plan = planToolSet(piWithActiveTools.getActiveTools(), lazyNames, rememberedLazyTools);
+          const plan = planToolSet(piWithActiveTools.getActiveTools(), lazyNames, getRememberedLazyTools(sessionFile));
           if (plan.changed) {
             piWithActiveTools.setActiveTools(plan.desired);
             recordToolSetMutation({
@@ -1139,7 +1263,8 @@ ${degradationLines.join(`
       const handlerEnteredAt = Date.now();
       const emitHostReadyDelay = consumeHostReadyDelayAnchor();
       resetMemorySamplerCadence();
-      await handleSessionStart({
+      resetTurnContext(stableSessionId);
+      await bounded(handleSessionStart({
         ctxCwd: ctx.cwd,
         sessionStartFiredAt,
         sessionStartMonotonicAt,
@@ -1147,6 +1272,8 @@ ${degradationLines.join(`
         emitHostReadyDelay,
         sessionReason,
         handlerEnteredAt,
+        globalConfig,
+        projectConfig: loadDmLensProjectConfig(runtime.projectRoot),
         sessionStartClassification: sessionStartDecision.classification,
         sessionStartSameRoot: sessionStartDecision.sameRoot,
         getFlag: (name) => getLensFlag(name),
@@ -1161,6 +1288,11 @@ ${degradationLines.join(`
         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);
@@ -1216,8 +1348,7 @@ ${degradationLines.join(`
     } catch (sessionErr) {
       if (isStaleExtensionCtxError(sessionErr))
         throw sessionErr;
-      dbg(`session_start crashed: ${sessionErr}`);
-      dbg(`session_start crash stack: ${sessionErr.stack}`);
+      surfaceHandlerCrash("session_start", sessionErr, { dbg });
     }
   }, { dbg }));
   pi.on("session_before_fork", () => {
@@ -1226,10 +1357,14 @@ ${degradationLines.join(`
       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) {
-      dbg(`session_before_fork crashed: ${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,
@@ -1251,6 +1386,7 @@ ${degradationLines.join(`
     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",
@@ -1265,28 +1401,48 @@ ${degradationLines.join(`
       });
     }
     try {
-      const { biomeClient, ruffClient, metricsClient, agentBehaviorClient } = await loadBootstrapClients();
-      return await handleToolResult({
+      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,
-        ruffClient,
-        metricsClient,
+        biomeClient: resident?.biomeClient,
+        ruffClient: resident?.ruffClient,
+        metricsClient: resident?.metricsClient,
         resetLSPService,
         readGuard: runtime.readGuard,
-        agentBehaviorRecord: (toolName, filePath) => agentBehaviorClient.recordToolCall(toolName, filePath),
-        formatBehaviorWarnings: (warnings) => agentBehaviorClient.formatWarnings(warnings),
+        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 }));
+  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);
@@ -1326,18 +1482,19 @@ ${degradationLines.join(`
         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) {
-      dbg(`observed_settled_sweep crashed: ${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: ctx?.signal
+        signal
       });
     } catch (refreshErr) {
-      dbg(`observed_ledger_refresh crashed: ${refreshErr}`);
+      surfaceHandlerCrash("observed_ledger_refresh", refreshErr, { dbg });
     }
   }
   async function runDeferredMutationDrain(ctx) {
@@ -1355,6 +1512,7 @@ ${degradationLines.join(`
       return;
     }
     await handleAgentEnd({
+      signal: ctx.signal,
       ctxCwd: ctx.cwd,
       getFlag: (name, filePath) => getLensFlag(name, filePath),
       getFlagSource: (name, filePath) => getLensFlagSource(name, filePath),
@@ -1384,8 +1542,7 @@ ${degradationLines.join(`
     } catch (agentEndErr) {
       if (isStaleExtensionCtxError(agentEndErr))
         throw agentEndErr;
-      dbg(`agent_end crashed: ${agentEndErr}`);
-      dbg(`agent_end crash stack: ${agentEndErr.stack}`);
+      surfaceHandlerCrash("agent_end", agentEndErr, { dbg });
     } finally {
       setAmbientAbortSignal(undefined);
     }
@@ -1472,11 +1629,11 @@ ${degradationLines.join(`
         depChecker,
         testRunnerClient,
         sessionId: getStableSessionId(ctx),
+        signal: ctx.signal,
         onTestRunnerComplete: (delivery) => stageTestRunnerDelivery({
           ...delivery,
           owner: {
             ownerId: testRunnerDeliveryOwnerId,
-            pi,
             cacheManager,
             runtime,
             getCtx: () => ownEventCtx ?? {}
@@ -1498,8 +1655,7 @@ ${degradationLines.join(`
     } catch (turnEndErr) {
       if (isStaleExtensionCtxError(turnEndErr))
         throw turnEndErr;
-      dbg(`turn_end crashed: ${turnEndErr}`);
-      dbg(`turn_end crash stack: ${turnEndErr.stack}`);
+      surfaceHandlerCrash("turn_end", turnEndErr, { dbg });
     } finally {
       setAmbientAbortSignal(undefined);
     }
@@ -1513,10 +1669,11 @@ ${degradationLines.join(`
     });
   }
   registerCascadeTierReconcileTask(() => getLSPService(), {
-    onResolvedFound: ({ filePath, diagnostics }) => {
+    onResolvedFound: ({ filePath, diagnostics, publishedAt }) => {
       const run = buildResolvedFoundCascadeRun(runtime.projectRoot, {
         filePath,
-        diagnostics
+        diagnostics,
+        publishedAt
       });
       if (run)
         runtime.appendCascadeRun(run);
@@ -1563,6 +1720,7 @@ ${degradationLines.join(`
             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)");
@@ -1601,7 +1759,9 @@ ${degradationLines.join(`
       } catch (drainErr) {
         if (isStaleExtensionCtxError(drainErr))
           throw drainErr;
-        dbg(`agent_settled deferred_mutation_drain crashed: ${drainErr}`);
+        surfaceHandlerCrash("agent_settled deferred_mutation_drain", drainErr, {
+          dbg
+        });
       } finally {
         setAmbientAbortSignal(undefined);
       }
@@ -1613,7 +1773,7 @@ ${degradationLines.join(`
         sessionId: getStableSessionId(ctx),
         ownerId: testRunnerDeliveryOwnerId
       }).catch((err) => {
-        dbg(`quiet_window crashed: ${err}`);
+        surfaceHandlerCrash("quiet_window", err, { dbg, rethrow: false });
       });
       dumpActiveHandles("agent_settled");
     } catch (settledErr) {
@@ -1626,7 +1786,7 @@ ${degradationLines.join(`
   } catch (registerErr) {
     dbg(`agent_settled registration failed (older pi host?): ${registerErr}`);
   }
-  pi.on("session_shutdown", (_event, ctx) => {
+  pi.on("session_shutdown", (event, ctx) => {
     const stableSessionId = (() => {
       try {
         return ctx?.sessionManager?.getSessionId?.();
@@ -1656,6 +1816,12 @@ ${degradationLines.join(`
       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();
@@ -1700,7 +1866,7 @@ ${degradationLines.join(`
           incrementDegradationCount(degradation);
         }
       } catch (err) {
-        dbg(`message_end handler error: ${err}`);
+        surfaceHandlerCrash("message_end", err, { dbg });
       }
     });
   } catch (err) {
@@ -1744,6 +1910,13 @@ ${degradationLines.join(`
       }
       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 = [
         {
@@ -1754,6 +1927,10 @@ ${degradationLines.join(`
           source: "turn-findings",
           messages: turnEndFindings?.messages ?? []
         },
+        {
+          source: "test-findings",
+          messages: testFindings?.messages ?? []
+        },
         {
           source: "agent-nudge",
           messages: agentNudge?.messages ?? []