pi-lens 4.4.2 → 4.4.4

package/dist/mcp/server.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  GitleaksClient,
+  classifyAndFilterFindings
+} from "../chunk-24AKHFGP.js";
 import {
   DEAD_CODE_DELTA_MAX_SHOWN,
   deadCodeIssueCount,
@@ -7,35 +11,31 @@ import {
   deadCodeIssues,
   formatDeadCodeDelta,
   stableFindingKey
-} from "../chunk-OG5UUPN7.js";
+} from "../chunk-RKKOYPRA.js";
 import {
   clearFormatterCache
-} from "../chunk-ARJ6PLFH.js";
+} from "../chunk-GSM5UU7A.js";
 import {
   findNearestProjectRoot,
   isStartupScanVerdictFresh,
   resolveStartupScanContext
-} from "../chunk-3VPVG5SU.js";
+} from "../chunk-U44DJXQP.js";
 import {
   loadCallGraph
-} from "../chunk-WOA4LN2R.js";
+} from "../chunk-7D6L4MTX.js";
+import {
+  isHardFailureSummary
+} from "../chunk-7U2IDNXN.js";
 import {
   RUNNERS,
   formatRunDurationMs,
   isExcludedTestTarget,
   isRunnerErrorResult
-} from "../chunk-JWA5I3SR.js";
+} from "../chunk-SD4I7ZO4.js";
 import {
   GovulncheckClient
-} from "../chunk-GZYBXISR.js";
-import {
-  GitleaksClient,
-  classifyAndFilterFindings
-} from "../chunk-VITUCP5A.js";
-import "../chunk-ZGDGW2V3.js";
-import {
-  isHardFailureSummary
-} from "../chunk-7U2IDNXN.js";
+} from "../chunk-IUE7SSKV.js";
+import "../chunk-ZIVJBOO3.js";
 import {
   resetManagedToolRefreshSession
 } from "../chunk-UXVNL3D7.js";
@@ -53,7 +53,7 @@ import {
   peekTurnEndFindings,
   snapshotAdvisoryProvenance,
   validateAdvisoryProvenance
-} from "../chunk-KBG47GHP.js";
+} from "../chunk-WMYE35PX.js";
 import {
   CacheManager,
   DELTA_UNUSED_PROMOTION_NOTE,
@@ -64,21 +64,27 @@ import {
   applyFindingPolicy,
   applyLspFindingPolicy,
   applyPushedFindingPolicy,
+  applyPushedFindingPolicyByFile,
   applyRulePolicy,
   canHandle,
   cascadeCarrySuffix,
   cascadeSettleWaitMs,
+  cascadeStillPresentSince,
+  composeCascadeSection,
   convertLspDiagnostics,
   createDispatchContext,
   createMcpHost,
   demoteInferredProjectDiagnostics,
   demoteInferredProjectSweepResults,
+  dispositionSuppressedLine,
   drainPendingRunnerFindings,
   dropStaleRunnerFindings,
   evaluateAstGrepRules,
   evaluateRules,
   filterFindingsByDisposition,
+  forgetCascadePendingNeighbor,
   formatCacheAgeLabel,
+  formatCascadeNeighborDiagnostics,
   formatDiagnostics,
   getAvailableRunners,
   getDiagnosticTracker,
@@ -86,65 +92,85 @@ import {
   getLatencyReports,
   getToolPlan,
   inlineBlockerIdentities,
+  laneCopyStandsFor,
+  listCascadePendingNeighbors,
   loadProjectRulePolicyMap,
   loadSg,
   logCascade,
+  markCascadeUnansweredPrimariesDelivered,
   markUnreconciledFindings,
   normalizeRuleId,
+  owedByContentOnly,
+  peekOutstandingCascadeTouches,
   pendingRunnerFindingsSize,
+  readFileContent,
+  recordDeliveredCascadeNeighbor,
+  renderCascadeResult,
   requeueRunnerFindings,
   resetCascadeTierSessionState,
   resetDispatchBaselines,
   resetObservedRunnerLatency,
   resetPendingRunnerFindings,
   resetPsScriptAnalyzerAvailability,
-  runProviders
-} from "../chunk-ODBNXWT4.js";
+  runProviders,
+  stampLineHashes
+} from "../chunk-CT4MN5IU.js";
 import {
   resetLazyInstallAttempts
-} from "../chunk-OXXKQCSV.js";
+} from "../chunk-UBOQLVT2.js";
 import {
   isTestRoleCollateral
-} from "../chunk-EJIUXPBX.js";
-import "../chunk-FC4RP4I2.js";
+} from "../chunk-5OFV52AM.js";
+import {
+  findingsResult,
+  hasUsableResult,
+  reachedNoVerdict
+} from "../chunk-RKBXZN3A.js";
+import "../chunk-6HWVI6MI.js";
+import "../chunk-S67KYG37.js";
+import "../chunk-KN35K52N.js";
+import {
+  resetGoAvailability
+} from "../chunk-ROYSX2S5.js";
 import {
   TrivyClient
-} from "../chunk-66SXUJCA.js";
-import "../chunk-VCHXCQFG.js";
-import "../chunk-IXXDFY73.js";
+} from "../chunk-YH5MVY2U.js";
 import {
-  resetRustAvailability
-} from "../chunk-MRXKYPCS.js";
+  scannerReportParentDir
+} from "../chunk-ED36RF6Y.js";
+import "../chunk-BWD5EPKO.js";
+import "../chunk-TIQ2PKDW.js";
 import {
-  findingsResult,
-  hasUsableResult
-} from "../chunk-2CD5RS6M.js";
-import "../chunk-UZ3TUTRV.js";
-import "../chunk-EETY4LF7.js";
+  resetRustAvailability
+} from "../chunk-EBC36LNN.js";
+import "../chunk-HYGZEMX6.js";
+import "../chunk-UZ2XCLYS.js";
 import {
   getSgCommand,
   resetDispatchAvailabilityState,
   resolveManagedToolClient
-} from "../chunk-GOYRYZ2R.js";
-import "../chunk-RPLINGVB.js";
-import "../chunk-XCJN5IJU.js";
-import "../chunk-76MWC2K6.js";
-import "../chunk-GXW6K4YJ.js";
-import "../chunk-2B73ZPOK.js";
+} from "../chunk-ZHH37KZL.js";
+import "../chunk-Y6GZHWSJ.js";
+import "../chunk-IYNJ6YPZ.js";
+import "../chunk-EUXZEFTV.js";
+import "../chunk-T57LYLZT.js";
 import {
-  resetGoAvailability
-} from "../chunk-XMSXXAHW.js";
-import "../chunk-7DYBLXYA.js";
+  SYMBOL_KIND_NAMES,
+  captureReviewGraphStructuralIr,
+  formatReviewGraphRevisionDriftNote,
+  publishReviewGraphFileIr,
+  reviewGraphIrContentHash
+} from "../chunk-XHJBS436.js";
+import {
+  buildSymbolId
+} from "../chunk-3MED75HT.js";
 import {
-  DEPENDENCY_DRIFT_MAX_DELIVERIES,
   MAX_LATE_AUX_REARMS,
   PAST_EOF_STALE_MARKER,
-  RUNTIME_CONFIG,
+  PRIMARY_UNAVAILABLE_CAUSE,
   ReadGuard,
   STALE_LINE_MARKER,
-  SYMBOL_KIND_NAMES,
   Text,
-  TreeSitterSymbolExtractor,
   WriteOrderingGuard,
   anchorsForDiagnostic,
   applyAuxiliarySuppressions,
@@ -155,12 +181,12 @@ import {
   armDeferredLspWork,
   attemptTsserverSyncDiagnostics,
   beginScope,
-  buildScopeKey,
+  buildProbeScopeKey,
   canRearmPendingAuxiliary,
-  canWriteAnalysisRoot,
-  captureReviewGraphStructuralIr,
   classifyDiagnosticTier,
   clearAllSessions,
+  combinePrimaryUnavailableCauses,
+  configDisabledAuxiliaryLspServerIds,
   countRetainedSuppressedRows,
   createFileTime,
   createLazyImport,
@@ -170,20 +196,21 @@ import {
   drainPendingAuxCapEvictedCount,
   drainPendingAuxiliaryCoverage,
   drainRenderedDependencyDriftFilePaths,
-  exceedsLspSyncLimits,
   findAuxiliaryProfileForSource,
-  formatReviewGraphRevisionDriftNote,
   getActiveSessionId,
   getDisposition,
   getFileDiagnosticSummaries,
   getLSPService,
   getLspBudgetIdleTimeoutMs,
   getMutationBridge,
+  getSuppressedDiagnostics,
   getWidgetBlockingFilesForSweep,
+  goPackageFilesToAnnounce,
   groupFilesByPrimaryServer,
   hasAnyDispositionMarks,
   hasStrictDispositionMarks,
   hashDiagnosticContent,
+  importTargetsToAnnounce,
   incrementWidgetDependencyDriftDelivery,
   isAuxBacklogPublished,
   isBlocking,
@@ -195,7 +222,7 @@ import {
   newLspMutationCorrelationId,
   nextOrderTurn,
   pendingAuxiliaryCoverageSize,
-  publishReviewGraphFileIr,
+  primaryUnavailableCause,
   rearmPendingAuxiliaryCoverage,
   reconcileCorrelatedScanDiagnostics,
   reconcileScanDiagnostics,
@@ -212,52 +239,42 @@ import {
   resetOpaqueMutationState,
   resetPendingAuxiliaryCoverage,
   resetWorkspaceDiagnosticsCacheSession,
-  resolveImportToFiles,
   resolveLiveBusEmitter,
   resyncDocumentOnPastEof,
   retagAuxiliaryDiagnostics,
   retireScope,
   retireWidgetDependencyDriftBlockers,
-  reviewGraphIrContentHash,
   runPerServerGroups,
   scopeCell,
   setSessionLanguages,
   shouldShortenLspIdleTimeout,
   summarizeWorkspaceEdit,
-  sweepInlineBlockerFreshness,
-  symbolExtractionGrammar,
   touchCompletedConfirmationPolicy,
   touchCoverageGap,
   tryWarmAttachedDiagnostics,
   widgetDiagnosticUri,
   workspaceEditTextPaths,
   writeOrderToken
-} from "../chunk-PV6LR5P5.js";
-import {
-  buildSymbolId
-} from "../chunk-3MED75HT.js";
-import {
-  emitBounded,
-  resetBoundedTelemetry
-} from "../chunk-CO2G5PHH.js";
+} from "../chunk-RVK72CZX.js";
 import {
+  ANY_POSITION,
+  foldedFindingIdentity,
   hashText,
   normalizeMessage,
   primePersistedMutationAttribution,
   resetMutationAttribution,
+  retainRecordedFindings,
   stableFindingId
-} from "../chunk-IBGIOBEE.js";
-import {
-  resolveGitCheckout,
-  resolveLinkedWorktreeOwner
-} from "../chunk-PNQDPDRC.js";
+} from "../chunk-IWDLU6K3.js";
 import {
   mapWithConcurrency
 } from "../chunk-XIMYZ3JA.js";
 import {
+  canWriteAnalysisRoot,
   classifyCascadeWaitTier,
   customServerSpecsOf,
   describeRootFallback,
+  disabledPrimaries,
   explainServersForFile,
   getAstGrepRuleFingerprint,
   getServersForFileWithConfig,
@@ -272,11 +289,17 @@ import {
   resetLSPCaseSensitivityState,
   resolveLspCwdForFile,
   shouldInitializeSessionRoot
-} from "../chunk-ESBQHFMJ.js";
+} from "../chunk-3DA2JDOL.js";
+import "../chunk-HWCCCQNX.js";
 import {
-  hasAmbientPythonEnvironment
-} from "../chunk-34WSVGEM.js";
-import "../chunk-VWCXW2E7.js";
+  emitBounded,
+  hasAmbientPythonEnvironment,
+  resetBoundedTelemetry
+} from "../chunk-CUHSHSB6.js";
+import {
+  resolveGitCheckout,
+  resolveLinkedWorktreeOwner
+} from "../chunk-UA7ZXYDR.js";
 import {
   PROJECT_SNAPSHOT_VERSION,
   getProjectSnapshotLegacyPath,
@@ -291,8 +314,25 @@ import {
   readJsonCache,
   readProjectSnapshotMeta,
   saveRuntimeProjectSnapshot
-} from "../chunk-ZXYDQ3TZ.js";
+} from "../chunk-T7FEBKXN.js";
+import {
+  SWEEP_IDLE_SAFETY_MARGIN_MS,
+  getFullScanWallClockMs,
+  isWorkspaceSweepActive,
+  runWhenWorkspaceSweepIdle
+} from "../chunk-SRYEJNES.js";
 import "../chunk-5W3R6LFT.js";
+import {
+  DEPENDENCY_DRIFT_MAX_DELIVERIES,
+  RUNTIME_CONFIG,
+  TreeSitterSymbolExtractor,
+  exceedsLspSyncLimits,
+  resolveImportToFiles,
+  sweepInlineBlockerFreshness,
+  symbolExtractionGrammar
+} from "../chunk-V35JG4JB.js";
+import "../chunk-XTBDCR27.js";
+import "../chunk-MPNJLASA.js";
 import {
   EXT_TO_LANG,
   classifyTreeSitterWasmError,
@@ -305,7 +345,7 @@ import {
   queryLoader,
   reportBundledResourceDirHealth,
   resolveTreeSitterLanguage
-} from "../chunk-QHJ6DQ2R.js";
+} from "../chunk-US7ECLD7.js";
 import "../chunk-Z54ZSOBZ.js";
 import {
   SCAN_LANGUAGE_PRIORITY,
@@ -313,35 +353,27 @@ import {
   extensionsForLanguageToken,
   getUserRuleRoot,
   resolveLanguage
-} from "../chunk-724UL2TJ.js";
+} from "../chunk-GXFV6MYU.js";
 import {
   dump,
   resolvePackagePath
-} from "../chunk-QOZXJ4NA.js";
-import "../chunk-GBPP5P7X.js";
-import "../chunk-P7266HLM.js";
-import {
-  SWEEP_IDLE_SAFETY_MARGIN_MS,
-  getFullScanWallClockMs,
-  isWorkspaceSweepActive,
-  runWhenWorkspaceSweepIdle
-} from "../chunk-MQLUAEOC.js";
+} from "../chunk-FM4RDMKT.js";
 import {
   HOOK_WALL_BUDGET_MS,
   bounded,
   combineAbortSignals,
   withDeadline
-} from "../chunk-52FUZI6K.js";
+} from "../chunk-RMLC67LF.js";
 import {
   centralityFromReverseDeps,
   getWordIndexBuildStatus,
   logWordIndex,
   searchWordIndex,
   triggerBackgroundWordIndexBuild
-} from "../chunk-SAEFPSB6.js";
+} from "../chunk-W66O5E25.js";
 import {
   getProjectDiagnosticsScannerMaxFiles
-} from "../chunk-GAEGEPOC.js";
+} from "../chunk-7HXE67BN.js";
 import {
   PathKeyedMap
 } from "../chunk-Z3CCVDUB.js";
@@ -349,32 +381,37 @@ import {
   WARM_TURN_END_SCHEMA_VERSION,
   createWarmIpcLineReader,
   createWarmIpcRequestQueue,
-  freshnessFromMtime,
   ipcPathForCwd,
   readTurnEndStatus,
+  unlinkStaleUnixSocket
+} from "../chunk-KAPJINKN.js";
+import {
+  freshnessFromMtime,
+  hashContentBytes,
   resolveRunnerPath,
   toRunnerDisplayPath
-} from "../chunk-L3BLXZG7.js";
+} from "../chunk-AGSS7277.js";
 import "../chunk-2BEMIWEW.js";
+import "../chunk-IJYGIDF4.js";
 import {
   commitDurableStore,
   resetResolvedPathCache,
   resetZizmorTokenAvailability
-} from "../chunk-66VMUL7Q.js";
+} from "../chunk-GAQ7OQG6.js";
 import {
   resolveToolCwd
-} from "../chunk-Q7DUK4LX.js";
+} from "../chunk-DEL2U6CM.js";
 import {
   _resetPackageManagerCache,
   findGlobalBinary,
   pmBinary,
   resolveNodePackageManager,
   runScriptArgs
-} from "../chunk-AW7R2GWG.js";
+} from "../chunk-5VSF4UUQ.js";
 import {
   getIsolatedNpxSpawnOptions,
   probeToolAsync
-} from "../chunk-RWWYJ623.js";
+} from "../chunk-3KAZU3VR.js";
 import {
   classifyProbeFailure,
   createAvailabilityLatch,
@@ -382,20 +419,20 @@ import {
   logAvailabilityDecision,
   resetInstallRetryLatches,
   startHostStallSampler
-} from "../chunk-VRZP76YM.js";
+} from "../chunk-P63GXC37.js";
 import {
   canRunStartupHeavyScans,
   detectProjectLanguageProfile,
   getDefaultStartupTools
-} from "../chunk-QOBUHWHX.js";
-import "../chunk-QILIYSJF.js";
+} from "../chunk-HRNHZA3N.js";
+import "../chunk-TLX72JTG.js";
 import {
   collectSourceFilesWithBudgetAsync,
   getSlowFsVerdict,
   isSlowFs,
   slowFsDegradationNotice
-} from "../chunk-6C7JWPCP.js";
-import "../chunk-5NGR67U5.js";
+} from "../chunk-DGUKIYSI.js";
+import "../chunk-XBJVAEEO.js";
 import {
   displayProjectDataPath,
   drainProjectDataDirMigrations,
@@ -422,7 +459,7 @@ import {
   sweepDeadEphemeralDataDirs,
   updateHeartbeat,
   withGenerationLockSync
-} from "../chunk-C34ZXZ7O.js";
+} from "../chunk-KUA4OJ5Y.js";
 import {
   createSingleFlight
 } from "../chunk-BW5KFIQC.js";
@@ -432,7 +469,7 @@ import {
 } from "../chunk-QYF5S6P6.js";
 import {
   detectFileKind
-} from "../chunk-PHDMFAKM.js";
+} from "../chunk-DUO2TU77.js";
 import {
   compareKeys,
   detectFileRole,
@@ -442,18 +479,18 @@ import {
   provenanceView,
   resolvePiLensConfig,
   summarizeConfigResolution
-} from "../chunk-2BBLFX75.js";
+} from "../chunk-J6MPGQTS.js";
 import {
   LSP_NAMESPACE_KEY,
   getPiLensGlobalConfigPath,
   resetWorkspaceTopology
-} from "../chunk-XVF2VVXP.js";
+} from "../chunk-5HSRT26B.js";
 import {
   getProjectTrustState,
   isToolInstallAllowedByTrust,
   projectTrustDenialReason,
   setProjectTrustState
-} from "../chunk-ZANLILYD.js";
+} from "../chunk-M2IFVFWU.js";
 import {
   DEFAULT_MAX_OUTPUT_BYTES,
   createBoundedOutputSink,
@@ -474,17 +511,17 @@ import {
   resolveLensToolEnabled,
   resolveLensToolName,
   toolRegistryEntryForMcp
-} from "../chunk-JAU72XNY.js";
+} from "../chunk-J64T55EI.js";
 import {
   createSubsystemLogger,
   flushExtensionLog,
   logExtension
-} from "../chunk-XTMJ7XDT.js";
+} from "../chunk-POMLXPMY.js";
 import "../chunk-JMYYOTQG.js";
 import {
   claimPhaseOncePerSession,
   logLatency
-} from "../chunk-QQNQ7SJW.js";
+} from "../chunk-QBFBRV2B.js";
 import {
   beginTurnContext,
   createNdjsonLogger,
@@ -493,11 +530,11 @@ import {
   isTestMode,
   runLogCleanup,
   setTurnContextSession
-} from "../chunk-AOHZU2BM.js";
+} from "../chunk-YNE3RP52.js";
 import "../chunk-LJDODBBZ.js";
 import {
   FactStore
-} from "../chunk-CHOW74WE.js";
+} from "../chunk-CYRKQRPM.js";
 import {
   BoundedFifoMap,
   BoundedLruCache
@@ -515,13 +552,13 @@ import {
   resolveHostToolPath,
   toProjectRelativePath,
   uriToPath
-} from "../chunk-N2H3ZPZY.js";
+} from "../chunk-3RKP3FMS.js";
 import "../chunk-NXL4FFQQ.js";
 
 // dist/mcp/server.js
 import * as fs25 from "node:fs";
 import * as net from "node:net";
-import * as path39 from "node:path";
+import * as path40 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // dist/tools/render-compact.js
@@ -786,7 +823,7 @@ function compactRenderResult(summarize) {
 
 // dist/clients/ast-grep-client.js
 import * as fs4 from "node:fs";
-import * as os2 from "node:os";
+import * as os from "node:os";
 import * as path4 from "node:path";
 
 // dist/clients/ast-grep-rule-manager.js
@@ -927,7 +964,6 @@ var AstGrepRuleManager = class {
 
 // dist/clients/sg-runner.js
 import * as fs3 from "node:fs";
-import * as os from "node:os";
 import * as path3 from "node:path";
 function buildBashRunArgs(cmd, allArgs) {
   return ["-c", '"$0" "$@"', cmd, ...allArgs];
@@ -1356,6 +1392,7 @@ ${result.stderr}`)) {
       case "cwd-unresolvable":
       case "permission-denied":
       case "spawn-failed":
+      case "trust-refused":
       case void 0:
         return result.error ? "cli-failure" : void 0;
     }
@@ -1473,7 +1510,7 @@ Original error: ${stderr}`;
   }
   // --- Shared helpers for temp-dir rule scans ---
   prepareTempScan(ruleId, ruleYaml) {
-    const sessionDir = fs3.mkdtempSync(path3.join(os.tmpdir(), `pi-lens-temp-${ruleId}-`));
+    const sessionDir = fs3.mkdtempSync(path3.join(scannerReportParentDir(), `pi-lens-temp-${ruleId}-`));
     try {
       const rulesSubdir = path3.join(sessionDir, "rules");
       const configFile = path3.join(sessionDir, ".sgconfig.yml");
@@ -1952,7 +1989,7 @@ var AstGrepClient = class {
    * Dump the parsed tree-sitter AST for a snippet using ast-grep CLI.
    */
   async dumpAst(source, lang, options = {}) {
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "pi-lens-ast-dump-"));
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "pi-lens-ast-dump-"));
     const tmpFile = path4.join(tmpDir, `snippet.${lang.replace(/[^a-z0-9_-]/gi, "") || "txt"}`);
     try {
       fs4.writeFileSync(tmpFile, source, "utf-8");
@@ -1982,7 +2019,7 @@ var AstGrepClient = class {
     if (shapeError)
       return { valid: false, error: shapeError };
     const snippet = validationSnippetFor(lang);
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "pi-lens-sg-validate-"));
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "pi-lens-sg-validate-"));
     const tmpFile = path4.join(tmpDir, `snippet.${snippet.ext}`);
     try {
       fs4.writeFileSync(tmpFile, snippet.source, "utf-8");
@@ -2029,7 +2066,7 @@ var AstGrepClient = class {
       return { valid: false, error: shapeError };
     const language = extractRuleLanguage(ruleYaml) ?? "typescript";
     const snippet = validationSnippetFor(language);
-    const tmpDir = fs4.mkdtempSync(path4.join(os2.tmpdir(), "pi-lens-sg-rule-"));
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "pi-lens-sg-rule-"));
     try {
       fs4.writeFileSync(path4.join(tmpDir, `snippet.${snippet.ext}`), snippet.source, "utf-8");
       const result = await this.tempScanDetailed(tmpDir, ruleYaml, options);
@@ -2606,6 +2643,7 @@ async function scanFileMajorRules(cwd, files, signal) {
       } finally {
         facts.dropFileFacts(filePath);
       }
+      await new Promise((resolve32) => setImmediate(resolve32));
     }
     if (wasmAborted) {
       astGrep.length = 0;
@@ -2937,29 +2975,29 @@ async function buildBootstrapClients() {
     }
   }
   const [ruffClient, biomeClient, knipClient, todoScanner, jscpdClient, depChecker, testRunnerClient, metricsClient, complexityClient, goClient, govulncheckClient, gitleaksClient, trivyClient, opengrepClient, rustClient, agentBehaviorClient2, deadCodeClients] = await Promise.all([
-    load("ruff", async () => new (await import("../chunk-PFNSLWU5.js")).RuffClient()),
-    load("biome", async () => new (await import("../chunk-QZVW3AAK.js")).BiomeClient()),
-    load("knip", async () => new (await import("../chunk-7ULNCDCO.js")).KnipClient()),
-    load("todo", async () => new (await import("../chunk-JSQFTSC6.js")).TodoScanner()),
-    load("jscpd", async () => new (await import("../chunk-3UUPUE3O.js")).JscpdClient()),
-    load("dependency-checker", async () => new (await import("../chunk-3WA4HP4I.js")).DependencyChecker()),
-    load("test-runner", async () => new (await import("../chunk-Q6ZWTCLY.js")).TestRunnerClient()),
-    load("metrics", async () => new (await import("../chunk-N3X6Q4YT.js")).MetricsClient()),
-    load("complexity", async () => new (await import("../chunk-VSSBEUFT.js")).ComplexityClient()),
+    load("ruff", async () => new (await import("../chunk-OHKJ7PQF.js")).RuffClient()),
+    load("biome", async () => new (await import("../chunk-N5FLEO7W.js")).BiomeClient()),
+    load("knip", async () => new (await import("../chunk-6DLWKFEX.js")).KnipClient()),
+    load("todo", async () => new (await import("../chunk-2FN63LPV.js")).TodoScanner()),
+    load("jscpd", async () => new (await import("../chunk-R3T7CLQ2.js")).JscpdClient()),
+    load("dependency-checker", async () => new (await import("../chunk-LZSEQW6A.js")).DependencyChecker()),
+    load("test-runner", async () => new (await import("../chunk-GL5LUMZE.js")).TestRunnerClient()),
+    load("metrics", async () => new (await import("../chunk-VOOAPROD.js")).MetricsClient()),
+    load("complexity", async () => new (await import("../chunk-AWSCPCN2.js")).ComplexityClient()),
     // The process-wide singleton, NOT a fresh instance (#2455 fix round 4,
     // F2). `handleSessionStart` reads this object for its "Active tools"
     // line while `resetGoAvailability` re-arms the singleton's latch; a
     // second instance here meant the reset never reached the surface a
     // user actually sees.
-    load("go", async () => (await import("../chunk-Z527N6YQ.js")).goClient),
-    load("govulncheck", async () => new (await import("../chunk-XPZPXCBV.js")).GovulncheckClient()),
-    load("gitleaks", async () => new (await import("../chunk-WOKKRCJ5.js")).GitleaksClient()),
-    load("trivy", async () => new (await import("../chunk-IBRALRBR.js")).TrivyClient()),
-    load("opengrep", async () => new (await import("../chunk-XKIZ2HNN.js")).OpengrepClient()),
+    load("go", async () => (await import("../chunk-SKAMFC7A.js")).goClient),
+    load("govulncheck", async () => new (await import("../chunk-3PTHXJXR.js")).GovulncheckClient()),
+    load("gitleaks", async () => new (await import("../chunk-MBKQHGA7.js")).GitleaksClient()),
+    load("trivy", async () => new (await import("../chunk-JW3YWBVB.js")).TrivyClient()),
+    load("opengrep", async () => new (await import("../chunk-5IUSNGOC.js")).OpengrepClient()),
     // The process-wide singleton, for the same reason as "go" above.
-    load("rust", async () => (await import("../chunk-BRGDSBJE.js")).rustClient),
-    load("agent-behavior", async () => (await import("../chunk-23WOO7TX.js")).agentBehaviorClient),
-    loadList("dead-code", async () => (await import("../chunk-NW7BOILN.js")).getDeadCodeClients())
+    load("rust", async () => (await import("../chunk-SYE6T2EB.js")).rustClient),
+    load("agent-behavior", async () => (await import("../chunk-R7YOCSNV.js")).agentBehaviorClient),
+    loadList("dead-code", async () => (await import("../chunk-5WRPDP2A.js")).getDeadCodeClients())
   ]);
   if (failures.length > 0)
     await logBootstrapFailures(failures);
@@ -3046,7 +3084,7 @@ function resetAnalyzerBootstrapSessionState() {
 }
 
 // dist/clients/formatters-lazy.js
-var lazyFormatters = createLazyImport(() => import("../chunk-GHB6AYCP.js"));
+var lazyFormatters = createLazyImport(() => import("../chunk-ZVUL7QYY.js"));
 function warmFormatters() {
   return lazyFormatters.get();
 }
@@ -3200,13 +3238,18 @@ function readChangeLogMaxSeq(logPath) {
 }
 var CHANGE_LOG_LOCK = { staleMs: 5e3, waitMs: 500 };
 function appendProjectChangeAllocated(cwd, build) {
+  appendProjectChangesAllocated(cwd, (logMaxSeq) => [build(logMaxSeq)]);
+}
+function appendProjectChangesAllocated(cwd, buildAll) {
   const logPath = getProjectChangeLogPath(cwd);
   fs7.mkdirSync(path7.dirname(logPath), { recursive: true });
   readChangeLogMaxSeq(logPath);
   const append = (locked) => {
-    const entry = build(readChangeLogMaxSeq(logPath));
-    const line = locked ? entry : { ...entry, unlocked: true };
-    fs7.appendFileSync(logPath, `${JSON.stringify(line)}
+    const entries = buildAll(readChangeLogMaxSeq(logPath));
+    if (entries.length === 0)
+      return;
+    const payload = entries.map((entry) => JSON.stringify(locked ? entry : { ...entry, unlocked: true })).join("\n");
+    fs7.appendFileSync(logPath, `${payload}
 `, "utf-8");
   };
   const result = withGenerationLockSync(`${logPath}.locks`, CHANGE_LOG_LOCK, () => append(true));
@@ -3227,7 +3270,11 @@ function inlineBlockerSources(blockers) {
 }
 function inlineBlockerLines(blockers, filePath) {
   const own = normalizeEphemeralMapKey(filePath);
-  return blockers.filter((d) => normalizeEphemeralMapKey(d.filePath) === own).map((d) => d.line).filter((line) => typeof line === "number");
+  return blockers.filter(
+    // #4509 (N3): a stale entry's line is from older bytes, so it cites
+    // none: the past-EOF sweep would retire the whole record on it.
+    (d) => !d.positionStale && normalizeEphemeralMapKey(d.filePath) === own
+  ).map((d) => d.line).filter((line) => typeof line === "number");
 }
 
 // dist/clients/partial-edit-apply.js
@@ -3413,6 +3460,7 @@ function recordViewIncomplete(cwd, cause) {
   });
 }
 var MAX_RESOLVED_BLOCKER_FILES = 10;
+var MAX_OWED_ANCHORS = 16;
 var TOOL_CALL_ATTRIBUTION_CAPACITY = 256;
 var TOOL_CALL_ATTRIBUTION_TTL_MS = 5 * 6e4;
 var TurnWarningsBySession = class {
@@ -3462,7 +3510,7 @@ var RuntimeCoordinator = class {
     diagnosticsSurfaced: 0,
     coldSnapshotTouches: 0
   };
-  _complexityBaselines = /* @__PURE__ */ new Map();
+  _complexityBaselines = /* @__PURE__ */ new Set();
   _fixedThisTurn = new PathKeyedMap(normalizeMapKey);
   _writtenThisTurn = new PathKeyedMap(normalizeMapKey);
   _autofixDemotedThisTurn = new PathKeyedMap(normalizeMapKey);
@@ -3551,6 +3599,26 @@ var RuntimeCoordinator = class {
   _readWidenings = new BoundedLruCache(TOOL_CALL_ATTRIBUTION_CAPACITY);
   _lspReadWarmState = /* @__PURE__ */ new Map();
   _pendingInlineBlockers = new PathKeyedMap(normalizeMapKey);
+  /**
+   * #4484 round 4: per file, what its last applied inline verdict left owed
+   * (`setAnalysisAnchor`), for a file whose record is gone or has no anchor.
+   * The positions live on the blocker record
+   * (`InlineBlockerRecord.analysisAnchor`). Round 5: this keeps each owing
+   * runner's owed line texts (`owedByContentOnly`, at most
+   * `MAX_OWED_LINE_TEXTS` hashes per runner, 16 KB), not only its id, so
+   * the next write owes it only the lines with those texts, never the whole
+   * file for a skip. Replaced by every applied verdict of the file and
+   * cleared per session.
+   */
+  _owedRunners = new PathKeyedMap(normalizeMapKey);
+  /**
+   * #4484 round 5: for a file with no blocker record, its last verdict's
+   * whole anchor (line hashes too), so the next write still remaps owed
+   * positions exactly (verify probe P23). At most `MAX_OWED_ANCHORS` files,
+   * 400 KB each; an evicted file falls back to `_owedRunners`' owed line
+   * texts, a superset. Cleared per session.
+   */
+  _owedAnchors = new PathKeyedMap(normalizeMapKey, MAX_OWED_ANCHORS);
   /**
    * #3507: one per-path order for BOTH verbs on `_pendingInlineBlockers`,
    * the widget store's guard shape (`widget-state.ts` diagnosticsWriteGuard).
@@ -3639,6 +3707,8 @@ var RuntimeCoordinator = class {
     this._readWidenings.clear();
     this._lspReadWarmState.clear();
     this._pendingInlineBlockers.clear();
+    this._owedRunners.clear();
+    this._owedAnchors.clear();
     this._inlineBlockerWriteOrder.clear();
     this._resolvedBlockerFilesThisTurn.clear();
     this._resolvedBlockerFilesDropped = 0;
@@ -3792,20 +3862,79 @@ var RuntimeCoordinator = class {
       }
     }
     const { projectSeq, fileSeq, key } = logged ?? this.bumpFileSeq(args.filePath);
+    this.recordMutationReceipt({ projectSeq, fileSeq, key }, args.source);
+    return { projectSeq, fileSeq };
+  }
+  /**
+   * #4535: the bulk form of {@link recordProjectMutation}, for a disk change
+   * pi-lens did not author that spans many paths (a publisher's recorded
+   * population). It allocates from the SAME sequence, in ONE locked append:
+   * `appendProjectChangesAllocated` takes the change-log lock once and writes
+   * every line under it, so a 400-path HEAD move costs one lock round-trip
+   * inside a hook budget instead of 400. The lock-failure semantics are the
+   * single writer's: when the lock is unavailable every appended line is
+   * tagged `unlocked` and one `change-log-lock-unavailable` degradation is
+   * recorded for the batch. Receipts are appended per path with the same ring
+   * cap and drop counter as a single mutation.
+   *
+   * Returns the batch's last allocated `projectSeq` (the record's seq after
+   * the batch) and each path's `fileSeq` keyed by the bump's normalized key.
+   * Duplicate paths are the caller's to collapse: each entry bumps.
+   */
+  recordProjectMutations(args) {
+    let logged;
+    if (args.cwd !== void 0 && args.paths.length > 0) {
+      try {
+        const cwd = args.cwd;
+        const paths = args.paths;
+        appendProjectChangesAllocated(cwd, (logMaxSeq) => {
+          const ownSeq = this._projectSeq;
+          const bumps2 = paths.map((filePath) => this.bumpFileSeq(filePath, logMaxSeq));
+          logged = bumps2;
+          if (this._viewMissingThrough > 0) {
+            recordViewIncomplete(cwd, { ownSeq, logMaxSeq });
+          }
+          return bumps2.map((bump, index) => ({
+            seq: bump.projectSeq,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            sessionId: this.telemetrySessionId,
+            turnIndex: this.turnIndex,
+            source: args.source,
+            filePath: path8.resolve(paths[index]),
+            fileSeq: bump.fileSeq
+          }));
+        });
+      } catch (err) {
+        args.onAppendError?.(err);
+      }
+    }
+    const bumps = logged ?? args.paths.map((filePath) => this.bumpFileSeq(filePath));
+    const fileSeqs = /* @__PURE__ */ new Map();
+    for (const bump of bumps) {
+      this.recordMutationReceipt({ projectSeq: bump.projectSeq, fileSeq: bump.fileSeq, key: bump.key }, args.source);
+      fileSeqs.set(bump.key, bump.fileSeq);
+    }
+    return { projectSeq: this._projectSeq, fileSeqs };
+  }
+  /**
+   * The receipt ring (§ {@link MutationReceipt}): one entry per bump, oldest
+   * evicted at the cap and counted, never silently incomplete. One writer, so
+   * the single and bulk mutation paths cannot drift apart on attribution.
+   */
+  recordMutationReceipt(bump, source) {
     if (this._mutationReceipts.length >= MAX_MUTATION_RECEIPTS) {
       this._mutationReceipts.shift();
       this._droppedMutationReceipts += 1;
     }
     this._mutationReceipts.push({
-      seq: projectSeq,
+      seq: bump.projectSeq,
       // Reuse the bump's normalized key (a realpath syscall: ~200us on
       // Windows, ~1.8us on POSIX since #3098) — never re-derive it here.
-      filePath: key,
-      source: args.source,
+      filePath: bump.key,
+      source,
       turnIndex: this._turnIndex,
       ts: Date.now()
     });
-    return { projectSeq, fileSeq };
   }
   /**
    * Attributed mutations whose seq is strictly after `seq` — the receipt-level
@@ -4274,7 +4403,7 @@ var RuntimeCoordinator = class {
     const existing = this._pendingInlineBlockers.get(key);
     if (existing && !existing.diagnostics)
       return 0;
-    const identity = (d) => JSON.stringify([d.tool, d.id, d.line, d.message]);
+    const identity = (d) => JSON.stringify([foldedFindingIdentity(d), d.line, d.column]);
     const known = new Set((existing?.diagnostics ?? []).map(identity));
     const added = blocking.flatMap((d) => known.has(identity(d)) ? [] : [d]);
     if (added.length === 0)
@@ -4310,6 +4439,91 @@ var RuntimeCoordinator = class {
     });
     return added.length;
   }
+  /**
+   * #4484 round 2: the file's recorded blocking diagnostics, which the next
+   * write's pipeline carries forward unless a conclusive observation from
+   * their own source shows them gone. Undefined when nothing is recorded or
+   * the record holds text only.
+   */
+  getInlineBlockerDiagnostics(filePath) {
+    return this._pendingInlineBlockers.get(path8.resolve(filePath))?.diagnostics;
+  }
+  /**
+   * #4484 round 3: the anchor the next write's pipeline aligns to: the line
+   * hashes of the bytes the file's blocker record is about, and the lines
+   * still owed. Round 4: it is the record's own anchor. A file without one
+   * (no record, or a record a collect-later settle started) gets no hashes,
+   * so the pipeline cannot align. Round 5: it gets the owed line texts.
+   */
+  getAnalysisAnchor(filePath) {
+    return this._pendingInlineBlockers.get(filePath)?.analysisAnchor ?? this._owedAnchors.get(filePath) ?? this._owedRunners.get(filePath);
+  }
+  /**
+   * #4484 round 3: store the anchor of an inline verdict that just applied
+   * (`recordInlineBlockers` or `clearInlineBlockers` returned applied), so it
+   * always describes the bytes the record is about. Round 4: it goes on the
+   * record, and lives as long as the record; what is owed goes apart
+   * (`_owedRunners`, by content since round 5), so it outlives a record that
+   * a later retire drops. Round 5: a file with no record keeps its whole
+   * anchor too (`_owedAnchors`, bounded).
+   */
+  setAnalysisAnchor(filePath, anchor) {
+    const existing = this._pendingInlineBlockers.get(filePath);
+    if (existing) {
+      const key = path8.resolve(filePath);
+      const { analysisAnchor: _dropped, ...rest } = existing;
+      this._pendingInlineBlockers.set(key, anchor ? { ...rest, analysisAnchor: anchor } : rest);
+    }
+    const owed = owedByContentOnly(anchor);
+    if (owed)
+      this._owedRunners.set(filePath, owed);
+    else
+      this._owedRunners.delete(filePath);
+    if (owed && anchor?.lineHashes && !existing)
+      this._owedAnchors.set(filePath, anchor);
+    else
+      this._owedAnchors.delete(filePath);
+  }
+  /**
+   * #4484 round 2: a settled collect-later run is the observation that can
+   * retire the blockers its runner left pending while it was in flight. Its
+   * runner's recorded blockers that the run no longer observes leave the
+   * record; blockers from other runners, and from a server the run left
+   * unconfirmed, stay. A blocker is still observed only at its own line, in
+   * range or withheld by the run's edit-range gate (#4484 round 3). The run
+   * must be about the recorded bytes: marked after
+   * they were read (`recordedAtMs`), with the file still holding them
+   * (`recordedHash`). An emptied record is deleted and its file is noted
+   * Resolved for turn end, as a clean write's clear does.
+   *
+   * @returns how many recorded blockers the run retired.
+   */
+  retireUnobservedRunnerBlockers(filePath, run) {
+    const key = path8.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing?.diagnostics || run.sha256 === void 0 || existing.recordedHash !== run.sha256 || existing.recordedAtMs === void 0 || run.markedAtMs < existing.recordedAtMs)
+      return 0;
+    const unconfirmed = new Set(run.unconfirmedServerIds);
+    const { kept, retired } = retainRecordedFindings(existing.diagnostics, run.observed, {
+      positionOf: (d) => d.positionStale ? ANY_POSITION : d.line,
+      keepUnobserved: (d) => d.runnerId !== run.runnerId || d.serverId !== void 0 && unconfirmed.has(d.serverId)
+    });
+    if (retired.length === 0)
+      return 0;
+    if (kept.length === 0) {
+      this.noteResolvedBlockerFile(existing, void 0, false);
+      this._pendingInlineBlockers.delete(key);
+      return retired.length;
+    }
+    this._pendingInlineBlockers.set(key, {
+      ...existing,
+      summary: formatDiagnostics(kept, "blocking").trim(),
+      diagnostics: kept,
+      sources: inlineBlockerSources(kept),
+      lines: inlineBlockerLines(kept, existing.filePath)
+    });
+    return retired.length;
+  }
   /**
    * #3218 criterion 2: remember one file whose blocker a clean verdict just
    * retired, for the turn-end "Resolved" line. Called from the two retire
@@ -4347,9 +4561,22 @@ var RuntimeCoordinator = class {
    * counted as `blocker-clear-refused` per file key. A record with no
    * `recordedHash` (#2982: the file was unreadable or over the baseline cap at
    * record time) cannot be matched and is cleared as before.
+   *
+   * #4484: a blocker is pending until a fresh observation no longer holds it,
+   * so a run whose own observation still holds `analysis.blocking` blockers
+   * never clears the record, whatever its authorship or its delta said; it
+   * is refused and counted the same way.
    */
   clearInlineBlockers(filePath, writeIndex, orderTurn = this._writeOrderTurn, analysis) {
     const existing = this._pendingInlineBlockers.get(path8.resolve(filePath));
+    if (existing && (analysis?.blocking ?? 0) > 0) {
+      incrementDegradationCount({
+        kind: "blocker-clear-refused",
+        subject: normalizeMapKey(filePath),
+        reason: "the clearing run still observed a blocker on the file; the record stays until an observation holds none (#4484)"
+      });
+      return false;
+    }
     if (existing && analysis && !analysis.authored && analysis.sha256 !== void 0 && existing.recordedHash === analysis.sha256) {
       incrementDegradationCount({
         kind: "blocker-clear-refused",
@@ -5344,7 +5571,8 @@ function boundDeferredTargets(entries, max, isOwn) {
 }
 
 // dist/clients/test-runner-delivery.js
-var pending = /* @__PURE__ */ new Map();
+var MAX_PENDING_DELIVERIES = 32;
+var pending = new BoundedFifoMap(MAX_PENDING_DELIVERIES);
 function resetTestRunnerDelivery() {
   pending.clear();
 }
@@ -5603,8 +5831,8 @@ async function igniteDominantLanguageWarm(cwd, runtime, sessionGeneration, dbg)
     if (!runtime.isCurrentSession(sessionGeneration))
       return;
     const lspService = (await loadLspService()).getLSPService();
-    const { collectSourceFilesAsync } = await import("../chunk-4W4VLAPJ.js");
-    const { CODE_KINDS, detectFileKind: detectFileKind2 } = await import("../chunk-FLKWCIZH.js");
+    const { collectSourceFilesAsync } = await import("../chunk-IQWN5JCP.js");
+    const { CODE_KINDS, detectFileKind: detectFileKind2 } = await import("../chunk-S2HEXIWI.js");
     const files = await collectSourceFilesAsync(cwd, {
       inspectGeneratedHeaders: false
     });
@@ -5670,7 +5898,7 @@ function scheduleManagedToolRefresh(dbg) {
   const timer = setTimeout(() => {
     void (async () => {
       try {
-        const refresh = await import("../chunk-CF24OIYI.js");
+        const refresh = await import("../chunk-2KXTHF3M.js");
         const outcome = await refresh.runManagedToolRefresh();
         if (outcome.skipped) {
           dbg(`session_start tool-refresh: skipped (${outcome.skipped})`);
@@ -5717,7 +5945,7 @@ function scanOneTodoFile(scanner, filePath, items) {
 async function collectTodoBaselineItems(scanner, analysisRoot, stillCurrent) {
   const items = [];
   try {
-    const { getSourceFilesAsync } = await import("../chunk-IZSHAIJ7.js");
+    const { getSourceFilesAsync } = await import("../chunk-TRETHTQO.js");
     const files = await getSourceFilesAsync(analysisRoot, true);
     if (!stillCurrent())
       return items;
@@ -5746,7 +5974,7 @@ async function buildOrRefreshWordIndex(args) {
   const snapshot = loadProjectSnapshot(snapshotRoot);
   const snapshotLoadMs = Date.now() - snapshotLoadStartMs;
   if (snapshot?.wordIndex) {
-    const { deserializeWordIndex, refreshWordIndexIncrementally, countWordIndexPostingEntries: countWordIndexPostingEntries2, estimateWordIndexResidentBytes: estimateWordIndexResidentBytes2 } = await import("../chunk-WU567RSC.js");
+    const { deserializeWordIndex, refreshWordIndexIncrementally, countWordIndexPostingEntries: countWordIndexPostingEntries2, estimateWordIndexResidentBytes: estimateWordIndexResidentBytes2, notifyWordIndexPublished: notifyWordIndexPublished2 } = await import("../chunk-ATKJFDQN.js");
     const deserializeStartMs = Date.now();
     const index = deserializeWordIndex(snapshot.wordIndex);
     const deserializeMs = Date.now() - deserializeStartMs;
@@ -5771,6 +5999,7 @@ async function buildOrRefreshWordIndex(args) {
           });
         } else {
           runtime.wordIndex = index;
+          notifyWordIndexPublished2(snapshotRoot, index, "session_start");
           let snapshotSaveSyncMs = 0;
           if (!isProjectSnapshotFresh(snapshot, effectiveSeq, latestSeq.unlockedThrough) || result.refreshed > 0 || result.dropped > 0 || snapshot.wordIndex.truncated !== index.truncated) {
             const serializeSaveEnqueueStartMs = Date.now();
@@ -5818,7 +6047,7 @@ async function buildOrRefreshWordIndex(args) {
       }
     }
   }
-  const { buildWordIndexAsync, collectWordIndexDocs, countWordIndexPostingEntries, estimateWordIndexResidentBytes } = await import("../chunk-WU567RSC.js");
+  const { buildWordIndexAsync, collectWordIndexDocs, countWordIndexPostingEntries, estimateWordIndexResidentBytes, notifyWordIndexPublished } = await import("../chunk-ATKJFDQN.js");
   const docs = await collectWordIndexDocs(analysisRoot, () => runtime.isCurrentSession(sessionGeneration), rebuildPreflightFiles);
   if (!runtime.isCurrentSession(sessionGeneration))
     return;
@@ -5835,6 +6064,7 @@ async function buildOrRefreshWordIndex(args) {
   if (!runtime.isCurrentSession(sessionGeneration))
     return;
   runtime.wordIndex = rebuiltIndex;
+  notifyWordIndexPublished(snapshotRoot, rebuiltIndex, "session_start");
   saveRuntimeProjectSnapshot({ cwd: snapshotRoot, runtime, dbg });
   dbg(`session_start word-index: rebuilt (absent/stale, seq=${effectiveSeq}) ${runtime.wordIndex.docCount} files, ${runtime.wordIndex.postings.size} tokens (${Date.now() - startMs}ms)`);
   logWordIndex({
@@ -5857,6 +6087,11 @@ async function buildOrRefreshWordIndex(args) {
     reused: 0
   };
 }
+var STARTUP_TASK_DEFER_MS = {
+  "call-graph": 5e3,
+  "codebase-model": 5200,
+  "ast-grep-exports": 5400
+};
 function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
   void (async () => {
     const resolved = await demandBootstrapDeps(deps, "session-start-scans");
@@ -5878,15 +6113,10 @@ function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analy
       reason: "skipped (disabled by config)"
     });
   }
-  const taskDeferMsByName = {
-    "call-graph": 5e3,
-    "codebase-model": 5200,
-    "ast-grep exports": 5400,
-    "project index": 5400
-  };
   const runTask = (name, task) => {
     const queuedAt = Date.now();
-    dbg(`session_start task ${name}: scheduled`);
+    const delay = STARTUP_TASK_DEFER_MS[name] ?? 0;
+    dbg(`session_start task ${name}: scheduled deferMs=${delay}`);
     runtime.markStartupScanInFlight(name, sessionGeneration);
     const completion = new Promise((resolve32) => {
       const fire = () => {
@@ -5903,7 +6133,6 @@ function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analy
           resolve32();
         });
       };
-      const delay = taskDeferMsByName[name] ?? 0;
       if (delay > 0) {
         setTimeout(fire, delay).unref?.();
       } else {
@@ -5915,7 +6144,7 @@ function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analy
   const canRunJsTsHeavyScans = canRunStartupHeavyScans(languageProfile, "jsts");
   const scanNames = ["todo", "dead-code"];
   if (canRunJsTsHeavyScans) {
-    scanNames.push("knip", "jscpd", "ast-grep exports", "project index");
+    scanNames.push("knip", "jscpd", "ast-grep-exports");
   }
   dbg(`session_start: launching background scans (${scanNames.join(", ")})`);
   void runTask("todo", async () => {
@@ -6183,9 +6412,9 @@ function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analy
   });
   let callGraphIdentity;
   const callGraphTask = runTask("call-graph", async () => {
-    const { FactStore: FactStore2 } = await import("../chunk-QGQ5CCCG.js");
-    const { buildOrUpdateGraph, extractSymbolsAndRefsFromGraph, getReviewGraphCacheIdentity } = await import("../chunk-2ZGIZPDG.js");
-    const { buildCallGraph, saveCallGraph, loadCallGraph: loadCallGraph2 } = await import("../chunk-BKE7E7TC.js");
+    const { FactStore: FactStore2 } = await import("../chunk-UMS2MFPZ.js");
+    const { buildOrUpdateGraph, extractSymbolsAndRefsFromGraph, getReviewGraphCacheIdentity } = await import("../chunk-YCWYO6TQ.js");
+    const { buildCallGraph, saveCallGraph, loadCallGraph: loadCallGraph2 } = await import("../chunk-GMX5OS7B.js");
     if (!runtime.isCurrentSession(sessionGeneration))
       return;
     const startMs = Date.now();
@@ -6226,7 +6455,7 @@ function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analy
       return;
     if (!runtime.callGraph)
       return;
-    const { buildCodebaseModel, saveCodebaseModel, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET } = await import("../chunk-TYM6OUIT.js");
+    const { buildCodebaseModel, saveCodebaseModel, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET } = await import("../chunk-TOY6QKOH.js");
     if (!callGraphIdentity)
       return;
     const model = buildCodebaseModel(runtime.callGraph, analysisRoot, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, callGraphIdentity);
@@ -6258,18 +6487,18 @@ function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analy
     });
   });
 }
-function scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
+function scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, dbg) {
   void (async () => {
     const resolved = await demandBootstrapDeps(deps, "session-start-tool-probes");
     if (!resolved) {
       dbg("session_start tools: analyzer bootstrap unavailable \u2014 no probes");
       return;
     }
-    scheduleDeferredToolProbesWithClients(resolved, languageProfile, startupDefaults, startupScansWillRun, dbg);
+    scheduleDeferredToolProbesWithClients(resolved, languageProfile, startupDefaults, dbg);
   })();
 }
-function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
-  const { biomeClient, ruffClient, depChecker } = deps;
+function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDefaults, dbg) {
+  const { biomeClient, ruffClient } = deps;
   const defaultTools = new Set(startupDefaults);
   const probes = [];
   if (languageProfile.present.jsts && !defaultTools.has("biome")) {
@@ -6278,9 +6507,6 @@ function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDef
   if (languageProfile.present.python && !defaultTools.has("ruff")) {
     probes.push(["ruff", () => ruffClient.ensureAvailable()]);
   }
-  if (startupScansWillRun) {
-    probes.push(["madge", () => depChecker.ensureAvailable()]);
-  }
   if (probes.length === 0) {
     dbg("session_start tools: no deferred availability probes needed");
     return;
@@ -6299,6 +6525,34 @@ function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDef
     dbg(`session_start tools (deferred probes complete, ${Date.now() - warmStart}ms): ${summary}`);
   })();
 }
+function resetSessionScopedState(cwd, sessionStartMs = Date.now()) {
+  resetWorkspaceTopology();
+  resetOpaqueMutationState();
+  resetObservedMutationNet();
+  resetMutationAttribution();
+  primePersistedMutationAttribution(cwd);
+  resetPendingAuxiliaryCoverage();
+  resetSafeSpawnWindowsCommandCache();
+  resetDispatchAvailabilityState();
+  resetObservedRunnerLatency();
+  resetPendingRunnerFindings();
+  resetSpawnTimeoutCooldowns();
+  clearFormatterCache();
+  resetZizmorTokenAvailability();
+  resetGoAvailability();
+  resetRustAvailability();
+  resetPsScriptAnalyzerAvailability();
+  resetInstallRetryLatches();
+  resetLazyInstallAttempts();
+  resetDirectLspCommandAvailability();
+  resetLSPCaseSensitivityState();
+  resetResolvedPathCache();
+  _resetPackageManagerCache();
+  resetManagedToolRefreshSession();
+  resetSmellsSessionState();
+  resetSituationalToolTelemetry();
+  resetWorkspaceDiagnosticsCacheSession(sessionStartMs);
+}
 function readSubstituteGuidance(isEnabled) {
   const units = [];
   if (isEnabled("symbol_search")) {
@@ -6410,8 +6664,8 @@ async function handleSessionStart(deps) {
         try {
           warmupDbg("warmup: starting background warmup");
           const scanContextStartedAt = Date.now();
-          const startupScanModule = await import("../chunk-ZHFZWTZV.js");
-          const languageProfileModule = await import("../chunk-R3PCY3YS.js");
+          const startupScanModule = await import("../chunk-GSLNCYGG.js");
+          const languageProfileModule = await import("../chunk-AMERCH6V.js");
           const warmupSnapshotRoot = resolveSnapshotRoot(warmupCwd);
           const cachedSnapshot = loadProjectSnapshot(warmupSnapshotRoot);
           warmupOwnSnapshotRead = cachedSnapshot ? {
@@ -6545,32 +6799,7 @@ async function handleSessionStart(deps) {
   clearAllSessions();
   runtime.complexityBaselines.clear();
   resetDispatchBaselines2(ctxCwd);
-  resetWorkspaceTopology();
-  resetOpaqueMutationState();
-  resetObservedMutationNet();
-  resetMutationAttribution();
-  primePersistedMutationAttribution(ctxCwd);
-  resetPendingAuxiliaryCoverage();
-  resetSafeSpawnWindowsCommandCache();
-  resetDispatchAvailabilityState();
-  resetObservedRunnerLatency();
-  resetPendingRunnerFindings();
-  resetSpawnTimeoutCooldowns();
-  clearFormatterCache();
-  resetZizmorTokenAvailability();
-  resetGoAvailability();
-  resetRustAvailability();
-  resetPsScriptAnalyzerAvailability();
-  resetInstallRetryLatches();
-  resetLazyInstallAttempts();
-  resetDirectLspCommandAvailability();
-  resetLSPCaseSensitivityState();
-  resetResolvedPathCache();
-  _resetPackageManagerCache();
-  resetManagedToolRefreshSession();
-  resetSmellsSessionState();
-  resetSituationalToolTelemetry();
-  resetWorkspaceDiagnosticsCacheSession(sessionStartMs);
+  resetSessionScopedState(ctxCwd, sessionStartMs);
   deps.bootstrap.peek()?.knipClient.resetSessionState?.();
   resetCascadeTierSessionState();
   runtime.resetForSession(sessionStartMs);
@@ -6957,10 +7186,8 @@ async function handleSessionStart(deps) {
     dbg("session_start: no language defaults selected for pre-install");
   }
   const startupScansEnabled = deps.projectConfig?.startup?.scans?.enabled ?? deps.globalConfig?.startup?.scans?.enabled ?? true;
-  const startupScansWillRun = allowBootstrapTasks && startupScan.canWarmCaches && startupScansEnabled;
-  const jstsHeavyScansWillRun = startupScansWillRun && canRunStartupHeavyScans(languageProfile, "jsts");
   if (allowBootstrapTasks) {
-    scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, jstsHeavyScansWillRun, dbg);
+    scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, dbg);
     scheduleManagedToolRefresh(dbg);
   }
   if (allowBootstrapTasks) {
@@ -7331,6 +7558,7 @@ async function buildActionableWarningsReport(args) {
   const cwd = path15.resolve(args.cwd);
   const records = [...args.dispatchWarnings];
   const lspService = getLSPService();
+  const excludeServerIds = args.getFlag ? configDisabledAuxiliaryLspServerIds(args.getFlag) : void 0;
   const observedAtByPath = /* @__PURE__ */ new Map();
   const buildStartedAt = (/* @__PURE__ */ new Date()).toISOString();
   logActionableWarningsEvent({
@@ -7400,6 +7628,7 @@ async function buildActionableWarningsReport(args) {
     const pullTimeoutMs = boundedNumber(args.lspPullTimeoutMs, ACTIONABLE_WARNINGS_LSP_PULL_TIMEOUT_MS);
     const inBandDeps = {
       lspService,
+      excludeServerIds,
       pullTimeoutMs,
       // #2504 review round 4 (F2). This is the AWAITED hook: the batch
       // budget has to bound what happens INSIDE a file, not only how many
@@ -7447,6 +7676,7 @@ async function buildActionableWarningsReport(args) {
         const loopSignal = combineAbortSignals(args.signal, deferredSignal) ?? deferredSignal;
         const deferredDeps = {
           lspService,
+          excludeServerIds,
           pullTimeoutMs,
           signal: loopSignal,
           // OFF the hook by construction: this loop is the answer to
@@ -7561,7 +7791,7 @@ async function enrichFileFromLsp(cwd, args, target, deps) {
           return out;
         }
       }
-      const pulled = await boundedLspCall(() => lspService.getDiagnostics(filePath), deps);
+      const pulled = await boundedLspCall(() => lspService.getDiagnostics(filePath, "full", deps.excludeServerIds), deps);
       if (pulled === void 0) {
         logActionableWarningsEvent({
           event: "lsp_file_skipped",
@@ -8118,8 +8348,8 @@ var MAX_FAILURE_TRACKER_SIZE = 200;
 var recentOldTextFailures = new BoundedFifoMap(MAX_FAILURE_TRACKER_SIZE);
 
 // dist/clients/deferred-runner-blockers.js
-import { createHash as createHash3 } from "node:crypto";
 import * as fs14 from "node:fs";
+import { resolve as resolve9 } from "node:path";
 function judgeDeferredRunnerFindings(pending2, cwd, options = {}) {
   const findings = pending2.result?.diagnostics ?? [];
   if (findings.length === 0) {
@@ -8160,7 +8390,7 @@ function judgeDeferredRunnerFindings(pending2, cwd, options = {}) {
   };
 }
 function recordDeferredRunnerBlockers(runtime, pending2, survivors, bytes) {
-  const blocking = survivors.flatMap((d) => d.semantic === "blocking" ? [d] : []);
+  const blocking = stampLineHashes(withoutLaneCopies(runtime, pending2, survivors).flatMap((d) => d.semantic === "blocking" ? [{ ...d, runnerId: d.runnerId ?? pending2.runnerId }] : []), bytes?.toString("utf-8"), (d) => !d.filePath || resolve9(d.filePath) === resolve9(pending2.filePath));
   if (blocking.length === 0)
     return 0;
   const recorded = runtime.recordDeferredInlineBlockers(pending2.filePath, blocking, {
@@ -8168,7 +8398,7 @@ function recordDeferredRunnerBlockers(runtime, pending2, survivors, bytes) {
     ...bytes ? {
       contentBaseline: {
         size: bytes.byteLength,
-        sha256: createHash3("sha256").update(bytes).digest("hex")
+        sha256: hashContentBytes(bytes)
       }
     } : {}
   });
@@ -8176,6 +8406,36 @@ function recordDeferredRunnerBlockers(runtime, pending2, survivors, bytes) {
     runtime.updateGitGuardStatus(false, "");
   return recorded;
 }
+function retireSettledRunnerBlockers(runtime, pending2, verdict) {
+  const result = pending2.result;
+  if (!result || reachedNoVerdict(result) || result.coveredBy !== void 0 && result.skipReason === "covered-by-primary")
+    return 0;
+  const bytes = readBytes(pending2.filePath);
+  const retired = runtime.retireUnobservedRunnerBlockers(pending2.filePath, {
+    runnerId: pending2.runnerId,
+    // #4484 round 3: what the run's edit-range gate withheld is still
+    // observed, at its own line.
+    observed: [
+      ...withoutLaneCopies(runtime, pending2, verdict.kept),
+      ...result.outOfEditScope ?? []
+    ].flatMap((d) => d.semantic === "blocking" ? [d] : []),
+    markedAtMs: pending2.markedAtMs,
+    sha256: bytes ? hashContentBytes(bytes) : void 0,
+    ...result.unconfirmedServerIds !== void 0 && {
+      unconfirmedServerIds: result.unconfirmedServerIds
+    }
+  });
+  if (retired > 0)
+    runtime.updateGitGuardStatus(false, "");
+  return retired;
+}
+function withoutLaneCopies(runtime, pending2, findings) {
+  const lane = pending2.result?.coveredBy;
+  if (lane === void 0)
+    return findings;
+  const standsFor = laneCopyStandsFor((runtime.getInlineBlockerDiagnostics(pending2.filePath) ?? []).flatMap((d) => d.runnerId === lane.runnerId && (lane.serverId === void 0 || d.serverId === lane.serverId) ? [d] : []));
+  return findings.flatMap((d) => standsFor(d) ? [] : [d]);
+}
 function readBytes(filePath) {
   try {
     return fs14.readFileSync(filePath);
@@ -8837,7 +9097,7 @@ function stillReportedParked(parked, current, keyOf, offeredKeys) {
 }
 
 // dist/clients/knip-scan-roots.js
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 var MAX_KNIP_ROOTS_PER_TURN = 3;
 function resolveKnipScanRoots(sessionCwd, modifiedFiles) {
   const session = resolveGitCheckout(sessionCwd);
@@ -8847,7 +9107,7 @@ function resolveKnipScanRoots(sessionCwd, modifiedFiles) {
   let sessionOwnsEdit = false;
   const linked = [];
   for (const file of modifiedFiles) {
-    const owner = resolveLinkedWorktreeOwner(session, resolve13(sessionCwd, file));
+    const owner = resolveLinkedWorktreeOwner(session, resolve14(sessionCwd, file));
     if (owner === null) {
       sessionOwnsEdit = true;
     } else if (!linked.some((known) => pathsEqual(known.root, owner.root))) {
@@ -9109,7 +9369,7 @@ function selectPersistentReverifyFiles(report, nowMs = Date.now()) {
     } catch {
       continue;
     }
-    if (mtimeMs > stamp) {
+    if (freshnessFromMtime({ mtimeMs, referenceMs: stamp, toleranceMs: 0 }).verdict === "stale") {
       skippedChanged += 1;
       continue;
     }
@@ -9500,6 +9760,10 @@ function lateDeadCodeScansOf(scope) {
 function joinedEarlierScan(result, askedAt) {
   return result.scannedAt !== void 0 && Date.parse(result.scannedAt) < askedAt;
 }
+var KNIP_CARRIED_FILES = "knip-carried-files";
+function knipCarriedFilesOf(scope) {
+  return scopeCell(scope, KNIP_CARRIED_FILES, () => /* @__PURE__ */ new Map());
+}
 function withRowForFailureWrite(scan, cacheManager2, cacheKey, cwd, startRow) {
   return scan.then((result) => result.success || startRow?.data.success === true ? { result, row: startRow } : cacheManager2.readCacheAsync(cacheKey, cwd).then((row) => ({ result, row })));
 }
@@ -9843,6 +10107,7 @@ async function handleTurnEnd(deps) {
   let runnerFindingsFailed = 0;
   let runnerFindingsDropped = 0;
   let runnerBlockersRecorded = 0;
+  let runnerBlockersRetired = 0;
   let runnerFindingsDispositionSuppressed = 0;
   const runnerFindingsDeliveredIds = [];
   for (const pending2 of pendingRunnerFindings) {
@@ -9869,6 +10134,7 @@ async function handleTurnEnd(deps) {
       dropStaleRunnerFindings(pending2);
       runnerFindingsDropped += 1;
     }
+    runnerBlockersRetired += retireSettledRunnerBlockers(runtime, pending2, verdict);
     if (verdict.live === 0)
       continue;
     const displayPath = toRunnerDisplayPath(cwd, pending2.filePath);
@@ -9914,6 +10180,7 @@ ${lines.join("\n")}`;
       failed: runnerFindingsFailed,
       dropped: runnerFindingsDropped,
       blockersRecorded: runnerBlockersRecorded,
+      blockersRetired: runnerBlockersRetired,
       dispositionSuppressed: runnerFindingsDispositionSuppressed,
       deliveredIds: runnerFindingsDeliveredIds
     }
@@ -10080,6 +10347,7 @@ ${policy.body}`);
     durationMs: Date.now() - cascadeSettleStart,
     metadata: { settled, timedOut }
   });
+  peekOutstandingCascadeTouches(holdScope);
   const t0 = Date.now();
   const cascadeRuns = (holdScope.guardedWrite("turn-end:cascade-runs", () => runtime.consumeCascadeRuns()) ?? []).filter((run) => {
     const originSeq = run.origin?.projectSeq;
@@ -10132,40 +10400,91 @@ ${policy.body}`);
     }
   }
   const cascadeLogFilePath = cascadeResults[0]?.filePath ?? files[0] ?? cwd;
-  if (cascadeResults.length > 0) {
-    const seen = /* @__PURE__ */ new Map();
-    for (const result of cascadeResults) {
-      seen.set(normalizeMapKey(result.filePath), result);
-    }
-    const neighborOwner = /* @__PURE__ */ new Map();
-    for (const result of [...seen.values()].reverse()) {
-      const pk = normalizeMapKey(result.filePath);
-      for (const n of result.neighbors) {
-        const nk = normalizeMapKey(n.filePath);
-        if (!neighborOwner.has(nk))
-          neighborOwner.set(nk, pk);
-      }
+  const cascadeTurn = runtime.turnIndex;
+  const editedKeys = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const absolute = path24.resolve(cwd, file);
+    editedKeys.add(normalizeMapKey(absolute));
+    forgetCascadePendingNeighbor(absolute);
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const result of cascadeResults) {
+    seen.set(normalizeMapKey(result.filePath), result);
+  }
+  const keptResults = new Set(seen.values());
+  const lastObserver = /* @__PURE__ */ new Map();
+  for (const run of [...cascadeRuns].reverse()) {
+    if (run.result && !keptResults.has(run.result))
+      continue;
+    for (const neighborPath of [
+      ...(run.result?.neighbors ?? []).map((n) => n.filePath),
+      ...run.observedNeighborPaths ?? []
+    ]) {
+      const nk = normalizeMapKey(neighborPath);
+      if (!lastObserver.has(nk))
+        lastObserver.set(nk, { run, filePath: neighborPath });
     }
+  }
+  for (const [nk, { run, filePath }] of lastObserver) {
+    const observedClean = run.observedNeighborPaths?.some((p) => normalizeMapKey(p) === nk) && !run.result?.neighbors.some((n) => normalizeMapKey(n.filePath) === nk && n.diagnostics.length > 0);
+    if (observedClean)
+      forgetCascadePendingNeighbor(filePath);
+  }
+  if (cascadeResults.length > 0) {
     const parts = [];
     const sectionRuns = [];
     let injectedNeighborCount = 0;
     let injectedDiagnosticCount = 0;
     let suppressedByOwnership = 0;
+    const sectionObservations = [];
+    const shownUnansweredServerIds = /* @__PURE__ */ new Set();
+    const unansweredLines = [];
     for (const result of seen.values()) {
-      const pk = normalizeMapKey(result.filePath);
-      const ownsAny = result.neighbors.some((n) => neighborOwner.get(normalizeMapKey(n.filePath)) === pk);
-      if (ownsAny && result.formatted) {
-        const carryMeta = carriedMetaByResult.get(result);
-        const carrySuffix = cascadeCarrySuffix(carryMeta?.carriedTurns, carryMeta?.observedAt);
-        parts.push(carrySuffix ? `${result.formatted}
-${carrySuffix}` : result.formatted);
-        if (carrySuffix)
-          carriedRunsRendered += 1;
+      const ownedNeighbors = result.neighbors.filter((n) => lastObserver.get(normalizeMapKey(n.filePath))?.run.result === result);
+      const ownsAny = ownedNeighbors.length > 0;
+      let rendered = ownsAny && result.formatted ? renderCascadeResult(result, shownUnansweredServerIds) : void 0;
+      const layout = result.layout;
+      if (rendered && layout) {
+        const since = (n, d) => cascadeStillPresentSince(n.filePath, d, cascadeTurn);
+        const relabel = ownedNeighbors.some((n) => n.diagnostics.some((d) => since(n, d) !== void 0));
+        if (relabel || ownedNeighbors.length < result.neighbors.length) {
+          const block = formatCascadeNeighborDiagnostics(layout.cwd, ownedNeighbors, {
+            noun: layout.noun,
+            includeReason: layout.includeReason,
+            stillPresentSince: since
+          });
+          rendered = {
+            ...rendered,
+            text: composeCascadeSection(block, layout)
+          };
+        }
+      }
+      if (rendered && (rendered.text || rendered.lines.length > 0)) {
+        unansweredLines.push(...rendered.lines);
+        if (rendered.text) {
+          const carryMeta = carriedMetaByResult.get(result);
+          const carrySuffix = cascadeCarrySuffix(carryMeta?.carriedTurns, carryMeta?.observedAt);
+          parts.push(carrySuffix ? `${rendered.text}
+${carrySuffix}` : rendered.text);
+          if (carrySuffix)
+            carriedRunsRendered += 1;
+        }
         const sectionRun = runByResult.get(result);
         if (sectionRun)
           sectionRuns.push(sectionRun);
-        injectedNeighborCount += result.neighbors.length;
-        injectedDiagnosticCount += result.neighbors.reduce((s, n) => s + n.diagnostics.length, 0);
+        for (const n of ownedNeighbors) {
+          if (n.diagnostics.length === 0)
+            continue;
+          if (editedKeys.has(normalizeMapKey(n.filePath)))
+            continue;
+          sectionObservations.push({
+            filePath: n.filePath,
+            diagnostics: n.diagnostics,
+            checkedAt: sectionRun?.checkedAt
+          });
+        }
+        injectedNeighborCount += ownedNeighbors.length;
+        injectedDiagnosticCount += ownedNeighbors.reduce((s, n) => s + n.diagnostics.length, 0);
       } else if (!ownsAny && result.formatted) {
         suppressedByOwnership++;
       }
@@ -10199,11 +10518,20 @@ ${testLines.join("\n")}`;
         parts.push(testSection);
       }
     }
+    if (unansweredLines.length > 0)
+      parts.unshift(unansweredLines.join("\n"));
     if (parts.length > 0) {
       const section = parts.join("\n\n");
       blockerParts.push(section);
+      const shownServerIds = [...shownUnansweredServerIds];
       deliveryHolds.push({
         part: section,
+        onDelivered: () => {
+          markCascadeUnansweredPrimariesDelivered(shownServerIds);
+          for (const o of sectionObservations) {
+            recordDeliveredCascadeNeighbor(o.filePath, o.diagnostics, cascadeTurn, o.checkedAt ?? 0);
+          }
+        },
         onHeld: () => {
           for (const run of sectionRuns)
             runtime.appendCascadeRun(run);
@@ -10232,6 +10560,124 @@ ${testLines.join("\n")}`;
       }
     });
   }
+  const pendingCandidates = listCascadePendingNeighbors().filter((entry) => {
+    const key = normalizeMapKey(entry.filePath);
+    if (lastObserver.has(key) || editedKeys.has(key))
+      return false;
+    return isUnderDir(entry.filePath, cwd);
+  });
+  const { "cascade-pending-neighbors": pendingGate } = gateFindingsByPathFreshness({
+    cwd,
+    quiet: true,
+    sources: {
+      "cascade-pending-neighbors": {
+        findings: pendingCandidates,
+        citedPath: (entry) => entry.filePath,
+        scannedAtOf: (entry) => entry.checkedAt
+      }
+    }
+  });
+  const unresolvedNeighbors = pendingGate.live;
+  const changedNeighbors = pendingGate.stale;
+  const gateKept = /* @__PURE__ */ new Set([...unresolvedNeighbors, ...changedNeighbors]);
+  const deletedNeighbors = [];
+  for (const entry of pendingCandidates) {
+    if (gateKept.has(entry))
+      continue;
+    deletedNeighbors.push(entry);
+    forgetCascadePendingNeighbor(entry.filePath);
+  }
+  const maxShown = RUNTIME_CONFIG.pipeline.cascadeMaxFiles;
+  const pendingAge = (checkedAt) => formatCacheAgeLabel(checkedAt > 0 ? checkedAt : void 0);
+  const pendingBlocks = [];
+  let unresolvedShown = 0;
+  if (unresolvedNeighbors.length > 0) {
+    const lines = unresolvedNeighbors.slice(-maxShown).reverse().map((entry) => `  \u2022 ${toRunnerDisplayPath(cwd, entry.filePath)}: ${entry.errorCount} error(s) unresolved (${pendingAge(entry.checkedAt)})`);
+    unresolvedShown = lines.length;
+    const more = unresolvedNeighbors.length - lines.length;
+    if (more > 0)
+      lines.push(`  ... and ${more} more neighbor file(s)`);
+    pendingBlocks.push(`\u{1F4D0} Cascade errors from an earlier turn, not re-checked this turn \u2014 still unresolved until a cascade or an edit shows them gone:
+${lines.join("\n")}`);
+  }
+  const changedShown = changedNeighbors.slice(-maxShown).reverse();
+  if (changedShown.length > 0) {
+    const lines = changedShown.map((entry) => `  \u2022 ${toRunnerDisplayPath(cwd, entry.filePath)}: ${entry.errorCount} error(s) changed since checked (${pendingAge(entry.checkedAt)}), not re-checked`);
+    const more = changedNeighbors.length - changedShown.length;
+    if (more > 0)
+      lines.push(`  ... and ${more} more neighbor file(s)`);
+    pendingBlocks.push(`\u{1F4D0} Cascade errors from an earlier turn whose file changed outside pi since they were checked \u2014 not re-checked, named this once:
+${lines.join("\n")}`);
+  }
+  if (pendingBlocks.length > 0) {
+    const pendingSection = pendingBlocks.join("\n");
+    blockerParts.push(pendingSection);
+    if (changedShown.length > 0) {
+      deliveryHolds.push({
+        part: pendingSection,
+        onDelivered: () => {
+          for (const entry of changedShown) {
+            forgetCascadePendingNeighbor(entry.filePath);
+          }
+        }
+      });
+    }
+    logCascade({
+      phase: "cascade_pending_rendered",
+      filePath: cascadeLogFilePath,
+      metadata: {
+        neighbors: unresolvedNeighbors.length,
+        shown: unresolvedShown,
+        changed: changedShown.length
+      }
+    });
+  }
+  if (changedNeighbors.length + deletedNeighbors.length > 0) {
+    logCascade({
+      phase: "cascade_pending_gated",
+      filePath: cascadeLogFilePath,
+      metadata: {
+        changed: changedNeighbors.length,
+        deleted: deletedNeighbors.length,
+        changedPaths: changedNeighbors.slice(0, 10).map((e) => e.filePath),
+        deletedPaths: deletedNeighbors.slice(0, 10).map((e) => e.filePath)
+      }
+    });
+  }
+  const withCarryLabel = (advisory, runs) => {
+    if (advisory === void 0)
+      return void 0;
+    const carried = runs.filter((r) => (r.carriedTurns ?? 0) > 0);
+    if (carried.length === 0 || carried.length !== runs.length) {
+      return advisory;
+    }
+    const stamps = carried.map((r) => r.observedAt);
+    const observedAt = stamps.every((s) => s !== void 0) ? Math.min(...stamps) : void 0;
+    const suffix = cascadeCarrySuffix(carried[0]?.carriedTurns, observedAt);
+    if (!suffix)
+      return advisory;
+    labeledAdvisories += 1;
+    return `${advisory}
+${suffix}`;
+  };
+  const holdAdvisory = (advisory, runs, keep) => {
+    if (advisory === void 0)
+      return;
+    deliveryHolds.push({
+      part: advisory,
+      onHeld: () => {
+        for (const run of runs) {
+          const restored = { ...run, result: void 0 };
+          delete restored.observedNeighborPaths;
+          if (keep !== "indeterminate")
+            delete restored.indeterminate;
+          if (keep !== "unconfirmed")
+            delete restored.unconfirmed;
+          runtime.appendCascadeRun(restored);
+        }
+      }
+    });
+  };
   const indeterminateRuns = cascadeRuns.filter((r) => r.indeterminate);
   if (indeterminateRuns.length > 0) {
     const buildAdvisory = (runs, frame) => {
@@ -10259,47 +10705,20 @@ ${lines.join("\n")}`;
     const graphRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason !== "lsp_binding_rejected" && r.indeterminate?.reason !== "excluded_by_role" && r.indeterminate?.reason !== "budget_truncated" && r.indeterminate?.budget === void 0);
     const bindingRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason === "lsp_binding_rejected" && r.indeterminate?.budget === void 0);
     const budgetRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason === "budget_truncated" || r.indeterminate?.budget !== void 0);
-    const withCarryLabel = (advisory, runs) => {
-      if (advisory === void 0)
-        return void 0;
-      const carried = runs.filter((r) => (r.carriedTurns ?? 0) > 0);
-      if (carried.length === 0 || carried.length !== runs.length) {
-        return advisory;
-      }
-      const stamps = carried.map((r) => r.observedAt);
-      const observedAt = stamps.every((s) => s !== void 0) ? Math.min(...stamps) : void 0;
-      const suffix = cascadeCarrySuffix(carried[0]?.carriedTurns, observedAt);
-      if (!suffix)
-        return advisory;
-      labeledAdvisories += 1;
-      return `${advisory}
-${suffix}`;
-    };
-    const holdAdvisory = (advisory, runs) => {
-      if (advisory === void 0)
-        return;
-      deliveryHolds.push({
-        part: advisory,
-        onHeld: () => {
-          for (const run of runs)
-            runtime.appendCascadeRun({ ...run, result: void 0 });
-        }
-      });
-    };
     const graphAdvisory = withCarryLabel(buildAdvisory(graphRuns, {
       lead: (fileCount2, reasons) => `Cascade could not compute downstream impact for ${fileCount2} edited file(s) this turn \u2014 the review graph was unavailable (${reasons}), so their dependents were not cascade-checked and a clean cascade result does not cover them.`,
       fallbackDetail: (r) => r.indeterminate?.reason === "missing_node" ? "changed file not in the review graph" : "review graph unavailable"
     }), graphRuns);
     if (graphAdvisory)
       advisoryParts.push(graphAdvisory);
-    holdAdvisory(graphAdvisory, graphRuns);
+    holdAdvisory(graphAdvisory, graphRuns, "indeterminate");
     const bindingAdvisory = withCarryLabel(buildAdvisory(bindingRuns, {
       lead: (fileCount2, reasons) => `Cascade identified dependents for ${fileCount2} edited file(s) this turn, but their diagnostics could not be freshly confirmed (${reasons}) and were withheld \u2014 a clean cascade result does not cover them.`,
       fallbackDetail: () => "cascade diagnostics withheld (binding rejected)"
     }), bindingRuns);
     if (bindingAdvisory)
       advisoryParts.push(bindingAdvisory);
-    holdAdvisory(bindingAdvisory, bindingRuns);
+    holdAdvisory(bindingAdvisory, bindingRuns, "indeterminate");
     const budgetAdvisory = withCarryLabel(buildAdvisory(budgetRuns, {
       lead: (fileCount2, reasons) => `Cascade checked the selected neighbors for ${fileCount2} edited file(s) this turn, but some eligible dependents were not checked because the cascade budget was exhausted (${reasons}); a clean cascade result does not cover them.`,
       fallbackDetail: (r) => {
@@ -10312,7 +10731,7 @@ ${suffix}`;
     }), budgetRuns);
     if (budgetAdvisory)
       advisoryParts.push(budgetAdvisory);
-    holdAdvisory(budgetAdvisory, budgetRuns);
+    holdAdvisory(budgetAdvisory, budgetRuns, "indeterminate");
     const fileCount = new Set(indeterminateRuns.map((r) => normalizeMapKey(r.filePath))).size;
     const byFile = indeterminateRuns.map((r) => ({
       file: toRunnerDisplayPath(cwd, r.filePath),
@@ -10336,6 +10755,57 @@ ${suffix}`;
       }
     });
   }
+  const unconfirmedRuns = cascadeRuns.filter((r) => r.unconfirmed);
+  if (unconfirmedRuns.length > 0) {
+    const runOrder = new Map(cascadeRuns.map((r, i) => [r, i]));
+    const byServer = /* @__PURE__ */ new Map();
+    for (const run of unconfirmedRuns) {
+      for (const group of run.unconfirmed?.servers ?? []) {
+        for (const neighborPath of group.paths) {
+          const nk = normalizeMapKey(neighborPath);
+          if (editedKeys.has(nk))
+            continue;
+          const observer = lastObserver.get(nk)?.run;
+          if (observer && (runOrder.get(observer) ?? -1) > (runOrder.get(run) ?? -1))
+            continue;
+          const bucket = byServer.get(group.serverId) ?? {
+            waitMs: group.waitMs,
+            primaries: /* @__PURE__ */ new Set(),
+            paths: /* @__PURE__ */ new Map()
+          };
+          bucket.waitMs = Math.max(bucket.waitMs, group.waitMs);
+          bucket.primaries.add(toRunnerDisplayPath(cwd, run.filePath));
+          bucket.paths.set(nk, toRunnerDisplayPath(cwd, neighborPath));
+          byServer.set(group.serverId, bucket);
+        }
+      }
+    }
+    const capped = (items, max) => items.length > max ? `${items.slice(0, max).join(", ")} (+${items.length - max} more)` : items.join(", ");
+    const blocks = [];
+    let pathCount = 0;
+    for (const [serverId, bucket] of byServer) {
+      const paths = [...bucket.paths.values()];
+      pathCount += paths.length;
+      const within = bucket.waitMs > 0 ? ` within ${bucket.waitMs} ms` : "";
+      blocks.push(`Cascade sent ${paths.length} dependent(s) of ${capped([...bucket.primaries], 3)} to ${serverId}, but no answer arrived${within}; a clean cascade result does not cover them.
+  \u2022 ${serverId}: ${capped(paths, 5)}`);
+    }
+    if (blocks.length > 0) {
+      const pendingAdvisory = withCarryLabel(blocks.join("\n"), unconfirmedRuns);
+      if (pendingAdvisory)
+        advisoryParts.push(pendingAdvisory);
+      holdAdvisory(pendingAdvisory, unconfirmedRuns, "unconfirmed");
+      logCascade({
+        phase: "cascade_unconfirmed_rendered",
+        filePath: cascadeLogFilePath,
+        metadata: {
+          servers: byServer.size,
+          paths: pathCount,
+          runs: unconfirmedRuns.length
+        }
+      });
+    }
+  }
   if (carriedRunsRendered > 0 || labeledAdvisories > 0) {
     logCascade({
       phase: "cascade_carry_rendered",
@@ -10369,6 +10839,7 @@ ${suffix}`;
       skipped: cascadeSkipped
     }
   });
+  const knipCarried = knipCarriedFilesOf(turnScope);
   const knipScan = resolveKnipScanRoots(cwd, files);
   for (const root of knipScan.overCap) {
     incrementDegradationCount({
@@ -10379,7 +10850,7 @@ ${suffix}`;
   }
   const KNOWN_SLOW_KNIP_GRACE_MS = 1;
   const KNIP_MAX_SHOWN = 5;
-  const applyKnipResult = (scanRoot, prevKnip, knipResult, rowNow) => {
+  const applyKnipResult = (scanRoot, prevKnip, knipResult, rowNow, joined) => {
     const knipWouldPoison = wouldPoisonCache(rowNow, knipResult);
     if (knipWouldPoison) {
       dbg(`turn_end: keeping last good knip cache; this run failed: ${knipResult.summary}`);
@@ -10412,7 +10883,7 @@ ${suffix}`;
     if (knipResult.success && knipResult.issues.length > 0) {
       const issueKey = (i) => stableFindingKey(i.type, i.file, i.name, i.package);
       const prevKeys = new Set((prevKnip?.data?.issues ?? []).map(issueKey));
-      const modifiedSet = new Set(files.map((f) => resolveRunnerPath(cwd, f)));
+      const modifiedSet = new Set([...files, ...knipCarried.get(scanRoot) ?? []].map((f) => resolveRunnerPath(cwd, f)));
       const newIssues = knipResult.issues.filter((issue) => {
         if (prevKeys.has(issueKey(issue)))
           return false;
@@ -10472,6 +10943,13 @@ ${suffix}`;
         deliveryHolds.push(cutAdvisoryHold("knip", knipAdvisoryLane, report, unusedExportDelta.slice(0, KNIP_MAX_SHOWN), (issue) => reOfferedKeys.has(issueKey(issue))));
       }
     }
+    if (joined) {
+      const carry = new Set(files);
+      knipCarried.set(scanRoot, carry);
+      knipMeta.joined = true;
+      knipMeta.carried = carry.size;
+    } else if (knipResult.success)
+      knipCarried.delete(scanRoot);
     return knipMeta;
   };
   const logKnipRow = (root, startedAt, metadata) => logLatency({
@@ -10538,7 +11016,8 @@ ${suffix}`;
             });
           }
         } else {
-          metadata = applyKnipResult(scanRoot, prevKnip, scanned.result, scanned.row);
+          const joined = scanned.result.success && scanned.result.execution !== "cache" && joinedEarlierScan(scanned.result, startedAt);
+          metadata = applyKnipResult(scanRoot, prevKnip, scanned.result, scanned.row, joined);
         }
       }
       budgetSpent = metadata.execution === "deferred" && (metadata.scanFloorMs === void 0 || metadata.aborted === true);
@@ -10909,7 +11388,7 @@ ${suffix}`;
     metadata: madgeStats ?? { skipped: true }
   });
   if (!getFlag("no-tests") && files.length > 0) {
-    const seen = /* @__PURE__ */ new Set();
+    const seen2 = /* @__PURE__ */ new Set();
     const targets = [];
     const testRootFor = createTurnEndTestRoots(cwd);
     const candidates = [];
@@ -10976,7 +11455,7 @@ ${suffix}`;
         foreignDeferred++;
         continue;
       }
-      if (seen.has(carriedKey)) {
+      if (seen2.has(carriedKey)) {
         resolvedDeferralKeys.add(carriedKey);
         continue;
       }
@@ -11020,7 +11499,7 @@ ${suffix}`;
         continue;
       }
       resolvedDeferralKeys.add(carriedKey);
-      seen.add(carriedKey);
+      seen2.add(carriedKey);
       redispatchedDeferred++;
       targets.push({
         testFile,
@@ -11071,8 +11550,8 @@ ${suffix}`;
       candidatesByRoot.set(testRoot, (candidatesByRoot.get(testRoot) ?? 0) + 1);
       const target = testRunnerClient.getTestRunTarget(abs, testRoot, runtime.turnIndex);
       const targetKey = target ? normalizeMapKey(target.testFile) : "";
-      if (target && !seen.has(targetKey)) {
-        seen.add(targetKey);
+      if (target && !seen2.has(targetKey)) {
+        seen2.add(targetKey);
         if (retiredKeys.has(targetKey)) {
           retiredSkips++;
           dbg(`turn_end: ${display} \u2192 test target retired earlier this session (outran the turn-end batch budget), skipping spawn (${path24.relative(cwd, target.testFile)})`);
@@ -11473,8 +11952,8 @@ ${suffix}`;
     } else {
       const callGraphStart = Date.now();
       try {
-        const { impact, formatImpact, parseSymbolKey } = await import("../chunk-BKE7E7TC.js");
-        const { callGraphImpactToProjectDiagnostics } = await import("../chunk-6GFRNVYR.js");
+        const { impact, formatImpact, parseSymbolKey } = await import("../chunk-GMX5OS7B.js");
+        const { callGraphImpactToProjectDiagnostics } = await import("../chunk-MZGQNL3Y.js");
         const impactLines = [];
         let callGraphDispositionSuppressed = 0;
         const impactFindings = [];
@@ -11597,6 +12076,8 @@ ${impactLines.join("\n")}`;
         modifiedRangesByFile,
         dispatchWarnings: runtime.peekActionableWarnings(sessionId),
         includeLspCodeActions: !!getFlag("lens-actionable-warning-actions"),
+        // #4323: the cold LSP read leaves a switched-off Opengrep unstarted.
+        getFlag,
         projectSeqStart: runtime.turnStartProjectSeq,
         projectSeqEnd: runtime.projectSeq,
         // #3676: the quick fix credits its writes with this epoch.
@@ -11715,31 +12196,7 @@ ${impactLines.join("\n")}`;
   }
   const t5 = Date.now();
   try {
-    const qualityWarningsByFile = /* @__PURE__ */ new Map();
-    for (const warning of runtime.peekCodeQualityWarnings(sessionId)) {
-      const group = qualityWarningsByFile.get(warning.filePath);
-      if (group)
-        group.push(warning);
-      else
-        qualityWarningsByFile.set(warning.filePath, [warning]);
-    }
-    const qualityWarnings = [];
-    let qualityDispositionSuppressed = 0;
-    for (const [filePath, group] of qualityWarningsByFile) {
-      let content;
-      try {
-        content = fs17.readFileSync(filePath, "utf-8");
-      } catch {
-        content = void 0;
-      }
-      const { kept, suppressed } = applyPushedFindingPolicy(group, {
-        cwd,
-        filePath,
-        content
-      });
-      qualityWarnings.push(...kept);
-      qualityDispositionSuppressed += suppressed;
-    }
+    const { kept: qualityWarnings, suppressed: qualityDispositionSuppressed } = applyPushedFindingPolicyByFile(runtime.peekCodeQualityWarnings(sessionId), cwd);
     const qualityReport = buildCodeQualityWarningsReport({
       cwd,
       sessionId: runtime.telemetrySessionId,
@@ -12467,7 +12924,7 @@ var TurnEndQueue = class {
   }
 };
 var turnEndQueue = new TurnEndQueue();
-var pendingTurnEndDeliveries = /* @__PURE__ */ new Map();
+var pendingTurnEndDeliveries = new BoundedFifoMap(TURN_END_DELIVERY_MAX);
 var inFlightIpcTurnEnds = /* @__PURE__ */ new Map();
 async function runTurnEndNowImpl(cwd, files = [], deferredDelivery = false) {
   const ctx = await getMcpSessionContext();
@@ -12545,12 +13002,6 @@ function prunePendingTurnEndDeliveries(now = Date.now()) {
       pendingTurnEndDeliveries.delete(deliveryId);
     }
   }
-  while (pendingTurnEndDeliveries.size > TURN_END_DELIVERY_MAX) {
-    const oldest = pendingTurnEndDeliveries.keys().next();
-    if (oldest.done)
-      break;
-    pendingTurnEndDeliveries.delete(oldest.value);
-  }
 }
 function pendingForCwd(cwd) {
   for (const [deliveryId, delivery] of pendingTurnEndDeliveries) {
@@ -13167,7 +13618,7 @@ function blastReadArgs(graph, normalizedFile) {
   return { path: normalizedFile, offset: 1, limit };
 }
 async function computeBlastRadius(graph, normalizedPath, projectRoot, maxDepth) {
-  const { computeTransitiveImpact } = await import("../chunk-4UNXBNE2.js");
+  const { computeTransitiveImpact } = await import("../chunk-XTFDJI3T.js");
   const result = computeTransitiveImpact(graph, normalizedPath, { maxDepth });
   const byFile = /* @__PURE__ */ new Map();
   for (const hit of result.hits) {
@@ -13784,7 +14235,7 @@ async function moduleReport(file, cwd, options) {
   let callGraphIdentity;
   let revisionDriftNote;
   try {
-    const { getCachedReviewGraph, getReviewGraphCacheIdentity, getReviewGraphSizeSkipVerdict, getReviewGraphRevisionDrift, formatReviewGraphRevisionDriftNote: formatReviewGraphRevisionDriftNote2 } = await import("../chunk-2ZGIZPDG.js");
+    const { getCachedReviewGraph, getReviewGraphCacheIdentity, getReviewGraphSizeSkipVerdict, getReviewGraphRevisionDrift, formatReviewGraphRevisionDriftNote: formatReviewGraphRevisionDriftNote2 } = await import("../chunk-YCWYO6TQ.js");
     graph = getCachedReviewGraph(cwd);
     graphFileCap = getReviewGraphSizeSkipVerdict(cwd)?.maxFileCount;
     const drift = graph ? getReviewGraphRevisionDrift(cwd) : void 0;
@@ -14568,7 +15019,7 @@ function roleFor(graph, filePath) {
   return top.length > 0 ? top.map((s) => s.name).join(", ") : void 0;
 }
 async function computeHubs(graph, degrees, cwd, limit, focusTerms) {
-  const { computeTransitiveImpact } = await import("../chunk-4UNXBNE2.js");
+  const { computeTransitiveImpact } = await import("../chunk-XTFDJI3T.js");
   const ranked = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => ({
     filePath,
     fileNodeId,
@@ -14820,7 +15271,7 @@ async function projectReport(cwd, options) {
   const limit = clampLimit(options?.limit);
   const focusTerms = normalizeFocus2(options?.focus);
   const view = options?.view;
-  const { getCachedReviewGraph, getReviewGraphSizeSkipVerdict, getLastReviewGraphBuildAttempt, buildOrUpdateGraph, isGraphBuildInFlight, getReviewGraphRevisionDrift } = await import("../chunk-2ZGIZPDG.js");
+  const { getCachedReviewGraph, getReviewGraphSizeSkipVerdict, getLastReviewGraphBuildAttempt, buildOrUpdateGraph, isGraphBuildInFlight, getReviewGraphRevisionDrift } = await import("../chunk-YCWYO6TQ.js");
   let graph;
   try {
     graph = getCachedReviewGraph(cwd);
@@ -14844,7 +15295,7 @@ async function projectReport(cwd, options) {
       };
     }
     const previousAttempt = getLastReviewGraphBuildAttempt(cwd);
-    const { FactStore: FactStore2 } = await import("../chunk-QGQ5CCCG.js");
+    const { FactStore: FactStore2 } = await import("../chunk-UMS2MFPZ.js");
     const trigger = triggerBackgroundGraphBuild(cwd, {
       buildOrUpdateGraph,
       isGraphBuildInFlight,
@@ -14945,7 +15396,7 @@ function renderCompactProjectReport(report) {
 }
 
 // dist/clients/effective-config.js
-import * as os3 from "node:os";
+import * as os2 from "node:os";
 import * as path28 from "node:path";
 function isEffectiveFileViewError(file) {
   return "error" in file;
@@ -15011,7 +15462,7 @@ function decidedByOrNothing(entry) {
 }
 async function effectiveConfig(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const homeDir = options.homeDir ?? os3.homedir();
+  const homeDir = options.homeDir ?? os2.homedir();
   const resolveAt = (dir) => resolvePiLensConfig({
     cwd: dir,
     globalDir: getGlobalPiLensDir(),
@@ -15125,13 +15576,19 @@ function recentLatency(limit = 5, fileFilter) {
   }
   return reports.slice(-limit).reverse();
 }
-function projectScan(cwd, maxFiles, includeGenerated) {
-  return scanProjectDiagnostics({
+async function projectScan(cwd, maxFiles, includeGenerated) {
+  const scan = await scanProjectDiagnostics({
     cwd,
     tier: "cheap",
     maxFiles,
     includeGenerated
   });
+  const policy = applyPushedFindingPolicyByFile(scan.diagnostics, cwd);
+  return {
+    ...scan,
+    diagnostics: policy.kept,
+    dispositionSuppressed: policy.suppressed
+  };
 }
 function scanTruncationNotice(snapshot) {
   if (!snapshot.scanTruncated)
@@ -15263,7 +15720,7 @@ async function symbolSearch(query, cwd, limit = 20, options = {}) {
     warmLease.release();
   }
   const hits = results.map(toSymbolSearchHit);
-  const { getCachedReviewGraph } = await import("../chunk-2ZGIZPDG.js");
+  const { getCachedReviewGraph } = await import("../chunk-YCWYO6TQ.js");
   const graph = getCachedReviewGraph(cwd);
   if (graph)
     annotateSymbolSearchHitsWithGraph(hits, centrality, graph);
@@ -15460,10 +15917,12 @@ function canonicalLanguage(lang) {
 }
 
 // dist/tools/shared.js
+import * as path31 from "node:path";
 function resolveAstGrepPaths(paths, cwd) {
   const base = cwd || ".";
-  const requested = paths?.length ? paths : [base];
-  return requested.map((p) => resolveHostToolPath(p, base));
+  if (!paths?.length)
+    return [path31.resolve(base)];
+  return paths.map((p) => resolveHostToolPath(p, base));
 }
 var LANGUAGES = [
   "bash",
@@ -16413,7 +16872,7 @@ ${hint}` : `${output}${paginationNote}`;
 // dist/tools/lens-diagnostics.js
 import { promises as fs23 } from "node:fs";
 import * as fsSync from "node:fs";
-import * as path37 from "node:path";
+import * as path38 from "node:path";
 
 // dist/clients/project-diagnostics/extractors.js
 var WARM_TRIGGER = {
@@ -16472,13 +16931,13 @@ function reasonFromAvailabilityVerdict(tool, verdict) {
 
 // dist/clients/project-diagnostics/fresh-fetch.js
 import * as fs21 from "node:fs";
-import * as os4 from "node:os";
-import * as path35 from "node:path";
+import * as os3 from "node:os";
+import * as path36 from "node:path";
 
 // dist/clients/project-diagnostics/runner-adapters/jscpd.js
-import * as path31 from "node:path";
+import * as path32 from "node:path";
 function resolveClonePath(cwd, file) {
-  return path31.isAbsolute(file) ? file : path31.resolve(cwd, file);
+  return path32.isAbsolute(file) ? file : path32.resolve(cwd, file);
 }
 function jscpdCloneToProjectDiagnostics(cwd, clone) {
   const a = resolveClonePath(cwd, clone.fileA);
@@ -16491,7 +16950,7 @@ function jscpdCloneToProjectDiagnostics(cwd, clone) {
     tool: "jscpd",
     runner: "jscpd",
     rule: "jscpd:duplicate",
-    message: `Duplicate code (${clone.lines} lines) \u2014 also at ${path31.relative(cwd, otherFile)}:${otherLine}`,
+    message: `Duplicate code (${clone.lines} lines) \u2014 also at ${path32.relative(cwd, otherFile)}:${otherLine}`,
     source: "project-scan"
   });
   return [
@@ -16506,16 +16965,16 @@ function jscpdResultToProjectDiagnostics(cwd, result) {
 }
 
 // dist/clients/project-diagnostics/runner-adapters/madge.js
-import * as path32 from "node:path";
+import * as path33 from "node:path";
 function resolveCyclePath(cwd, file) {
-  return path32.isAbsolute(file) ? file : path32.resolve(cwd, file);
+  return path33.isAbsolute(file) ? file : path33.resolve(cwd, file);
 }
 function cycleMembers(dep) {
   return dep.path.length > 0 ? dep.path : [dep.file];
 }
 function circularDepToProjectDiagnostics(cwd, dep) {
   const members = cycleMembers(dep);
-  const rendered = `${members.map((f) => path32.basename(f)).join(" \u2192 ")} \u2192 ${path32.basename(members[0] ?? "")}`;
+  const rendered = `${members.map((f) => path33.basename(f)).join(" \u2192 ")} \u2192 ${path33.basename(members[0] ?? "")}`;
   return members.map((file) => ({
     filePath: resolveCyclePath(cwd, file),
     severity: "warning",
@@ -16541,7 +17000,7 @@ function circularDepsToProjectDiagnostics(cwd, circular) {
 }
 
 // dist/clients/project-diagnostics/runner-adapters/opengrep.js
-import * as path33 from "node:path";
+import * as path34 from "node:path";
 function severityFor(raw) {
   switch (raw.toUpperCase()) {
     case "ERROR":
@@ -16556,7 +17015,7 @@ function opengrepFindingToProjectDiagnostic(cwd, finding) {
   const { severity, blocking } = severityFor(finding.severity);
   const cweSuffix = finding.cwe?.length ? ` (${finding.cwe[0]})` : "";
   return {
-    filePath: path33.isAbsolute(finding.path) ? finding.path : path33.resolve(cwd, finding.path),
+    filePath: path34.isAbsolute(finding.path) ? finding.path : path34.resolve(cwd, finding.path),
     line: finding.startLine,
     column: finding.startCol,
     severity,
@@ -16576,7 +17035,7 @@ function opengrepResultToProjectDiagnostics(cwd, result) {
 
 // dist/clients/project-diagnostics/runner-adapters/runner-findings.js
 import * as fs20 from "node:fs";
-import * as path34 from "node:path";
+import * as path35 from "node:path";
 function failureMessage(failure) {
   const firstLine2 = failure.message.split("\n")[0]?.slice(0, 300) ?? "";
   return firstLine2 ? `${failure.name}: ${firstLine2}` : failure.name;
@@ -16642,7 +17101,7 @@ function testRunnerFindingsToProjectDiagnostics(cache, cwd, runtime) {
     return [];
   const validation = cwd ? validateAdvisoryProvenance(cache, cwd, runtime) : { status: "unknown", reasons: ["validation-context-missing"] };
   const root = cwd ?? process.cwd();
-  const missingKeys = new Set((cache.provenance?.files ?? []).filter((file) => !fs20.existsSync(path34.resolve(root, file.path))).map((file) => advisoryPathKey(file.path, root)));
+  const missingKeys = new Set((cache.provenance?.files ?? []).filter((file) => !fs20.existsSync(path35.resolve(root, file.path))).map((file) => advisoryPathKey(file.path, root)));
   const historical = cache.superseded === true || cache.stale === true || validation.status !== "current";
   return cache.results.filter((result) => !missingKeys.has(advisoryPathKey(result.file, root))).flatMap((result) => testResultToProjectDiagnostics(result, historical)).map((diagnostic) => historical ? {
     ...diagnostic,
@@ -16672,7 +17131,7 @@ function laneObservedAtMs(scannedAt, startedAtMs) {
   return parseScannedAtMs(scannedAt) ?? startedAtMs;
 }
 async function fetchFreshProjectDiagnostics(cacheManager2, cwd, clients, signal, options = {}) {
-  const requestedRoot = options.analysisRoot === void 0 ? cwd : path35.resolve(cwd, options.analysisRoot);
+  const requestedRoot = options.analysisRoot === void 0 ? cwd : path36.resolve(cwd, options.analysisRoot);
   let analysisRoot;
   let analysisRootValidation;
   if (options.analysisRoot !== void 0) {
@@ -16711,7 +17170,7 @@ async function fetchFreshProjectDiagnostics(cacheManager2, cwd, clients, signal,
     analysisRoot = realpathOrResolve(cwd);
   }
   const unsafeRootReason = "the analysis root resolves at or above the home directory; heavyweight analyzers refuse to walk from there (#747)";
-  const homeRoot = realpathOrResolve(options.homeDir ?? os4.homedir());
+  const homeRoot = realpathOrResolve(options.homeDir ?? os3.homedir());
   if (options.analysisRoot !== void 0) {
     const unsafeExplicitRoot = !isSameOrWithin(homeRoot, analysisRoot) || isSameOrWithin(analysisRoot, homeRoot);
     analysisRootValidation = unsafeExplicitRoot ? {
@@ -16839,7 +17298,7 @@ async function fetchFreshProjectDiagnostics(cacheManager2, cwd, clients, signal,
         markCold("jscpd", reasonFromAvailabilityVerdict("jscpd", clients.jscpdClient.getAvailabilityVerdict?.()));
         return;
       }
-      const isTsProject = fs21.existsSync(path35.join(analysisRoot, "tsconfig.json"));
+      const isTsProject = fs21.existsSync(path36.join(analysisRoot, "tsconfig.json"));
       const scannerKey = isTsProject ? "jscpd-ts" : "jscpd";
       const startMs = Date.now();
       const result = await clients.jscpdClient.scan(analysisRoot, void 0, void 0, isTsProject);
@@ -17156,7 +17615,7 @@ function makeProgressReporter(onUpdate, label, throttleMs = 250) {
 
 // dist/tools/lsp-diagnostics.js
 import * as fs22 from "node:fs";
-import * as path36 from "node:path";
+import * as path37 from "node:path";
 var MAX_FILES = 100;
 var MAX_BATCH_FILES = 100;
 var MAX_DIAGNOSTICS = 200;
@@ -17239,11 +17698,11 @@ async function collectFiles(dir, extensions, maxFiles, isIgnored = () => false)
         return;
       if (entry.isSymbolicLink())
         continue;
-      const full = path36.join(current, entry.name);
+      const full = path37.join(current, entry.name);
       if (entry.isDirectory()) {
         if (!isExcludedDirName(entry.name) && !isIgnored(full, true))
           await walk(full);
-      } else if (entry.isFile() && extensions.includes(path36.extname(full))) {
+      } else if (entry.isFile() && extensions.includes(path37.extname(full))) {
         if (isIgnored(full, false))
           continue;
         files.push(full);
@@ -17253,7 +17712,7 @@ async function collectFiles(dir, extensions, maxFiles, isIgnored = () => false)
   await walk(dir);
   return files;
 }
-function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getService = getLSPService) {
+function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getService = getLSPService, getFlag) {
   return {
     async execute(_toolCallId, params, _signal, onUpdate, ctx) {
       const signal = combineAbortSignals(_signal, ctx.signal);
@@ -17264,6 +17723,7 @@ function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getServ
       const concurrency = boundedPositiveInt(typedParams.concurrency, DEFAULT_BATCH_CONCURRENCY, 1, MAX_BATCH_CONCURRENCY);
       const waitMs = typeof typedParams.waitMs === "number" && typedParams.waitMs >= 0 ? Math.floor(typedParams.waitMs) : void 0;
       const serverScope = typedParams.serverScope === "primary" ? "primary" : "all";
+      const excludeServerIds = getFlag ? configDisabledAuxiliaryLspServerIds((name) => getFlag(name, cwd)) : void 0;
       const lspService = getService();
       if (!lspService) {
         return {
@@ -17321,7 +17781,8 @@ function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getServ
           nextWriteIndex,
           serverScope,
           cwd,
-          onConfirmedNoBlockers
+          onConfirmedNoBlockers,
+          excludeServerIds
         }, expanded);
       }
       const rawPath = typedParams.path;
@@ -17337,7 +17798,7 @@ function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getServ
           details: {}
         };
       }
-      const absPath = normalizeMapKey(path36.resolve(cwd, rawPath));
+      const absPath = normalizeMapKey(typedParams.pathAlreadyResolved === true ? rawPath : resolveHostToolPath(rawPath, cwd));
       let stat;
       try {
         stat = fs22.statSync(absPath);
@@ -17359,14 +17820,15 @@ function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getServ
           nextWriteIndex,
           serverScope,
           cwd,
-          onConfirmedNoBlockers
+          onConfirmedNoBlockers,
+          excludeServerIds
         });
       }
-      return runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope, cwd, onConfirmedNoBlockers);
+      return runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope, cwd, onConfirmedNoBlockers, excludeServerIds);
     }
   };
 }
-async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs, serverScope = "all") {
+async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs, serverScope = "all", excludeServerIds) {
   let timedOut = false;
   let content;
   let touched;
@@ -17431,6 +17893,7 @@ async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs,
       maxClientWaitMs: waitMs,
       source: "lsp_diagnostics",
       clientScope: serverScope,
+      excludeServerIds,
       // #3405: the caller asked whether THIS file is clean right now, and the
       // content above was just read from disk — so it is the file's saved
       // state. Without the save a save-triggered server answers zero
@@ -17438,10 +17901,11 @@ async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs,
       // as clean.
       saved: true
     });
-    timedOut = touched?.inconclusive === true;
+    timedOut = touched?.inconclusive === true && touched.inconclusiveReason !== "primary-unavailable";
   } catch {
   }
-  const diagnostics = touched !== void 0 ? touched.diags : await lspService.getDiagnostics(absPath, waitMs !== void 0 ? "document" : "full");
+  const diagnostics = touched !== void 0 ? touched.diags : await lspService.getDiagnostics(absPath, waitMs !== void 0 ? "document" : "full", excludeServerIds);
+  const fallbackHealth = touched === void 0 ? lspService.getDiagnosticsHealth?.(absPath) : void 0;
   const filtered = content !== void 0 ? applyAuxiliarySuppressions(diagnostics, content, {
     fileRole: detectFileRole(absPath, content),
     filePath: absPath,
@@ -17449,11 +17913,18 @@ async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs,
   }) : diagnostics;
   const binding = touched?.binding;
   const confirmedByTouch = touchCompletedConfirmationPolicy(touched);
+  const primaryUnavailable = describePrimaryUnavailable(touched, fallbackHealth);
+  const noClientAnswered = fallbackHealth !== void 0 && String(fallbackHealth.health ?? "").startsWith("no_clients");
   return {
     diagnostics: filtered,
     timedOut,
     skipReason: touched?.skipReason,
     confirmedByTouch,
+    ...noClientAnswered && { noClientAnswered: true },
+    ...primaryUnavailable !== void 0 && {
+      primaryUnavailable: primaryUnavailable.text,
+      primaryUnavailableCause: primaryUnavailable.cause
+    },
     // #1470: only a touch that resolved clients contributes a coverage gap;
     // the getDiagnostics fallback never reports one, which is honest — that
     // path claims no confirmation at all.
@@ -17463,6 +17934,27 @@ async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs,
     binding
   };
 }
+function describePrimaryUnavailable(touched, fallbackHealth) {
+  let serverIds;
+  let disabledServerIds;
+  let carriedCause;
+  if (touched?.inconclusiveReason === "primary-unavailable") {
+    serverIds = touched.inconclusiveServerIds ?? [];
+    disabledServerIds = touched.disabledPrimaryServerIds ?? [];
+    carriedCause = touched.primaryUnavailableCause;
+  } else if (fallbackHealth?.unavailablePrimaryServerIds?.length) {
+    serverIds = fallbackHealth.unavailablePrimaryServerIds;
+    disabledServerIds = fallbackHealth.disabledPrimaryServerIds ?? [];
+    carriedCause = fallbackHealth.primaryUnavailableCause;
+  } else {
+    return void 0;
+  }
+  const cause = carriedCause ?? primaryUnavailableCause(serverIds, disabledServerIds);
+  return {
+    text: `Primary LSP (${serverIds.join(", ")}): not available \u2014 no language server answered for this file (${PRIMARY_UNAVAILABLE_CAUSE[cause]}). NOT the same as 0 diagnostics; auxiliary scanners do not check the language itself.`,
+    cause
+  };
+}
 function diagnosticsToFileDiags(file, diagnostics) {
   return diagnostics.map((d) => ({
     file,
@@ -17508,7 +18000,7 @@ async function resolveEmptyResult(file, lspService) {
 function canTrustTouchConfirmation(file, serverScope, confirmedByTouch) {
   return confirmedByTouch && (serverScope === "primary" || primaryServerId(file) !== "typescript");
 }
-function coveredSourcesForCheck(file, serverScope, unconfirmedServerIds) {
+function coveredSourcesForCheck(file, serverScope, unconfirmedServerIds, excludeServerIds) {
   const unconfirmed = new Set(unconfirmedServerIds);
   const covered = /* @__PURE__ */ new Set();
   let servers = [];
@@ -17523,6 +18015,8 @@ function coveredSourcesForCheck(file, serverScope, unconfirmedServerIds) {
       continue;
     if (unconfirmed.has(server.id))
       continue;
+    if (excludeServerIds?.has(server.id))
+      continue;
     covered.add(auxiliary ? server.id : "lsp");
   }
   return [...covered];
@@ -17534,7 +18028,7 @@ function demoteInferredForFile(file, diagnostics, cwd, lspService) {
     service: lspService
   });
 }
-function applyProbeFindingPolicy(file, diagnostics, cwd, content, severity) {
+function applyProbeFindingPolicy(file, diagnostics, cwd, content, severity, toolName = "lsp_diagnostics") {
   const started = Date.now();
   try {
     const result = applyLspFindingPolicy(diagnostics, {
@@ -17549,7 +18043,7 @@ function applyProbeFindingPolicy(file, diagnostics, cwd, content, severity) {
     if (suppressed > 0) {
       logLatency({
         type: "phase",
-        toolName: "lsp_diagnostics",
+        toolName,
         filePath: file,
         phase: "lsp_probe_disposition_filter",
         durationMs: Date.now() - started,
@@ -17571,15 +18065,11 @@ function applyProbeFindingPolicy(file, diagnostics, cwd, content, severity) {
   }
 }
 function replayContentForStrictMarks(file, cwd) {
-  if (!hasStrictDispositionMarks(cwd))
-    return void 0;
-  try {
-    return fs22.readFileSync(file, "utf-8");
-  } catch {
-    return void 0;
-  }
+  return hasStrictDispositionMarks(cwd) ? readFileContent(file) : void 0;
 }
-function reconcileWidgetFromLspResult(file, rawDiags, confirmation, writeIndex, cwd, content, boundMismatch = false, observedAt) {
+function reconcileWidgetFromLspResult(file, rawDiags, confirmation, writeIndex, cwd, content, boundMismatch = false, observedAt, auxiliariesOnly = false) {
+  if (auxiliariesOnly)
+    return { confirmed: false, blocking: true };
   const confirmed = (rawDiags.length > 0 || confirmation !== "unconfirmed") && !boundMismatch;
   if (!confirmed)
     return { confirmed: false, blocking: true };
@@ -17596,7 +18086,7 @@ function reconcileWidgetFromLspResult(file, rawDiags, confirmation, writeIndex,
     return { confirmed: false, blocking: true };
   }
 }
-async function collectFileDiagnosticResult(file, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cacheCtx, scopeKey, cwd = process.cwd(), onConfirmedNoBlockers) {
+async function collectFileDiagnosticResult(file, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cacheCtx, scopeKey, cwd = process.cwd(), onConfirmedNoBlockers, excludeServerIds) {
   const writeIndex = nextWriteIndex?.();
   const scannedAt = Date.now();
   let stat;
@@ -17640,7 +18130,7 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
       };
     }
   }
-  const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason } = await collectDiagnosticsForFile(file, lspService, cwd, waitMs, serverScope);
+  const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason, primaryUnavailable, primaryUnavailableCause: primaryUnavailableCause2, noClientAnswered } = await collectDiagnosticsForFile(file, lspService, cwd, waitMs, serverScope, excludeServerIds);
   if (tooLargeReason !== void 0) {
     return { file, diagnostics: [], outcome: "too_large", tooLargeReason };
   }
@@ -17649,7 +18139,7 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
   let confirmation;
   if (diagnosticsUnsupportedServerIds.length > 0) {
     confirmation = void 0;
-  } else if (skipReason !== void 0) {
+  } else if (skipReason !== void 0 || primaryUnavailable !== void 0) {
     confirmation = "unconfirmed";
   } else if (timedOut) {
     if (applySeverityFilter(rawDiags, severity).length === 0) {
@@ -17689,13 +18179,14 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     boundMismatch,
     // #3505 r1 F1: the widget row is observed at the read, as the cache
     // entry recorded below is.
-    scannedAt
+    scannedAt,
+    primaryUnavailable !== void 0
   );
   if (verdict.confirmed && !verdict.blocking) {
     onConfirmedNoBlockers?.({
       filePath: file,
       writeIndex,
-      coveredSources: coveredSourcesForCheck(file, serverScope, unconfirmedServerIds),
+      coveredSources: coveredSourcesForCheck(file, serverScope, unconfirmedServerIds, excludeServerIds),
       cwd
     });
   }
@@ -17710,6 +18201,11 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     timedOut: confirmation === "unconfirmed" ? timedOut : void 0,
     ...rootFallback && { rootFallback },
     ...skipReason !== void 0 && { skipReason },
+    ...primaryUnavailable !== void 0 && {
+      primaryUnavailable,
+      primaryUnavailableCause: primaryUnavailableCause2
+    },
+    ...noClientAnswered && { noClientAnswered },
     primaryServerId: primaryServerId(file),
     diagnosticsUnsupported: diagnosticsUnsupportedServerIds.length > 0,
     ...policy.suppressed > 0 && {
@@ -17717,10 +18213,14 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     }
   };
 }
-async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cwd = process.cwd(), onConfirmedNoBlockers) {
+async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cwd = process.cwd(), onConfirmedNoBlockers, excludeServerIds) {
   const writeIndex = nextWriteIndex?.();
+  lspService.announceCreatedFiles([
+    ...goPackageFilesToAnnounce([absPath]),
+    ...await importTargetsToAnnounce(cwd, [absPath])
+  ]);
   const observedAt = Date.now();
-  const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason } = await collectDiagnosticsForFile(absPath, lspService, cwd, waitMs, serverScope);
+  const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason, primaryUnavailable } = await collectDiagnosticsForFile(absPath, lspService, cwd, waitMs, serverScope, excludeServerIds);
   if (tooLargeReason !== void 0) {
     return {
       content: [{ type: "text", text: tooLargeReason }],
@@ -17742,7 +18242,7 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   let confirmation;
   if (diagnosticsUnsupportedServerIds.length > 0) {
     confirmation = void 0;
-  } else if (skipReason !== void 0) {
+  } else if (skipReason !== void 0 || primaryUnavailable !== void 0) {
     confirmation = "unconfirmed";
   } else if (timedOut) {
     if (applySeverityFilter(rawDiags, severity).length === 0) {
@@ -17776,12 +18276,12 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   const truncated = total > MAX_DIAGNOSTICS;
   const limited = truncated ? filtered.slice(0, MAX_DIAGNOSTICS) : filtered;
   const unconfirmed = confirmation === "unconfirmed";
-  const verdict = reconcileWidgetFromLspResult(absPath, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch, observedAt);
+  const verdict = reconcileWidgetFromLspResult(absPath, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch, observedAt, primaryUnavailable !== void 0);
   if (verdict.confirmed && !verdict.blocking) {
     onConfirmedNoBlockers?.({
       filePath: absPath,
       writeIndex,
-      coveredSources: coveredSourcesForCheck(absPath, serverScope, unconfirmedServerIds),
+      coveredSources: coveredSourcesForCheck(absPath, serverScope, unconfirmedServerIds, excludeServerIds),
       cwd
     });
   }
@@ -17789,6 +18289,8 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   const primaryDiags = limited.filter((d) => d.serverId === primaryId);
   const auxiliaryDiags = limited.filter((d) => d.serverId !== primaryId);
   const primaryLine = (() => {
+    if (primaryUnavailable !== void 0)
+      return primaryUnavailable;
     if (diagnosticsUnsupportedServerIds.length > 0) {
       return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: navigation-only \u2014 diagnostics unsupported (no pull provider or publish evidence).`;
     }
@@ -17808,12 +18310,14 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   })();
   const coverageLine = unconfirmedServerIds.length > 0 ? `Auxiliary coverage INCOMPLETE \u2014 ${[...unconfirmedServerIds].join(", ")} did not answer within the wait budget, so ${unconfirmedServerIds.length === 1 ? "its findings are" : "their findings are"} NOT included here. This is not a clean bill of health for ${unconfirmedServerIds.length === 1 ? "that scanner" : "those scanners"}; re-check after the next edit. waitMs can extend an ordinary wait, but it cannot override a session-demoted scanner.` : void 0;
   const suppressedLine = dispositionSuppressedLine(policy.suppressed);
+  const switchedOffServerIds = serverScope === "all" && excludeServerIds && excludeServerIds.size > 0 ? getServersForFileWithConfig(absPath).flatMap((server) => excludeServerIds.has(server.id) ? [server.id] : []) : [];
+  const noAuxiliaryLine = switchedOffServerIds.length > 0 ? `No auxiliary findings. Switched off, not run: ${switchedOffServerIds.join(", ")}.` : "No auxiliary findings.";
   let text;
   if (total === 0) {
     text = [
       primaryLine,
       "",
-      unavailable ?? "No auxiliary findings.",
+      unavailable ?? noAuxiliaryLine,
       ...coverageLine ? [coverageLine] : [],
       ...suppressedLine ? [suppressedLine] : []
     ].join("\n");
@@ -17865,6 +18369,7 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
       timedOut: unconfirmed ? timedOut : void 0,
       navigationOnlyFiles: diagnosticsUnsupportedServerIds.length > 0 ? 1 : void 0,
       ...skipReason !== void 0 && { skipReason },
+      ...primaryUnavailable !== void 0 && { primaryUnavailable },
       ...rootFallback && {
         rootFallbackReason: describeRootFallback(rootFallback)
       },
@@ -17882,6 +18387,8 @@ function tallyConfirmation(results) {
   let clean = 0;
   let unconfirmed = 0;
   let timedOut = 0;
+  let primaryUnavailable = 0;
+  const primaryUnavailableCauses = [];
   const rootFallbackReasons = /* @__PURE__ */ new Set();
   let navigationOnly = 0;
   let tooLarge = 0;
@@ -17900,6 +18407,11 @@ function tallyConfirmation(results) {
       unconfirmed += 1;
       if (result.timedOut)
         timedOut += 1;
+      if (result.primaryUnavailable !== void 0) {
+        primaryUnavailable += 1;
+        if (result.primaryUnavailableCause !== void 0)
+          primaryUnavailableCauses.push(result.primaryUnavailableCause);
+      }
       if (result.rootFallback) {
         rootFallbackReasons.add(describeRootFallback(result.rootFallback));
       }
@@ -17911,6 +18423,10 @@ function tallyConfirmation(results) {
     clean,
     unconfirmed,
     timedOut,
+    primaryUnavailable: {
+      count: primaryUnavailable,
+      cause: combinePrimaryUnavailableCauses(primaryUnavailableCauses)
+    },
     rootFallbackReasons: [...rootFallbackReasons],
     navigationOnly,
     tooLarge
@@ -17923,6 +18439,9 @@ function classifyBatchFileOutcome(result) {
     return "too_large";
   if (result.diagnosticsUnsupported)
     return "unsupported";
+  if (result.noClientAnswered && result.primaryUnavailable !== void 0) {
+    return "unavailable";
+  }
   if (result.timedOut || result.confirmation === "unconfirmed") {
     return "inconclusive";
   }
@@ -17945,7 +18464,24 @@ function inconclusiveBatchResult(file, reason) {
     inconclusiveReason: reason
   };
 }
-function unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons = []) {
+function batchOutcomeReason(result) {
+  return result.tooLargeReason ?? // #4322: a file only auxiliaries answered for names its language server.
+  result.primaryUnavailable ?? result.inconclusiveReason ?? result.error ?? result.unavailable;
+}
+function auxiliaryOnlyFindingsLine(results) {
+  const auxiliaryOnly = results.filter((result) => result.diagnostics.length > 0 && result.primaryUnavailable !== void 0 && result.noClientAnswered === void 0);
+  const count = auxiliaryOnly.length;
+  if (count === 0)
+    return void 0;
+  const cause = combinePrimaryUnavailableCauses(auxiliaryOnly.flatMap((result) => result.primaryUnavailableCause ?? [])) ?? "unstarted";
+  return `${count} file${count === 1 ? "" : "s"} with auxiliary findings only: no language server answered (${PRIMARY_UNAVAILABLE_CAUSE[cause]}), so the language itself was not checked.`;
+}
+function unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons = [], primaryUnavailable = { count: 0, cause: void 0 }) {
+  if (primaryUnavailable.count > 0) {
+    const head = `${primaryUnavailable.count} with no language server answer (${PRIMARY_UNAVAILABLE_CAUSE[primaryUnavailable.cause ?? "unstarted"]})`;
+    const rest = unconfirmed - primaryUnavailable.count;
+    return rest > 0 ? `${head}; the other ${rest}: ${unconfirmedReasonClause(rest, timedOut, rootFallbackReasons)}` : `${head}.`;
+  }
   if (rootFallbackReasons.length > 0) {
     return `${rootFallbackReasons.join("; ")} (${unconfirmed} unconfirmed in all).`;
   }
@@ -17961,7 +18497,8 @@ function unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons = []
 async function collectBatchDiagnostics(files, severity, lspService, options) {
   const resolvedCwd = options.cwd ?? process.cwd();
   const cacheCtx = createWorkspaceDiagnosticsCacheContext(resolvedCwd);
-  const scopeKey = buildScopeKey(options.serverScope ?? "all");
+  const serverScope = options.serverScope ?? "all";
+  const scopeKey = buildProbeScopeKey(serverScope, options.excludeServerIds);
   const resultsByIndex = /* @__PURE__ */ new Map();
   let completed = 0;
   const pendingIndices = /* @__PURE__ */ new Map();
@@ -17972,6 +18509,11 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     else
       pendingIndices.set(file, [index]);
   });
+  lspService.announceCreatedFiles([
+    ...files,
+    ...goPackageFilesToAnnounce(files),
+    ...await importTargetsToAnnounce(resolvedCwd, files.filter((file) => !cacheCtx.servesClean(file, scopeKey)), (file, scope) => cacheCtx.noteImportScope(file, scope))
+  ]);
   const groups = groupFilesByPrimaryServer(files);
   await runPerServerGroups(groups, options.concurrency, async (group) => {
     if (options.signal?.aborted)
@@ -17986,7 +18528,7 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     }
     await mapWithConcurrency(group.files, 1, async (file) => {
       const index = pendingIndices.get(file).shift();
-      const work = collectFileDiagnosticResult(file, severity, lspService, options.waitMs, options.nextWriteIndex, options.serverScope, cacheCtx, scopeKey, resolvedCwd, options.onConfirmedNoBlockers);
+      const work = collectFileDiagnosticResult(file, severity, lspService, options.waitMs, options.nextWriteIndex, options.serverScope, cacheCtx, scopeKey, resolvedCwd, options.onConfirmedNoBlockers, options.excludeServerIds);
       const bounded2 = withDeadline(work, {
         ms: batchFileDeadlineMs(),
         onTimeout: "undefined",
@@ -18017,7 +18559,7 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
   const total = allDiags.length;
   const truncated = total > MAX_DIAGNOSTICS;
   const display = truncated ? allDiags.slice(0, MAX_DIAGNOSTICS) : allDiags;
-  const { clean, unconfirmed, timedOut, rootFallbackReasons } = tallyConfirmation(results);
+  const { clean, unconfirmed, timedOut, primaryUnavailable, rootFallbackReasons } = tallyConfirmation(results);
   for (const result of results) {
     result.outcome = classifyBatchFileOutcome(result);
   }
@@ -18049,6 +18591,7 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     unconfirmed,
     timedOut,
     rootFallbackReasons,
+    primaryUnavailable,
     outcomeCounts,
     incompleteFiles: Math.max(0, files.length - results.length)
   };
@@ -18058,7 +18601,7 @@ async function expandPathsToFiles(cwd, rawPaths) {
   const directories = [];
   const seenFileKeys = /* @__PURE__ */ new Set();
   for (const entry of rawPaths) {
-    const abs = normalizeMapKey(path36.resolve(cwd, entry));
+    const abs = normalizeMapKey(resolveHostToolPath(entry, cwd));
     let stat;
     try {
       stat = fs22.statSync(abs);
@@ -18103,7 +18646,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options,
       details: { mode: "batch", severity, filesChecked: 0 }
     };
   }
-  const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, rootFallbackReasons, outcomeCounts, incompleteFiles } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
+  const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, rootFallbackReasons, primaryUnavailable, outcomeCounts, incompleteFiles } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
   const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
   const dispositionSuppressed = results.reduce((sum, result) => sum + (result.dispositionSuppressed ?? 0), 0);
   const lines = [
@@ -18129,7 +18672,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options,
   const outcomeDetails = results.map((result) => ({
     file: result.file,
     outcome: result.outcome,
-    reason: result.tooLargeReason ?? result.inconclusiveReason ?? result.error ?? result.unavailable
+    reason: batchOutcomeReason(result)
   }));
   const tooLargeLines = renderBatchOutcomeLines(outcomeDetails);
   if (tooLargeLines.length > 0) {
@@ -18139,8 +18682,11 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options,
     lines.push("", "LSP health warnings:", ...lspHealthWarnings.slice(0, 10));
   }
   if (unconfirmed > 0) {
-    lines.push("", `${clean} file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)} NOT the same as 0 diagnostics.`);
+    lines.push("", `${clean} file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons, primaryUnavailable)} NOT the same as 0 diagnostics.`);
   }
+  const auxiliaryOnlyLine = auxiliaryOnlyFindingsLine(results);
+  if (auxiliaryOnlyLine)
+    lines.push("", auxiliaryOnlyLine);
   if (display.length === 0) {
     if (unconfirmed === 0 && outcomeCounts.clean === results.length) {
       lines.push("", "No diagnostics found.");
@@ -18185,7 +18731,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options,
       outcomes: results.map((result) => ({
         file: result.file,
         outcome: result.outcome,
-        reason: result.tooLargeReason ?? result.inconclusiveReason ?? result.error ?? result.unavailable,
+        reason: batchOutcomeReason(result),
         primaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.serverId === result.primaryServerId).length,
         auxiliaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.serverId !== result.primaryServerId).length
       })),
@@ -18253,26 +18799,30 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       }
     };
   }
-  const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, rootFallbackReasons, outcomeCounts } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
+  const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, rootFallbackReasons, primaryUnavailable, outcomeCounts } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
   const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
   const dispositionSuppressed = results.reduce((sum, result) => sum + (result.dispositionSuppressed ?? 0), 0);
   const suppressedLine = dispositionSuppressedLine(dispositionSuppressed);
   const outcomeDetails = results.map((result) => ({
     file: result.file,
     outcome: result.outcome,
-    reason: result.tooLargeReason ?? result.inconclusiveReason ?? result.error ?? result.unavailable
+    reason: batchOutcomeReason(result)
   }));
-  const tooLargeLines = renderBatchOutcomeLines(outcomeDetails, (file) => path36.relative(absPath, file));
+  const auxiliaryOnlyLine = auxiliaryOnlyFindingsLine(results);
+  const tooLargeLines = renderBatchOutcomeLines(outcomeDetails, (file) => path37.relative(absPath, file));
   let text;
   if (total === 0) {
-    const cleanLine = unconfirmed > 0 ? `${clean} clean \xB7 ${unconfirmed} unconfirmed: ${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)} NOT the same as 0 diagnostics.` : "No diagnostics found.";
+    const cleanLine = unconfirmed > 0 ? `${clean} clean \xB7 ${unconfirmed} unconfirmed: ${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons, primaryUnavailable)} NOT the same as 0 diagnostics.` : "No diagnostics found.";
     text = [
       `Directory: ${absPath}`,
       `Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${MAX_FILES})` : ""}`,
       ...lspHealthWarnings.length > 0 ? [
         "LSP unavailable for one or more files:",
         ...lspHealthWarnings.slice(0, 10)
-      ] : unconfirmed > 0 || outcomeCounts.clean === filesToProcess.length ? [cleanLine] : [],
+      ] : [],
+      // #4403: an unconfirmed file says why even beside a health warning,
+      // which names what was missing but not that the file is unconfirmed.
+      ...unconfirmed > 0 || lspHealthWarnings.length === 0 && outcomeCounts.clean === filesToProcess.length ? [cleanLine] : [],
       ...tooLargeLines.length > 0 ? ["", "Files too large for LSP diagnostics:", ...tooLargeLines] : [],
       ...suppressedLine ? ["", suppressedLine] : []
     ].join("\n");
@@ -18288,13 +18838,14 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       // whole found diagnostics elsewhere.
       ...unconfirmed > 0 ? [
         "",
-        `${clean} other file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)
+        `${clean} other file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons, primaryUnavailable)
       ] : [],
+      ...auxiliaryOnlyLine ? ["", auxiliaryOnlyLine] : [],
       ""
     ];
     const toRelative = (d) => ({
       ...d,
-      file: path36.relative(absPath, d.file)
+      file: path37.relative(absPath, d.file)
     });
     if (primaryDisplay.length > 0) {
       lines.push(`Primary findings (${primaryDisplay.length}):`);
@@ -18325,7 +18876,7 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       filesScanned: filesToProcess.length,
       capped: wasCapped,
       diagnostics: display.map((d) => ({
-        file: path36.relative(absPath, d.file),
+        file: path37.relative(absPath, d.file),
         line: d.line,
         character: d.character,
         severity: d.severity,
@@ -18351,11 +18902,6 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     }
   };
 }
-function dispositionSuppressedLine(suppressed) {
-  if (suppressed <= 0)
-    return void 0;
-  return `suppressed by disposition: ${suppressed} finding(s) dropped from this result because they're marked false-positive/won't-fix, disabled by \`.pi-lens.json\` rule policy, or suppressed by an inline \`pi-lens-ignore\` comment. Not a clean verdict for those locations \u2014 they were found, then intentionally hidden.`;
-}
 function applySeverityFilter(diags, severity) {
   if (severity === "all")
     return diags;
@@ -18422,7 +18968,7 @@ async function findFullScanBindingMismatches(results) {
   return mismatched;
 }
 function createLensDiagnosticsTool(cacheManager2, getCwd, getLspService = getLSPService, flushPending = async () => {
-}, nextWriteIndex, captureLspStatusRepaint, getRuntime, isLensGuardEnabled2 = () => true) {
+}, nextWriteIndex, captureLspStatusRepaint, getRuntime, isLensGuardEnabled2 = () => true, getFlag) {
   const lspProbe = createLspDiagnosticsTool(nextWriteIndex, (info) => {
     const runtime = getRuntime?.();
     if (!runtime)
@@ -18443,7 +18989,7 @@ function createLensDiagnosticsTool(cacheManager2, getCwd, getLspService = getLSP
         message: `inline_blocker: retired for ${info.filePath}`
       });
     }
-  }, getLspService);
+  }, getLspService, getFlag);
   return {
     name: "lens_diagnostics",
     label: "Project Diagnostics",
@@ -18455,7 +19001,7 @@ function createLensDiagnosticsTool(cacheManager2, getCwd, getLspService = getLSP
         const files2 = details.filesChecked ?? details.filesScanned ?? 0;
         const noun = count === 1 ? "diagnostic" : "diagnostics";
         const filePath = typeof details?.filePath === "string" ? details.filePath : Array.isArray(args?.paths) && args.paths.length === 1 && typeof args.paths[0] === "string" ? args.paths[0] : void 0;
-        const singleFile = (details?.mode === "file" || files2 === 1) && typeof filePath === "string" ? ` ${path37.basename(filePath)}` : "";
+        const singleFile = (details?.mode === "file" || files2 === 1) && typeof filePath === "string" ? ` ${path38.basename(filePath)}` : "";
         const scope = files2 > 1 ? ` across ${files2} files` : singleFile;
         if (isError)
           return `lens_diagnostics lsp \u2014 ${text.split("\n")[0] ?? "error"}`;
@@ -18473,7 +19019,10 @@ function createLensDiagnosticsTool(cacheManager2, getCwd, getLspService = getLSP
         if ((details.incompleteFiles ?? 0) > 0)
           return `lens_diagnostics${scope} \u2014 incomplete (${details.incompleteFiles} files not confirmed)`;
         if (count === 0 && details.unconfirmed)
-          return details.timedOut ? `lens_diagnostics${scope} \u2014 timed out (result may be incomplete)` : `lens_diagnostics${scope} \u2014 unconfirmed (server cannot confirm clean)`;
+          return details.timedOut ? `lens_diagnostics${scope} \u2014 timed out (result may be incomplete)` : (
+            // #4322: no language server answered; it is not a silent server.
+            details.primaryUnavailable !== void 0 ? `lens_diagnostics${scope} \u2014 unconfirmed (no language server answered)` : `lens_diagnostics${scope} \u2014 unconfirmed (server cannot confirm clean)`
+          );
         return `lens_diagnostics${scope} \u2014 ${count} ${noun}`;
       }
       const scanning = scanningSummaryLine(details, text);
@@ -18583,6 +19132,7 @@ function createLensDiagnosticsTool(cacheManager2, getCwd, getLspService = getLSP
         const hasExplicitPaths = Array.isArray(lspParams.paths) && lspParams.paths.length > 0;
         if (scope === "workspace" && !hasExplicitPath && !hasExplicitPaths) {
           lspParams.path = cwd;
+          lspParams.pathAlreadyResolved = true;
         }
         const lspStart = Date.now();
         const result = await lspProbe.execute(_toolCallId, lspParams, signal, onUpdate, ctx.signal ? { cwd, signal: ctx.signal } : { cwd });
@@ -18701,7 +19251,7 @@ function appendProjectDiagnosticsDeltaLines(groups, cwd, report, severity, inclu
   const diagnostics = [...gated.live, ...gated.stale];
   const byFile = /* @__PURE__ */ new Map();
   for (const diagnostic of diagnostics) {
-    const filePath = path37.resolve(diagnostic.filePath);
+    const filePath = path38.resolve(diagnostic.filePath);
     const bucket = byFile.get(filePath) ?? [];
     bucket.push(diagnostic);
     byFile.set(filePath, bucket);
@@ -18828,7 +19378,7 @@ function applyDeltaFreshnessGate(files, cwd, generatedAt) {
   })).filter((file) => file.warnings.length > 0);
 }
 function getDeltaFileGroup(groups, cwd, filePath) {
-  const rel = path37.relative(cwd, filePath);
+  const rel = path38.relative(cwd, filePath);
   let group = groups.get(rel);
   if (!group) {
     group = {
@@ -18952,7 +19502,7 @@ Summary (turn delta): ${aw} actionable warning${aw === 1 ? "" : "s"} \xB7 ${cq}
 function createCurrentIgnoreFilter(cwd) {
   try {
     const matcher = getProjectIgnoreMatcher(cwd);
-    return (filePath) => !matcher.isIgnored(path37.resolve(filePath), false);
+    return (filePath) => !matcher.isIgnored(path38.resolve(filePath), false);
   } catch {
     return () => true;
   }
@@ -18963,7 +19513,7 @@ function resolvePathsScope(cwd, rawPaths) {
   if (rawPaths.length > MAX_PATHS_ENTRIES) {
     throw new Error(`paths has ${rawPaths.length} entries, over the ${MAX_PATHS_ENTRIES} cap. Narrow the list or omit paths to scan without a restriction.`);
   }
-  const entries = rawPaths.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => path37.resolve(path37.isAbsolute(entry) ? entry : path37.resolve(cwd, entry)));
+  const entries = rawPaths.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => resolveHostToolPath(entry, cwd));
   const missing = [];
   const fileEntries = [];
   const existingEntries = [];
@@ -18986,9 +19536,9 @@ function resolvePathsScope(cwd, rawPaths) {
   }
   const fileKeys = new Set(fileEntries.map((f) => normalizeFilePath(f)));
   const dirPrefixes = dirEntries.map((d) => normalizeFilePath(d));
-  const includeExplicitFile = (filePath) => fileKeys.has(normalizeFilePath(path37.resolve(filePath)));
+  const includeExplicitFile = (filePath) => fileKeys.has(normalizeFilePath(path38.resolve(filePath)));
   const includeFile = (filePath) => {
-    const key = normalizeFilePath(path37.resolve(filePath));
+    const key = normalizeFilePath(path38.resolve(filePath));
     if (fileKeys.has(key))
       return true;
     return dirPrefixes.some((prefix) => key === prefix || key.startsWith(`${prefix}/`));
@@ -19009,7 +19559,7 @@ function pathsScopeCacheOnlyNote(scope) {
 function pathsScopeMissingNote(scope) {
   if (!scope || scope.missing.length === 0)
     return "";
-  const shown2 = scope.missing.slice(0, 10).map((p) => path37.basename(p));
+  const shown2 = scope.missing.slice(0, 10).map((p) => path38.basename(p));
   const more = scope.missing.length > shown2.length ? ` (+${scope.missing.length - shown2.length} more)` : "";
   return `
 
@@ -19140,7 +19690,7 @@ function projectDiagnosticToWidget(diagnostic, filePath) {
 }
 function diagnosticDedupKey(filePath, diagnostic) {
   const ruleId = normalizeRuleId(diagnostic.rule ?? diagnostic.tool ?? "");
-  return [path37.resolve(filePath), diagnostic.line ?? "?", ruleId].join(":");
+  return [path38.resolve(filePath), diagnostic.line ?? "?", ruleId].join(":");
 }
 function runnerIdOf(diagnostic) {
   return diagnostic.tool ?? diagnostic.rule?.split(":", 1)[0] ?? "";
@@ -19154,8 +19704,8 @@ function runnerRetirementDecision(diagnostic, filePath, authoritativeRunnerIds,
   const realFilePath = realpathOrResolve(filePath);
   for (const entry of coverage) {
     const root = entry.root;
-    const relative9 = path37.relative(root, realFilePath);
-    const underRoot = relative9 === "" || !relative9.startsWith("..") && !path37.isAbsolute(relative9);
+    const relative9 = path38.relative(root, realFilePath);
+    const underRoot = relative9 === "" || !relative9.startsWith("..") && !path38.isAbsolute(relative9);
     if (!underRoot)
       continue;
     if (entry.files.has(realFilePath)) {
@@ -19205,7 +19755,11 @@ var UNCONFIRMED_REASON_SENTENCE = {
   binding_mismatch: "the file changed on disk since this result was computed",
   // #2052: no server was asked. Say WHY and say it is permanent for this
   // path, so the reader does not read an empty result as "clean" or retry it.
-  outside_project_root: "the file is outside every initialized session project root, so no language server was asked"
+  outside_project_root: "the file is outside every initialized session project root, so no language server was asked",
+  // #4403: the per-file note's wording, one sentence per cause.
+  primary_unavailable: `no primary language server answered (${PRIMARY_UNAVAILABLE_CAUSE.unstarted})`,
+  primary_disabled: `no primary language server answered (${PRIMARY_UNAVAILABLE_CAUSE.disabled})`,
+  primary_disabled_fallback: `no primary language server answered (${PRIMARY_UNAVAILABLE_CAUSE.disabledFallback})`
 };
 var UNCONFIRMED_REASON_COUNT_LABEL = {
   budget: "timed out",
@@ -19214,7 +19768,10 @@ var UNCONFIRMED_REASON_COUNT_LABEL = {
   service_destroyed: "service reset mid-sweep",
   error: "errored",
   binding_mismatch: "stale binding",
-  outside_project_root: "outside project root"
+  outside_project_root: "outside project root",
+  primary_unavailable: "no primary started",
+  primary_disabled: "primary disabled in config",
+  primary_disabled_fallback: "primary disabled, fallback did not answer"
 };
 function classifyUnconfirmedReason(result, mismatched) {
   if (mismatched.has(result))
@@ -19279,7 +19836,7 @@ function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projec
   const byFile = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
   for (const summary of widgetSummaries) {
-    const filePath = path37.resolve(summary.filePath);
+    const filePath = path38.resolve(summary.filePath);
     if (authoritativeLspFiles?.has(filePath))
       continue;
     const retained = summary.diagnostics ?? [];
@@ -19307,7 +19864,7 @@ function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projec
     byFile.set(filePath, summarizeDiagnostics(filePath, diagnostics, existing?.hasFinalSnapshot ?? true));
   };
   for (const result of lspResults) {
-    const filePath = path37.resolve(result.filePath);
+    const filePath = path38.resolve(result.filePath);
     for (const diagnostic of result.diagnostics ?? []) {
       addDiagnostic(filePath, {
         ...lspDiagnosticToWidget(diagnostic),
@@ -19327,19 +19884,19 @@ function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projec
     });
   }
   for (const diagnostic of projectSnapshot?.diagnostics ?? []) {
-    addDiagnostic(path37.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
+    addDiagnostic(path38.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
   }
   for (const diagnostic of deltaDiagnostics) {
     const widget = projectDiagnosticToWidget(diagnostic, diagnostic.filePath);
     const observedAt = widget.observedAt ?? deltaObservedAt;
-    addDiagnostic(path37.resolve(diagnostic.filePath), {
+    addDiagnostic(path38.resolve(diagnostic.filePath), {
       ...widget,
       ...observedAt !== void 0 && { observedAt }
     });
   }
   return [...byFile.values()];
 }
-async function applyInlineSuppressionsToSummaries(summaries, cwd, policyMap) {
+async function applyInlineSuppressionsToSummaries(summaries, cwd, policyMap, dispositionDropped) {
   return Promise.all(summaries.map(async (summary) => {
     if (!summary.diagnostics.length)
       return summary;
@@ -19353,12 +19910,19 @@ async function applyInlineSuppressionsToSummaries(summaries, cwd, policyMap) {
       });
       return policyKept2.length === summary.diagnostics.length ? summary : summarizeDiagnostics(summary.filePath, policyKept2, summary.hasFinalSnapshot);
     }
-    const { kept: policyKept } = applyFindingPolicy(summary.diagnostics, {
+    const { kept: policyKept, inlineKept, disposed } = applyFindingPolicy(summary.diagnostics, {
       cwd,
       filePath: summary.filePath,
       content,
       policyMap
     });
+    if (disposed.length < inlineKept.length) {
+      const survivors = new Set(disposed);
+      for (const d of inlineKept) {
+        if (!survivors.has(d))
+          dispositionDropped.push(d);
+      }
+    }
     for (const d of policyKept) {
       const { weak } = anchorsForDiagnostic(cwd, summary.filePath, d, content);
       if (getDisposition(cwd, weak)?.disposition === "flagged") {
@@ -19516,13 +20080,21 @@ async function formatFullMode(cwd, severity, lspService, cacheManager2, options
   const unconfirmedLspResults = lspResults.filter((result2) => result2.timedOut || result2.error || mismatchedLspResults.has(result2));
   const authoritativeLspFiles = /* @__PURE__ */ new Set();
   const unreconciledFiles = /* @__PURE__ */ new Set();
+  const policyMap = loadProjectRulePolicyMap(cwd);
   for (const result2 of fullyCoveredLspResults) {
     try {
       const diagnostics = convertLspDiagnostics(result2.diagnostics, result2.filePath, { scanOrigin: "lens_diagnostics_full" });
       const retagged = retagAuxiliaryDiagnostics(diagnostics, result2.diagnostics, "", { cwd, fileRole: detectFileRole(result2.filePath) });
+      const content = readFileContent(result2.filePath);
+      const { kept: policyKept } = applyFindingPolicy(retagged, {
+        cwd,
+        filePath: result2.filePath,
+        content: content ?? "",
+        policyMap
+      });
       const retired = reconcileScanDiagnostics(
         result2.filePath,
-        retagged,
+        policyKept,
         true,
         // The service reserves this token when the file enters the scan. The
         // fallback preserves compatibility with older test doubles/services.
@@ -19535,32 +20107,31 @@ async function formatFullMode(cwd, severity, lspService, cacheManager2, options
         result2.observedAt
       );
       if (retired === true) {
-        authoritativeLspFiles.add(path37.resolve(result2.filePath));
+        authoritativeLspFiles.add(path38.resolve(result2.filePath));
       } else {
-        unreconciledFiles.add(path37.resolve(result2.filePath));
+        unreconciledFiles.add(path38.resolve(result2.filePath));
         recordDegradationOnce({
           kind: "diagnostic-retained-unreconciled",
-          subject: `${path37.resolve(result2.filePath)}:lsp`,
+          subject: `${path38.resolve(result2.filePath)}:lsp`,
           reason: "confirmed diagnostic result could not replace retained widget state"
         });
       }
     } catch {
-      unreconciledFiles.add(path37.resolve(result2.filePath));
+      unreconciledFiles.add(path38.resolve(result2.filePath));
       recordDegradationOnce({
         kind: "diagnostic-retained-unreconciled",
-        subject: `${path37.resolve(result2.filePath)}:lsp`,
+        subject: `${path38.resolve(result2.filePath)}:lsp`,
         reason: "confirmed diagnostic result failed during widget reconciliation"
       });
     }
   }
-  const policyMap = loadProjectRulePolicyMap(cwd);
   const scannedSnapshot = filterProjectDiagnosticsSnapshot(rawProjectSnapshot, includeFile);
   const authoritativeRunnerIds = new Set(extracted.analyzed ?? []);
   const authoritativeRunnerCoverage = extracted.authoritativeCoverage ?? [];
   const foldedProjectSnapshot = foldExtraDiagnosticsIntoSnapshot(scannedSnapshot, extracted.diagnostics.filter((d) => includeFile(d.filePath)), extracted.runners, cwd);
   const projectSnapshot = applyProjectRulePolicy(foldedProjectSnapshot, policyMap, cwd);
   const projectDelta = applyProjectRulePolicy(filterProjectDiagnosticsDeltaReport(loadProjectDiagnosticsDeltaReport(cwd), includeFile), policyMap, cwd);
-  const authoritativeRetiredCount = getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath) && authoritativeLspFiles.has(path37.resolve(summary.filePath)) && (summary.diagnostics?.length ?? 0) > 0).length;
+  const authoritativeRetiredCount = getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath) && authoritativeLspFiles.has(path38.resolve(summary.filePath)) && (summary.diagnostics?.length ?? 0) > 0).length;
   if (authoritativeRetiredCount > 0) {
     logLatency({
       type: "phase",
@@ -19613,9 +20184,10 @@ async function formatFullMode(cwd, severity, lspService, cacheManager2, options
       }
     });
   }
-  let summaries = await applyInlineSuppressionsToSummaries(mergeDiagnosticsWithWidgetSummaries(getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath)), confirmedLspResults, projectSnapshot, projectDelta, authoritativeLspFiles, authoritativeRunnerIds, authoritativeRunnerCoverage), cwd, policyMap);
+  const dispositionDropped = [];
+  let summaries = await applyInlineSuppressionsToSummaries(mergeDiagnosticsWithWidgetSummaries(getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath)), confirmedLspResults, projectSnapshot, projectDelta, authoritativeLspFiles, authoritativeRunnerIds, authoritativeRunnerCoverage), cwd, policyMap, dispositionDropped);
   if (unreconciledFiles.size > 0) {
-    summaries = summaries.map((summary) => unreconciledFiles.has(path37.resolve(summary.filePath)) ? summarizeDiagnostics(summary.filePath, markUnreconciledFindings(summary.diagnostics), summary.hasFinalSnapshot) : summary);
+    summaries = summaries.map((summary) => unreconciledFiles.has(path38.resolve(summary.filePath)) ? summarizeDiagnostics(summary.filePath, markUnreconciledFindings(summary.diagnostics), summary.hasFinalSnapshot) : summary);
   }
   const parsedProjectScanObservedAt = projectSnapshot?.scannedAt ? Date.parse(projectSnapshot.scannedAt) : void 0;
   const projectScanObservedAt = parsedProjectScanObservedAt !== void 0 && Number.isFinite(parsedProjectScanObservedAt) ? parsedProjectScanObservedAt : void 0;
@@ -19637,14 +20209,26 @@ async function formatFullMode(cwd, severity, lspService, cacheManager2, options
       sources: projectDelta.sources,
       turnIndex: projectDelta.turnIndex
     }
-  }, 0, pathsScope);
+  }, 0, pathsScope, 0, {
+    dropped: dispositionDropped,
+    // #1617: the #1616 suppressed-bucket rule applied to the analyzers —
+    // a finding marked false-positive/won't-fix drops out of
+    // `diagnostics` (fresh-fetch.ts's `record()`), and the drop stays
+    // visible as a count. Review-round F4 (#1625): per-lane attribution
+    // ("gitleaks 2, knip 1") says WHICH analyzer's marks are doing the
+    // suppressing. A lane that's 100% suppressed still won't appear in
+    // `runners`/`cold` as distinct from "ran clean" — #1623's territory.
+    analyzers: extracted.dispositionSuppressed ?? 0,
+    analyzersByLane: extracted.dispositionSuppressedByLane ?? {}
+  });
   const missingNote = pathsScopeMissingNote(pathsScope);
   const unconfirmedByReason = tallyUnconfirmedReasons(unconfirmedLspResults, mismatchedLspResults);
   const lspServerBreakdown = tallyLspByPrimaryServer(confirmedLspResults, unconfirmedLspResults);
   const serverBreakdownClause = lspServerBreakdown.size > 1 ? ` \u2014 by server: ${formatLspServerBreakdown(lspServerBreakdown)}.` : "";
+  const retryClause = [...unconfirmedByReason.keys()].every((reason) => reason === "primary_disabled") ? "" : "; re-run mode=full to retry them";
   const unconfirmedLspNote = unconfirmedLspResults.length > 0 ? `
 
-\u26A0 LSP sweep: ${confirmedLspResults.length} file(s) confirmed via LSP, ${unconfirmedLspResults.length} unconfirmed (${formatUnconfirmedReasonClause(unconfirmedByReason)})${serverBreakdownClause} \u2014 NOT the same as 0 diagnostics for: ${unconfirmedLspResults.slice(0, 20).map((result2) => result2.filePath).join(", ")}${unconfirmedLspResults.length > 20 ? ", \u2026" : ""}. These files' LSP contribution is excluded from this result; re-run mode=full to retry them (they may still show findings above from cached/project-runner state).` : "";
+\u26A0 LSP sweep: ${confirmedLspResults.length} file(s) confirmed via LSP, ${unconfirmedLspResults.length} unconfirmed (${formatUnconfirmedReasonClause(unconfirmedByReason)})${serverBreakdownClause} \u2014 NOT the same as 0 diagnostics for: ${unconfirmedLspResults.slice(0, 20).map((result2) => result2.filePath).join(", ")}${unconfirmedLspResults.length > 20 ? ", \u2026" : ""}. These files' LSP contribution is excluded from this result${retryClause} (they may still show findings above from cached/project-runner state).` : "";
   const uncoveredScannerIds = [
     ...new Set(partiallyCoveredLspResults.flatMap((result2) => result2.unconfirmedServerIds ?? []))
   ].sort((a, b) => Number(a > b) - Number(a < b));
@@ -19692,10 +20276,6 @@ test-runner coverage is edit-scoped, NOT a full-project run: its findings only r
   const failedNote = failedAnalyzers.length > 0 ? `
 
 failed (ran, but no trustworthy result): ${failedAnalyzers.map(({ id, summary }) => `${id} \u2014 ${summary}`).join(", ")}. These analyzers were not cached and will be retried; absence of their findings is NOT a clean verdict.` : "";
-  const dispositionSuppressedByLaneText = Object.entries(extracted.dispositionSuppressedByLane ?? {}).map(([id, count]) => `${id} ${count}`).join(", ");
-  const dispositionSuppressedNote = (extracted.dispositionSuppressed ?? 0) > 0 ? `
-
-suppressed by disposition: ${extracted.dispositionSuppressed} finding(s) dropped from this result because they're marked false-positive or won't-fix (${dispositionSuppressedByLaneText}). Not a clean verdict for those locations \u2014 they were found, then intentionally hidden.` : "";
   const walkUnsafeRoot = explicitFiles === void 0 && isAtOrAboveHomeDir(cwd);
   const walkUnsafeRootNote = walkUnsafeRoot ? `
 
@@ -19743,7 +20323,9 @@ served from cache this call (not re-run): ${cachedAgeEntries.map(([id, ms]) => `
       coldReasons: extracted.coldReasons ?? {},
       failedAnalyzers,
       analyzerTimingsMs: extracted.timings,
-      dispositionSuppressed: extracted.dispositionSuppressed ?? 0,
+      // #1634: every lane the call filtered — the sweep's and the
+      // analyzers' — in one count, the one the text states.
+      dispositionSuppressed: result.details.dispositionSuppressed ?? 0,
       dispositionSuppressedByLane: extracted.dispositionSuppressedByLane ?? {},
       // #1623: ms-old each cache-read-by-design lane's data was (today, only
       // test-runner) — lets a caller distinguish "just ran" from "served
@@ -19798,18 +20380,18 @@ served from cache this call (not re-run): ${cachedAgeEntries.map(([id, ms]) => `
       content: [
         {
           type: "text",
-          text: result.content[0].text + note + unconfirmedLspNote + auxiliaryCoverageNote + lspPrimaryVsAuxiliaryNote + partialNote + coldNote + testRunnerEditScopedNote + failedNote + dispositionSuppressedNote + walkUnsafeRootNote + scanTruncatedNote + generatedSkipNote + abortedNote + freshNote + cachedAgeNote + cheapScanStatusNote + missingNote
+          text: result.content[0].text + note + unconfirmedLspNote + auxiliaryCoverageNote + lspPrimaryVsAuxiliaryNote + partialNote + coldNote + testRunnerEditScopedNote + failedNote + walkUnsafeRootNote + scanTruncatedNote + generatedSkipNote + abortedNote + freshNote + cachedAgeNote + cheapScanStatusNote + missingNote
         }
       ],
       details: { ...resultWithCold.details, timedOut }
     };
   }
-  if (missingNote || coldNote || partialNote || testRunnerEditScopedNote || failedNote || dispositionSuppressedNote || walkUnsafeRootNote || scanTruncatedNote || generatedSkipNote || abortedNote || freshNote || cachedAgeNote || cheapScanStatusNote || unconfirmedLspNote || auxiliaryCoverageNote || lspPrimaryVsAuxiliaryNote) {
+  if (missingNote || coldNote || partialNote || testRunnerEditScopedNote || failedNote || walkUnsafeRootNote || scanTruncatedNote || generatedSkipNote || abortedNote || freshNote || cachedAgeNote || cheapScanStatusNote || unconfirmedLspNote || auxiliaryCoverageNote || lspPrimaryVsAuxiliaryNote) {
     return {
       content: [
         {
           type: "text",
-          text: result.content[0].text + unconfirmedLspNote + auxiliaryCoverageNote + lspPrimaryVsAuxiliaryNote + partialNote + coldNote + testRunnerEditScopedNote + failedNote + dispositionSuppressedNote + walkUnsafeRootNote + scanTruncatedNote + generatedSkipNote + abortedNote + freshNote + cachedAgeNote + cheapScanStatusNote + missingNote
+          text: result.content[0].text + unconfirmedLspNote + auxiliaryCoverageNote + lspPrimaryVsAuxiliaryNote + partialNote + coldNote + testRunnerEditScopedNote + failedNote + walkUnsafeRootNote + scanTruncatedNote + generatedSkipNote + abortedNote + freshNote + cachedAgeNote + cheapScanStatusNote + missingNote
         }
       ],
       details: resultWithCold.details
@@ -19825,12 +20407,21 @@ async function projectResolvedCwd(summary, cwd) {
     diagnostics: summary.diagnostics ?? []
   };
 }
-async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(), detailOverrides = { mode: "all" }, staleDropped = 0, pathsScope, dependencyDemoted = 0) {
+async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(), detailOverrides = { mode: "all" }, staleDropped = 0, pathsScope, dependencyDemoted = 0, fullModeDisposition = { dropped: [], analyzers: 0, analyzersByLane: {} }) {
   const footerCapped = summaries.reduce((n, s) => n + (s.diagnostics ?? []).filter((d) => d.footerRetired === true).length, 0);
   const staleNote = (staleDropped > 0 ? ` (${staleDropped} changed file${staleDropped === 1 ? "" : "s"} omitted as stale \u2014 use mode=full to rescan)` : "") + (dependencyDemoted > 0 ? ` (${dependencyDemoted} blocking finding${dependencyDemoted === 1 ? "" : "s"} demoted to [stale] \u2014 an imported file changed since; re-run to confirm)` : "") + (footerCapped > 0 ? ` (${footerCapped} demoted finding${footerCapped === 1 ? "" : "s"} capped after ${DEPENDENCY_DRIFT_MAX_DELIVERIES} unconfirmed deliveries \u2014 no longer shown in the pi-lens footer, still listed here; re-run to confirm)` : "");
   const isFullMode = detailOverrides.mode === "full";
   const includeFile = createScopedFileFilter(cwd, pathsScope);
   const policyMap = loadProjectRulePolicyMap(cwd);
+  const inScope = (rows) => rows.reduce((n, d) => n + (matchesSeverity(d, severity) ? 1 : 0), 0);
+  const sweepSuppressed = isFullMode ? inScope(fullModeDisposition.dropped) : 0;
+  const lanes = [];
+  for (const [id, count] of Object.entries(fullModeDisposition.analyzersByLane)) {
+    if (count > 0)
+      lanes.push(`${id} ${count}`);
+  }
+  const suppressedBreakdown = lanes.length > 0 ? `analyzer lanes: ${lanes.join(", ")}` : void 0;
+  let dispositionSuppressed = sweepSuppressed + fullModeDisposition.analyzers;
   const dispositioned = isFullMode ? summaries : summaries.map((s) => {
     const diagnostics = s.diagnostics ?? [];
     const kept = applyCachedDispositions(diagnostics, cwd, s.filePath);
@@ -19838,6 +20429,9 @@ async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummari
       root: cwd,
       filePath: s.filePath
     });
+    if (includeFile(s.filePath)) {
+      dispositionSuppressed += inScope(getSuppressedDiagnostics(s.filePath)) + inScope(diagnostics) - inScope(kept);
+    }
     if (policyKept.length === kept.length && kept.length === diagnostics.length)
       return s;
     return summarizeDiagnostics(s.filePath, policyKept, s.hasFinalSnapshot);
@@ -19863,14 +20457,19 @@ async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummari
     return s.blocking > 0 || s.errors > 0 || s.warnings > 0 || s.advisories > 0 || (s.diagnostics ?? []).some((d) => d.stale);
   });
   const pathsNote = isFullMode ? "" : pathsScopeCacheOnlyNote(pathsScope);
+  const suppressedLine = dispositionSuppressedLine(dispositionSuppressed, suppressedBreakdown);
+  const suppressedNote = suppressedLine ? `
+${suppressedLine}` : "";
+  const suppressedDetails = dispositionSuppressed > 0 ? { dispositionSuppressed } : {};
   if (withIssues.length === 0) {
-    const text = (visibleSummaries.length === 0 ? "No files diagnosed yet this session." : `No ${severity === "all" ? "" : severity + " "}issues across ${visibleSummaries.length} file${visibleSummaries.length === 1 ? "" : "s"} diagnosed this session. \u2713`) + staleNote + pathsNote;
+    const text = (visibleSummaries.length === 0 ? "No files diagnosed yet this session." : `No ${severity === "all" ? "" : severity + " "}issues across ${visibleSummaries.length} file${visibleSummaries.length === 1 ? "" : "s"} diagnosed this session. \u2713`) + staleNote + suppressedNote + pathsNote;
     return {
       content: [{ type: "text", text }],
       details: {
         ...detailOverrides,
         filesChecked: visibleSummaries.length,
-        staleDropped
+        staleDropped,
+        ...suppressedDetails
       }
     };
   }
@@ -19882,7 +20481,7 @@ async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummari
   let totalWarnings = 0;
   let totalAdvisories = 0;
   for (const s of rendered) {
-    const rel = path37.relative(cwd, s.filePath);
+    const rel = path38.relative(cwd, s.filePath);
     const parts = [];
     if (s.blocking > 0)
       parts.push(`\u{1F534} ${s.blocking} blocking`);
@@ -19934,7 +20533,10 @@ Summary (${visibleSummaries.length} files diagnosed this session):`,
   ].filter(Boolean).join("\n");
   return {
     content: [
-      { type: "text", text: lines.join("\n") + summary + staleNote }
+      {
+        type: "text",
+        text: lines.join("\n") + summary + staleNote + suppressedNote
+      }
     ],
     details: {
       ...detailOverrides,
@@ -19943,14 +20545,15 @@ Summary (${visibleSummaries.length} files diagnosed this session):`,
       totalErrors,
       totalWarnings,
       totalAdvisories,
-      staleDropped
+      staleDropped,
+      ...suppressedDetails
     }
   };
 }
 
 // dist/tools/lsp-navigation.js
 import * as nodeFs2 from "node:fs";
-import * as path38 from "node:path";
+import * as path39 from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
 
 // dist/tools/lsp-structured-output.js
@@ -20310,6 +20913,12 @@ function operationSupportStatus(operation, support) {
     return support.callHierarchy;
   return null;
 }
+function noServerAnsweredText(filePath) {
+  const { disabledServerIds, fallbackServerIds } = disabledPrimaries(filePath);
+  const cause = primaryUnavailableCause([...fallbackServerIds, ...disabledServerIds], disabledServerIds, fallbackServerIds);
+  const who = disabledServerIds.length > 0 ? `Primary LSP (${disabledServerIds.join(", ")}) did not answer` : "no language server answered";
+  return `No LSP server available for ${path39.basename(filePath)}: ${who} (${PRIMARY_UNAVAILABLE_CAUSE[cause]}).`;
+}
 function emptyReasonForOperation(operation) {
   if (operation === "signatureHelp")
     return "position-sensitive-or-no-signature";
@@ -20660,7 +21269,7 @@ function collectSearchReadsForOperation(operation, result, callHierarchyItem) {
 }
 function formatCapabilities(snapshots, filePath) {
   if (snapshots.length === 0) {
-    return filePath ? `No active LSP server for ${path38.basename(filePath)}. Open/touch the file first or run another LSP operation to start the server.` : "No active LSP servers in this session.";
+    return filePath ? `No active LSP server for ${path39.basename(filePath)}. Open/touch the file first or run another LSP operation to start the server.` : "No active LSP servers in this session.";
   }
   const rows = [
     ["definition", (s) => !!s.operationSupport.definition],
@@ -20690,7 +21299,7 @@ function formatCapabilities(snapshots, filePath) {
   ];
   const lines = [];
   for (const snapshot of snapshots) {
-    const label = filePath ? `${snapshot.serverId} (${path38.basename(filePath)})` : `${snapshot.serverId} (${snapshot.root})`;
+    const label = filePath ? `${snapshot.serverId} (${path39.basename(filePath)})` : `${snapshot.serverId} (${snapshot.root})`;
     lines.push(label);
     for (const [name, supported, note] of rows) {
       const suffix = note ? ` (${note})` : "";
@@ -20718,7 +21327,7 @@ function classifyCodeActions(actions) {
   }
   return { quickfix, refactor, other };
 }
-async function openFileBestEffort(lspService, filePath, waitForDiagnostics = false) {
+async function openFileBestEffort(lspService, filePath, waitForDiagnostics = false, excludeServerIds) {
   let fileContent;
   try {
     fileContent = nodeFs2.readFileSync(filePath, "utf-8");
@@ -20731,7 +21340,8 @@ async function openFileBestEffort(lspService, filePath, waitForDiagnostics = fal
     await lspService.touchFile(filePath, fileContent, {
       diagnostics: waitForDiagnostics ? "document" : "none",
       source: "lsp_navigation",
-      clientScope: waitForDiagnostics ? "all" : "primary"
+      clientScope: waitForDiagnostics ? "all" : "primary",
+      ...excludeServerIds !== void 0 && { excludeServerIds }
     });
   } catch {
   }
@@ -20881,6 +21491,7 @@ function createLspNavigationTool(getFlag, mutationDeps) {
       const session = mutationDeps?.runtime?.captureSessionGeneration?.();
       const startedAt = Date.now();
       let supported = null;
+      let noFileClient = false;
       let diagnosticsMode = "unknown";
       let columnResolution;
       let openedFileContent;
@@ -21030,7 +21641,7 @@ function createLspNavigationTool(getFlag, mutationDeps) {
           resultCount: 0
         });
       }
-      const filePath = rawPath ? path38.isAbsolute(rawPath) ? rawPath : path38.resolve(ctx.cwd || ".", rawPath) : "";
+      const filePath = rawPath ? resolveHostToolPath(rawPath, ctx.cwd || ".") : "";
       let filePathIsDirectory = false;
       if (filePath) {
         try {
@@ -21057,16 +21668,17 @@ function createLspNavigationTool(getFlag, mutationDeps) {
         });
       }
       if (operation === "workspaceDiagnostics") {
+        const policyCwd = ctx.cwd || process.cwd();
         const wsDiagSupport = rawPath ? await lspService.getWorkspaceDiagnosticsSupport(filePath) : await lspService.getWorkspaceDiagnosticsSupport(void 0, workspaceScopeAttribution);
         diagnosticsMode = wsDiagSupport?.mode ?? "unknown";
         if (rawPath && !filePathIsDirectory) {
-          const hasLSP2 = lspService.supportsLSP(filePath);
+          const hasLSP2 = lspService.supportsLSP(filePath) || disabledPrimaries(filePath).disabledServerIds.length > 0;
           if (!hasLSP2) {
             return finalize({
               content: [
                 {
                   type: "text",
-                  text: `No LSP server available for ${path38.basename(filePath)}. Check that the language server is installed.`
+                  text: `No LSP server available for ${path39.basename(filePath)}. Check that the language server is installed.`
                 }
               ],
               isError: true
@@ -21077,8 +21689,12 @@ function createLspNavigationTool(getFlag, mutationDeps) {
               resultCount: 0
             });
           }
-          await openFileBestEffort(lspService, filePath, true);
-          const diagnostics = await lspService.getDiagnostics(filePath);
+          const excludeServerIds = configDisabledAuxiliaryLspServerIds((name) => getFlag(name, ctx.cwd));
+          const openedContent = await openFileBestEffort(lspService, filePath, true, excludeServerIds);
+          const policy = applyProbeFindingPolicy(filePath, await lspService.getDiagnostics(filePath, void 0, excludeServerIds), policyCwd, openedContent, "all", "lsp_navigation");
+          const diagnostics = policy.kept;
+          const suppressedLine = dispositionSuppressedLine(policy.suppressed);
+          const primaryUnavailable = describePrimaryUnavailable(void 0, lspService.getDiagnosticsHealth(filePath))?.text;
           const result3 = [
             {
               filePath,
@@ -21097,14 +21713,23 @@ function createLspNavigationTool(getFlag, mutationDeps) {
               {
                 type: "text",
                 text: `${note2}
-${JSON.stringify(result3)}`
+${JSON.stringify(result3)}${primaryUnavailable ? `
+Note: ${primaryUnavailable}` : ""}${suppressedLine ? `
+Note: ${suppressedLine}` : ""}`
               }
             ],
             details: {
               operation,
               resultCount: resultCount2,
               diagnosticsMode,
-              coverage: "requested-file"
+              coverage: "requested-file",
+              ...policy.suppressed > 0 && {
+                dispositionSuppressed: policy.suppressed
+              },
+              ...primaryUnavailable !== void 0 && {
+                unconfirmed: true,
+                primaryUnavailable
+              }
             }
           }, {
             operation,
@@ -21113,12 +21738,23 @@ ${JSON.stringify(result3)}`
             resultCount: resultCount2
           });
         }
-        const allDiagnostics = await lspService.getAllDiagnostics();
-        const result2 = Array.from(allDiagnostics.entries()).map(([trackedFile, { diags }]) => ({
-          filePath: trackedFile,
-          diagnostics: diags,
-          count: diags.length
-        }));
+        const allDiagnostics = await lspService.getAllDiagnostics(configDisabledAuxiliaryLspServerIds((name) => getFlag(name, ctx.cwd)));
+        let snapshotSuppressed = 0;
+        const result2 = Array.from(allDiagnostics.entries()).map(([trackedFile, { diags, ts }]) => {
+          let kept = diags;
+          if (diags.length > 0) {
+            const policy = applyProbeFindingPolicy(trackedFile, diags, policyCwd, readFileContent(trackedFile), "all", "lsp_navigation");
+            snapshotSuppressed += policy.suppressed;
+            kept = policy.kept;
+          }
+          return {
+            filePath: trackedFile,
+            diagnostics: kept,
+            count: kept.length,
+            lag: formatCacheAgeLabel(ts)
+          };
+        });
+        const snapshotSuppressedLine = dispositionSuppressedLine(snapshotSuppressed);
         const noteMap2 = {
           "push-only": "Note: push-only tracked diagnostics snapshot (not full workspace pull diagnostics).",
           pull: "Note: tracked diagnostics snapshot from active clients. Provide path to force file-level diagnostics collection"
@@ -21129,14 +21765,18 @@ ${JSON.stringify(result3)}`
             {
               type: "text",
               text: `${note}
-${JSON.stringify(result2)}`
+${JSON.stringify(result2)}${snapshotSuppressedLine ? `
+Note: ${snapshotSuppressedLine}` : ""}`
             }
           ],
           details: {
             operation,
             resultCount: result2.length,
             diagnosticsMode,
-            coverage: "tracked-open-files"
+            coverage: "tracked-open-files",
+            ...snapshotSuppressed > 0 && {
+              dispositionSuppressed: snapshotSuppressed
+            }
           }
         }, {
           operation,
@@ -21167,7 +21807,7 @@ ${JSON.stringify(result2)}`
           content: [
             {
               type: "text",
-              text: `No LSP server available for ${path38.basename(filePath)}. Check that the language server is installed.`
+              text: disabledPrimaries(filePath).disabledServerIds.length > 0 ? noServerAnsweredText(filePath) : `No LSP server available for ${path39.basename(filePath)}. Check that the language server is installed.`
             }
           ],
           isError: true
@@ -21180,13 +21820,14 @@ ${JSON.stringify(result2)}`
       }
       if (needsFilePath) {
         const support = await lspService.getOperationSupport(filePath);
+        noFileClient = support === null;
         supported = operationSupportStatus(operation, support);
         if (supported === false) {
           return finalize({
             content: [
               {
                 type: "text",
-                text: `LSP server for ${path38.basename(filePath)} does not advertise support for ${operation}`
+                text: `LSP server for ${path39.basename(filePath)} does not advertise support for ${operation}`
               }
             ],
             isError: true,
@@ -21315,7 +21956,7 @@ ${JSON.stringify(result2)}`
             if (!newFilePath || newFilePath.trim().length === 0) {
               throw new Error("__BADINPUT__ newFilePath parameter required for rename_file");
             }
-            const resolvedNewFilePath = path38.isAbsolute(newFilePath) ? newFilePath : path38.resolve(ctx.cwd || ".", newFilePath);
+            const resolvedNewFilePath = resolveHostToolPath(newFilePath, ctx.cwd || ".");
             const result2 = await lspService.renameFile(filePath, resolvedNewFilePath, {
               cwd: ctx.cwd || ".",
               apply: apply ?? false,
@@ -21459,7 +22100,15 @@ ${JSON.stringify(result2)}`
         }, { operation, filePath, failureKind: "lsp_error", resultCount: 0 });
       }
       const isEmpty = !result || Array.isArray(result) && result.length === 0;
-      const fileCtx = filePath ? " at " + path38.basename(filePath) : "";
+      if (isEmpty && noFileClient) {
+        return finalize({
+          content: [
+            { type: "text", text: noServerAnsweredText(filePath) }
+          ],
+          isError: true
+        }, { operation, filePath, failureKind: "no_server", resultCount: 0 });
+      }
+      const fileCtx = filePath ? " at " + path39.basename(filePath) : "";
       const lineCtx = line ? ":" + line + ":" + character : "";
       let output = isEmpty ? "No results for " + operation + fileCtx + lineCtx : JSON.stringify(result);
       if (isEmpty && operation === "workspaceSymbol" && !rawPath) {
@@ -21701,11 +22350,11 @@ function resolveDefaultCwd() {
   const fromArg = process.argv.find((arg) => arg.startsWith("--cwd="))?.slice("--cwd=".length);
   return fromArg ?? process.env.PI_LENS_MCP_CWD ?? process.cwd();
 }
-var DEFAULT_CWD = path39.resolve(resolveDefaultCwd());
+var DEFAULT_CWD = path40.resolve(resolveDefaultCwd());
 var lspReadyCwds = /* @__PURE__ */ new Set();
 var SERVER_FILE = fileURLToPath3(import.meta.url);
-var SERVER_DIR = path39.dirname(SERVER_FILE);
-var WORKER_PATH = path39.join(SERVER_DIR, "worker.js");
+var SERVER_DIR = path40.dirname(SERVER_FILE);
+var WORKER_PATH = path40.join(SERVER_DIR, "worker.js");
 var REBUILD_SCRIPT = resolveRebuildScript(SERVER_FILE);
 var STALENESS_STAT_PATH = process.env.PI_LENS_MCP_STALENESS_STAT_PATH ?? SERVER_FILE;
 var BUILD_STAMP = computeBuildStamp(STALENESS_STAT_PATH);
@@ -21727,7 +22376,7 @@ function isWarmBuildStale() {
 function findRepoRoot(start) {
   let dir = start;
   for (let depth = 0; depth < 6; depth++) {
-    const pkgPath = path39.join(dir, "package.json");
+    const pkgPath = path40.join(dir, "package.json");
     if (fs25.existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(fs25.readFileSync(pkgPath, "utf8"));
@@ -21736,16 +22385,16 @@ function findRepoRoot(start) {
       } catch {
       }
     }
-    const parent = path39.dirname(dir);
+    const parent = path40.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return path39.resolve(start, "..", "..");
+  return path40.resolve(start, "..", "..");
 }
-var REPO_ROOT = process.env.PI_LENS_MCP_REPO_ROOT ? path39.resolve(process.env.PI_LENS_MCP_REPO_ROOT) : findRepoRoot(SERVER_DIR);
+var REPO_ROOT = process.env.PI_LENS_MCP_REPO_ROOT ? path40.resolve(process.env.PI_LENS_MCP_REPO_ROOT) : findRepoRoot(SERVER_DIR);
 async function ensureReady(cwd) {
-  const normalized = path39.resolve(cwd);
+  const normalized = path40.resolve(cwd);
   if (!shouldInitializeSessionRoot(normalized, lspReadyCwds)) {
     return;
   }
@@ -21791,22 +22440,17 @@ function getAutoSessionStatus() {
 }
 var IPC_PATH = ipcPathForCwd(DEFAULT_CWD);
 function rejectForeignTurnCwd(route, cwd) {
-  const message = `${route} cwd outside this server's workspace: ${path39.resolve(cwd)} not within ${DEFAULT_CWD}`;
+  const message = `${route} cwd outside this server's workspace: ${path40.resolve(cwd)} not within ${DEFAULT_CWD}`;
   console.error(`[pi-lens-mcp] rejected ${message}`);
   return message;
 }
 function isWithinServerWorkspace(cwd) {
-  const target = path39.resolve(cwd);
-  const rel = path39.relative(DEFAULT_CWD, target);
-  return !rel.startsWith("..") && !path39.isAbsolute(rel);
+  const target = path40.resolve(cwd);
+  const rel = path40.relative(DEFAULT_CWD, target);
+  return !rel.startsWith("..") && !path40.isAbsolute(rel);
 }
 function startIpcServer() {
-  if (process.platform !== "win32") {
-    try {
-      fs25.unlinkSync(IPC_PATH);
-    } catch {
-    }
-  }
+  unlinkStaleUnixSocket(IPC_PATH);
   const requestQueue = createWarmIpcRequestQueue();
   const ipc = net.createServer((socket) => {
     socket.setEncoding("utf8");
@@ -21908,12 +22552,6 @@ function startIpcServer() {
       ipc.close();
     } catch {
     }
-    if (process.platform !== "win32") {
-      try {
-        fs25.unlinkSync(IPC_PATH);
-      } catch {
-      }
-    }
   };
   process.on("exit", cleanup);
 }
@@ -21974,7 +22612,11 @@ var lensDiagnosticsTool = createLensDiagnosticsTool(
   // `lens-guard` off — a config bypass on a durable cross-surface store.
   // Matches index.ts:1656 and the two sibling readers
   // (clients/runtime-tool-call.ts, clients/runtime-tool-result.ts).
-  () => isLensGuardEnabled()
+  () => isLensGuardEnabled(),
+  // #4323: `opengrep.enabled=false` keeps the explicit `source=lsp` probe from
+  // starting Opengrep, as it does for `pilens_analyze`. Resolved per call
+  // against the call's own project, like `lspNavigationTool` below (#792).
+  (name, cwd) => createMcpHost(void 0, cwd).getFlag(name)
 );
 var astGrepClient = new AstGrepClient();
 var astGrepSearchTool = createAstGrepSearchTool(astGrepClient);
@@ -22293,7 +22935,7 @@ function enabledToolsForCwd(cwd) {
 }
 function formatAnalyze(result, cwd, mode, servedBy) {
   const lspNote = result.lsp ? ` \xB7 lsp ${result.lsp.diagnosticCount} (${result.lsp.status}${result.lsp.failureKind ? `: ${result.lsp.failureKind}` : ""}, ${result.lsp.durationMs}ms)` : "";
-  const summary = `${path39.relative(cwd, result.filePath) || result.filePath} [${mode}] \u2014 ${result.counts.blockers} blocking, ${result.counts.warnings} warning(s), ${result.counts.advisories} advisory(ies), ${result.counts.diagnostics} total` + (result.latency ? ` \xB7 ${result.latency.totalDurationMs}ms` : "") + lspNote + (result.counts.fixed > 0 ? ` \xB7 ${result.counts.fixed} auto-fixed` : "") + (servedBy ? `
+  const summary = `${path40.relative(cwd, result.filePath) || result.filePath} [${mode}] \u2014 ${result.counts.blockers} blocking, ${result.counts.warnings} warning(s), ${result.counts.advisories} advisory(ies), ${result.counts.diagnostics} total` + (result.latency ? ` \xB7 ${result.latency.totalDurationMs}ms` : "") + lspNote + (result.counts.fixed > 0 ? ` \xB7 ${result.counts.fixed} auto-fixed` : "") + (servedBy ? `
 
 servedBy: ${servedBy}` : "");
   return renderToolText(summary, servedBy ? { ...result, servedBy } : result);
@@ -22427,7 +23069,7 @@ ${outcome.output}`, {
     }
     const { deduped, byRule, byFile } = summarizeScan(snapshot.diagnostics);
     const topRules = Object.entries(byRule).sort((a, b) => b[1] - a[1]);
-    const topFiles = Object.entries(byFile).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([file, count]) => ({ file: path39.relative(cwd, file), count }));
+    const topFiles = Object.entries(byFile).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([file, count]) => ({ file: path40.relative(cwd, file), count }));
     const summaryLines = [
       `Scanned ${snapshot.filesScanned} file(s) [${snapshot.runners.join(", ")}] \u2192 ${deduped.length} unique diagnostic(s)` + (snapshot.diagnostics.length !== deduped.length ? ` (${snapshot.diagnostics.length} raw, ${snapshot.diagnostics.length - deduped.length} duplicate)` : ""),
       ...topRules.slice(0, 12).map(([rule, count]) => `  ${count}\xD7 ${rule}`)
@@ -22438,8 +23080,13 @@ ${outcome.output}`, {
     const skipNotice = generatedSkipNotice(snapshot, "mcp");
     if (skipNotice)
       summaryLines.push(skipNotice);
+    const { dispositionSuppressed } = snapshot;
+    const suppressedLine = dispositionSuppressedLine(dispositionSuppressed);
+    if (suppressedLine)
+      summaryLines.push(suppressedLine);
     return renderToolText(summaryLines.join("\n"), {
       filesScanned: snapshot.filesScanned,
+      ...dispositionSuppressed > 0 ? { dispositionSuppressed } : {},
       runners: snapshot.runners,
       uniqueDiagnostics: deduped.length,
       rawDiagnostics: snapshot.diagnostics.length,
@@ -22480,7 +23127,7 @@ ${stalenessNote}` : ""), {
     }
     const lines = [
       `Top ${results.length} file(s) for "${query}":`,
-      ...results.map((result, i) => `  ${i + 1}. ${path39.relative(cwd, result.file)} (score ${result.score.toFixed(2)}, ${result.hits} hit(s), line ${result.startLine})`),
+      ...results.map((result, i) => `  ${i + 1}. ${path40.relative(cwd, result.file)} (score ${result.score.toFixed(2)}, ${result.hits} hit(s), line ${result.startLine})`),
       ...stalenessNote ? ["", stalenessNote] : [],
       ...coverage ? [
         `Index covers ${coverage.files} files${coverage.truncated ? " (capped \u2014 results may be incomplete)" : ""}.`
@@ -22490,7 +23137,7 @@ ${stalenessNote}` : ""), {
       query,
       coverage,
       results: results.map((result) => {
-        const relFile = path39.relative(cwd, result.file);
+        const relFile = path40.relative(cwd, result.file);
         return {
           file: relFile,
           score: result.score,
@@ -22529,12 +23176,12 @@ ${stalenessNote}` : ""), {
     });
     if (!report.available) {
       return {
-        ...renderToolText(`No module report for ${path39.relative(cwd, path39.resolve(cwd, file))} \u2014 not a symbol-bearing file, or unreadable.`, report, true),
+        ...renderToolText(`No module report for ${path40.relative(cwd, path40.resolve(cwd, file))} \u2014 not a symbol-bearing file, or unreadable.`, report, true),
         isError: true
       };
     }
     const graphStaleness = graphStalenessNote(report.graphBuiltAt, "Review graph");
-    const summary = `${path39.relative(cwd, report.path) || report.path} [${report.staleness}] \u2014 ${report.summary.symbols} symbol(s), ${report.summary.exports} exported, ${report.api.length} in public API` + (graphStaleness ? `
+    const summary = `${path40.relative(cwd, report.path) || report.path} [${report.staleness}] \u2014 ${report.summary.symbols} symbol(s), ${report.summary.exports} exported, ${report.api.length} in public API` + (graphStaleness ? `
 
 ${graphStaleness}` : "");
     if (view === "compact") {
@@ -22595,7 +23242,7 @@ ${graphStaleness}` : "");
     if (!result.found) {
       const suggestionSuffix = result.suggestions?.length ? ` Did you mean: ${result.suggestions.join(", ")}?` : " Use pilens_module_report to list symbols.";
       return {
-        ...renderToolText(`Symbol "${symbol}" not found in ${path39.basename(file)}.${suggestionSuffix}`, {
+        ...renderToolText(`Symbol "${symbol}" not found in ${path40.basename(file)}.${suggestionSuffix}`, {
           found: false,
           ...result.suggestions ? { suggestions: result.suggestions } : {}
         }),
@@ -22604,7 +23251,7 @@ ${graphStaleness}` : "");
     }
     const sigSuffix = result.signature ? `  ${result.signature}` : "";
     const ambiguityNote = result.ambiguous ? ` (${result.ambiguous.count} matches \u2014 returned the ${result.kind}; pass \`kind\` to disambiguate: ${result.ambiguous.kinds.join(", ")})` : "";
-    const header = `${result.kind} ${result.name}${ambiguityNote}${sigSuffix}  ${path39.relative(cwd, result.path)}:${result.startLine}-${result.endLine}`;
+    const header = `${result.kind} ${result.name}${ambiguityNote}${sigSuffix}  ${path40.relative(cwd, result.path)}:${result.startLine}-${result.endLine}`;
     return {
       content: [
         {
@@ -22642,14 +23289,14 @@ ${result.source ?? ""}`
 
 Nested outline:
 ${JSON.stringify(result.outline)}` : "";
-      const text = result.error ? `Could not read enclosing range in ${path39.basename(file)}:${result.line}: ${result.error}${warningSuffix}${outlineSuffix}` : `No enclosing symbol/callback found in ${path39.basename(file)}:${result.line}.${warningSuffix}`;
+      const text = result.error ? `Could not read enclosing range in ${path40.basename(file)}:${result.line}: ${result.error}${warningSuffix}${outlineSuffix}` : `No enclosing symbol/callback found in ${path40.basename(file)}:${result.line}.${warningSuffix}`;
       return {
         ...renderToolText(text, { found: false, line: result.line }),
         isError: true
       };
     }
     const range = result.partial ? `${result.startLine}-${result.endLine} (partial of ${result.enclosingStartLine}-${result.enclosingEndLine})` : `${result.startLine}-${result.endLine}`;
-    const header = `${result.kind} ${result.name}  ${path39.relative(cwd, result.path)}:${range}`;
+    const header = `${result.kind} ${result.name}  ${path40.relative(cwd, result.path)}:${range}`;
     return {
       content: [
         {
@@ -22684,7 +23331,7 @@ ${result.source ?? ""}`
       ]),
       ...renderLspBrokenStatusLines(brokenServers),
       ...renderDegradationLines(degradations),
-      last ? `Last dispatch: ${path39.basename(last.filePath)} \u2014 ${last.totalDurationMs}ms, ${last.totalDiagnostics} diagnostic(s)` : "Last dispatch: none yet",
+      last ? `Last dispatch: ${path40.basename(last.filePath)} \u2014 ${last.totalDurationMs}ms, ${last.totalDiagnostics} diagnostic(s)` : "Last dispatch: none yet",
       `Diagnostics this session: ${stats.totalShown} shown \xB7 ${stats.totalAutoFixed} auto-fixed \xB7 ${stats.totalUnresolved} unresolved`,
       autoSession ? `Auto session_start: ${autoSession.succeeded ? "succeeded" : autoSession.error ? "FAILED" : autoSession.attempted ? "in progress" : "not yet attempted"}${autoSession.firedAt ? ` (fired ${autoSession.firedAt})` : ""}${autoSession.error ? ` \u2014 ${autoSession.error}` : ""}` : "Auto session_start: disabled (PI_LENS_MCP_AUTO_SESSION not set)",
       turnEnd ? `Stop-hook turn-end: ${turnEnd.ran} ran \xB7 ${turnEnd.skipped} skipped${turnEnd.lastRunAt ? ` (last ran ${turnEnd.lastRunAt})` : ""}${turnEnd.lastSkipReason ? ` \u2014 last skip: ${turnEnd.lastSkipReason}${turnEnd.lastSkipAt ? ` at ${turnEnd.lastSkipAt}` : ""}` : ""}` : "Stop-hook turn-end: no activity recorded (hook not installed, or no Stop yet)",
@@ -22750,7 +23397,7 @@ ${result.source ?? ""}`
     const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? Math.max(1, Math.floor(args.limit)) : 5;
     const fileFilter = typeof args.file === "string" ? args.file : void 0;
     const recent = recentLatency(limit, fileFilter);
-    const summary = recent.length === 0 ? "No dispatch latency reports yet." : recent.map((report) => `${path39.basename(report.filePath)}: ${report.totalDurationMs}ms (${report.totalDiagnostics} diag${report.stoppedEarly ? ", stopped early" : ""})`).join("\n");
+    const summary = recent.length === 0 ? "No dispatch latency reports yet." : recent.map((report) => `${path40.basename(report.filePath)}: ${report.totalDurationMs}ms (${report.totalDiagnostics} diag${report.stoppedEarly ? ", stopped early" : ""})`).join("\n");
     return renderToolText(summary, recent);
   }
   if (name === "pilens_session_start") {