pi-lens 4.4.2 → 4.4.4

package/dist/{chunk-ODBNXWT4.js → chunk-CT4MN5IU.js}

@@ -2,17 +2,7 @@ import { createRequire as __pilensCreateRequire } from "node:module"; const requ
 import {
   getLazyInstallAttempt,
   tryLazyInstall
-} from "./chunk-OXXKQCSV.js";
-import {
-  stripAnsi
-} from "./chunk-FC4RP4I2.js";
-import {
-  isTrivyEnabled,
-  resolveSeverityFloor
-} from "./chunk-66SXUJCA.js";
-import {
-  rustClient
-} from "./chunk-MRXKYPCS.js";
+} from "./chunk-UBOQLVT2.js";
 import {
   findingsResult,
   finishParsedRun,
@@ -21,11 +11,29 @@ import {
   isRunnerClaimSource,
   isRunnerSkipReason,
   parseToolRun,
-  skipUnlessToolRan
-} from "./chunk-2CD5RS6M.js";
+  reachedNoVerdict,
+  skipUnlessToolRan,
+  spanOverlapsModifiedRanges
+} from "./chunk-RKBXZN3A.js";
+import {
+  stripAnsi
+} from "./chunk-6HWVI6MI.js";
 import {
   spawnFailedWithNoOutput
-} from "./chunk-UZ3TUTRV.js";
+} from "./chunk-S67KYG37.js";
+import {
+  computeImpactCascade
+} from "./chunk-KN35K52N.js";
+import {
+  goClient
+} from "./chunk-ROYSX2S5.js";
+import {
+  isTrivyEnabled,
+  resolveSeverityFloor
+} from "./chunk-YH5MVY2U.js";
+import {
+  rustClient
+} from "./chunk-EBC36LNN.js";
 import {
   coveringLaneAvailable,
   createAvailabilityChecker,
@@ -33,6 +41,7 @@ import {
   getDispatchAvailabilityGeneration,
   lspPrimaryCoversFile,
   recordAvailabilityProbeOverrun,
+  resolveAdoptedRootCommand,
   resolveAvailableOrInstall,
   resolveCommandArgsWithInstallFallback,
   resolveLocalFirstAsync,
@@ -40,7 +49,7 @@ import {
   resolveToolCommand,
   resolveToolCommandWithInstallFallback,
   resolveVendorToolCommand
-} from "./chunk-GOYRYZ2R.js";
+} from "./chunk-ZHH37KZL.js";
 import {
   biomeConfigArgs,
   findCompiledClassesDir,
@@ -59,47 +68,44 @@ import {
   hasYamllintConfig,
   markdownlintConfigArgs,
   ruffConfigArgs
-} from "./chunk-RPLINGVB.js";
+} from "./chunk-Y6GZHWSJ.js";
 import {
   importFactProvider
-} from "./chunk-XCJN5IJU.js";
+} from "./chunk-IYNJ6YPZ.js";
 import {
   functionFactProvider
-} from "./chunk-76MWC2K6.js";
+} from "./chunk-EUXZEFTV.js";
 import {
   extractFactsFromTree
-} from "./chunk-GXW6K4YJ.js";
+} from "./chunk-T57LYLZT.js";
 import {
-  computeImpactCascade
-} from "./chunk-2B73ZPOK.js";
-import {
-  goClient
-} from "./chunk-XMSXXAHW.js";
+  buildOrUpdateGraph,
+  clearReviewGraphWorkspaceCache,
+  fileContentProvider
+} from "./chunk-XHJBS436.js";
 import {
   MAX_BLOCKING_RULE_COMPLEXITY,
-  RUNTIME_CONFIG,
+  PRIMARY_UNAVAILABLE_CAUSE,
   applyDispositions,
   applyDispositionsMultiFile,
   buildEffectiveAstGrepCatalog,
-  buildOrUpdateGraph,
   calculateRuleComplexity,
   classifyDefect,
   classifyDiagnostic,
   classifyDiagnosticTier,
   clearPendingAuxiliaryCoverage,
-  clearReviewGraphWorkspaceCache,
+  combinePrimaryUnavailableCauses,
   enabledAuxiliaryLspServerIds,
-  exceedsLspSyncLimits,
   fetchTsserverProjectIdentity,
-  fileContentProvider,
   getLSPService,
-  getRunnerTimeoutFloorMs,
   hasAnyDispositionMarks,
   hasAuxiliaryLspPublishedForRoot,
   hasPendingAuxiliaryCoverage,
   isOverlyBroadPattern,
   isRuleIgnoredForPath,
   isStructuredRule,
+  lineContentHash,
+  primaryUnavailableCause,
   recordDiagnostics,
   recordNapiFallbackCoverage,
   recordRunner,
@@ -107,24 +113,40 @@ import {
   touchCoverageGap,
   tryWarmAttachedCodeActions,
   tryWarmAttachedDiagnostics
-} from "./chunk-PV6LR5P5.js";
+} from "./chunk-RVK72CZX.js";
+import {
+  ANY_POSITION,
+  retainRecordedFindings
+} from "./chunk-IWDLU6K3.js";
 import {
   mapWithConcurrency
 } from "./chunk-XIMYZ3JA.js";
 import {
   LSP_SERVERS,
+  disabledPrimaries,
   getAstGrepRuleSources,
-  registerRunnerId
-} from "./chunk-ESBQHFMJ.js";
+  registerRunnerId,
+  resolveAnalysisRoot
+} from "./chunk-3DA2JDOL.js";
 import {
   augmentPythonEnvironment,
   detectPythonEnvironment
-} from "./chunk-34WSVGEM.js";
+} from "./chunk-CUHSHSB6.js";
 import {
   loadProjectSnapshot,
   readJsonCache,
   readJsonCacheAsync
-} from "./chunk-ZXYDQ3TZ.js";
+} from "./chunk-T7FEBKXN.js";
+import {
+  RUNTIME_CONFIG,
+  exceedsLspSyncLimits,
+  getRunnerTimeoutFloorMs,
+  loadAstGrepNapi
+} from "./chunk-V35JG4JB.js";
+import {
+  buildModuleGraph,
+  clearModuleGraphCache
+} from "./chunk-XTBDCR27.js";
 import {
   BUNDLED_QUERIES_ROOT,
   classifyTreeSitterWasmError,
@@ -144,44 +166,44 @@ import {
   ruleFilesForLanguage,
   ruleSourceLanguages,
   walk
-} from "./chunk-QHJ6DQ2R.js";
-import {
-  buildModuleGraph,
-  clearModuleGraphCache
-} from "./chunk-GBPP5P7X.js";
+} from "./chunk-US7ECLD7.js";
 import {
   WORD_INDEX_MAX_BYTES,
   deserializeWordIndex,
   logWordIndex,
   removeWordIndexDocumentAsync,
   scheduleWordIndexPersist,
+  setWordIndexPublishedListener,
   updateWordIndexDocumentForEdit
-} from "./chunk-SAEFPSB6.js";
+} from "./chunk-W66O5E25.js";
 import {
   PathKeyedMap
 } from "./chunk-Z3CCVDUB.js";
 import {
   WARM_CODE_ACTION_LOOKUP_LIMIT,
-  contentHash,
-  resolveRunnerPath
-} from "./chunk-L3BLXZG7.js";
+  contentHash
+} from "./chunk-KAPJINKN.js";
+import {
+  resolveRunnerPath,
+  toRunnerDisplayPath
+} from "./chunk-AGSS7277.js";
 import {
   isSpawnableCommand
-} from "./chunk-66VMUL7Q.js";
+} from "./chunk-GAQ7OQG6.js";
 import {
   logRunnerAdvisoryOnce,
   resolveRunnerCwd,
   resolveRunnerCwdWithReason
-} from "./chunk-Q7DUK4LX.js";
+} from "./chunk-DEL2U6CM.js";
 import {
   findLocalBinUpwards,
   localBinPath
-} from "./chunk-AW7R2GWG.js";
+} from "./chunk-5VSF4UUQ.js";
 import {
   createAvailabilityProbeFlight,
   getIsolatedNpxSpawnOptions,
   probeToolAsync
-} from "./chunk-RWWYJ623.js";
+} from "./chunk-3KAZU3VR.js";
 import {
   classifyProbeFailure,
   createAvailabilityLatch,
@@ -191,12 +213,12 @@ import {
   logAvailabilityDecision,
   startHostStallSampler,
   transientRetryDelayMs
-} from "./chunk-VRZP76YM.js";
+} from "./chunk-P63GXC37.js";
 import {
   getLspCapableKinds,
   getPrimaryDispatchGroup,
   resolveLanguageRootForFile
-} from "./chunk-QOBUHWHX.js";
+} from "./chunk-HRNHZA3N.js";
 import {
   getGlobalPiLensDir,
   getProjectDataDir,
@@ -206,25 +228,25 @@ import {
   noteSpawnTimeout,
   resolvePiLensFlag,
   safeSpawnAsync
-} from "./chunk-C34ZXZ7O.js";
+} from "./chunk-KUA4OJ5Y.js";
 import {
   detectFileKind
-} from "./chunk-PHDMFAKM.js";
+} from "./chunk-DUO2TU77.js";
 import {
   classifyGeneratedOrArtifactDetailed,
   detectFileRole,
   loadPiLensProjectConfig,
   resolvePiLensConfig
-} from "./chunk-2BBLFX75.js";
+} from "./chunk-J6MPGQTS.js";
 import {
   findNearestDirWithAnyBasename,
   findNearestDirWithMarker,
   getPiLensGlobalConfigPath
-} from "./chunk-XVF2VVXP.js";
+} from "./chunk-5HSRT26B.js";
 import {
   getProjectTrustState,
   projectTrustDenialReason
-} from "./chunk-ZANLILYD.js";
+} from "./chunk-M2IFVFWU.js";
 import {
   killedForOutputCap,
   truncatedByOutputCap,
@@ -233,27 +255,28 @@ import {
 import {
   incrementDegradationCount,
   recordDegradationOnce
-} from "./chunk-JAU72XNY.js";
+} from "./chunk-J64T55EI.js";
 import {
   createSubsystemLogger,
   logExtension
-} from "./chunk-XTMJ7XDT.js";
+} from "./chunk-POMLXPMY.js";
 import {
   logLatency,
   phaseFinished,
   phaseStarted
-} from "./chunk-QQNQ7SJW.js";
+} from "./chunk-QBFBRV2B.js";
 import {
   createNdjsonLogger,
   getGlobalPiLensLogDir,
   getMaxLogSizeMB,
   isTestMode
-} from "./chunk-AOHZU2BM.js";
+} from "./chunk-YNE3RP52.js";
 import {
   FactStore,
   setFactStoreEvictionReporter
-} from "./chunk-CHOW74WE.js";
+} from "./chunk-CYRKQRPM.js";
 import {
+  BoundedFifoMap,
   BoundedLruCache
 } from "./chunk-ABBOA7UD.js";
 import {
@@ -266,7 +289,7 @@ import {
   normalizeMapKey,
   pathsEqual,
   toProjectRelativePath
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/mcp/analyze.js
 import * as fs19 from "node:fs";
@@ -885,6 +908,62 @@ function createDiagnosticLogger() {
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 
+// dist/clients/line-alignment.js
+var MAX_OWED_LINE_TEXTS = 4096;
+function lineHashOf(line) {
+  return Number.parseInt(lineContentHash(line), 16);
+}
+function stampLineHashes(findings, content, isOwn) {
+  if (content === void 0)
+    return [...findings];
+  let lines;
+  return findings.map((d) => {
+    if (d.lineHash !== void 0 || d.line === void 0 || !isOwn(d))
+      return d;
+    lines ??= content.split(/\r?\n/);
+    const text = lines[d.line - 1];
+    return text === void 0 ? d : { ...d, lineHash: lineHashOf(text) };
+  });
+}
+function linesOfRanges(ranges) {
+  const lines = [];
+  for (const { start, end } of ranges)
+    for (let line = start; line <= end; line += 1)
+      lines.push(line);
+  return lines;
+}
+function rangesOfLines(lines) {
+  const sorted = [...new Set(lines)].sort((a, b) => a - b);
+  const ranges = [];
+  for (const line of sorted) {
+    const last = ranges.at(-1);
+    if (last && line === last.end + 1)
+      last.end = line;
+    else
+      ranges.push({ start: line, end: line });
+  }
+  return ranges;
+}
+function owedContentOf(ranges, lineHashes) {
+  if (lineHashes === void 0)
+    return "whole-file";
+  const texts = /* @__PURE__ */ new Set();
+  for (const line of linesOfRanges(ranges)) {
+    const hash = lineHashes[line - 1];
+    if (hash !== void 0)
+      texts.add(hash);
+    if (texts.size > MAX_OWED_LINE_TEXTS)
+      return "whole-file";
+  }
+  return Uint32Array.from(texts).sort();
+}
+function owedByContentOnly(anchor) {
+  const owedContent = new Map(anchor?.owedContent ?? []);
+  for (const [runnerId, ranges] of anchor?.owedRanges ?? [])
+    owedContent.set(runnerId, owedContentOf(ranges, anchor?.lineHashes));
+  return owedContent.size > 0 ? { lineHashes: void 0, owedRanges: /* @__PURE__ */ new Map(), owedContent } : void 0;
+}
+
 // dist/clients/dispatch/rule-id-normalize.js
 import * as fs2 from "node:fs";
 import * as path3 from "node:path";
@@ -1380,8 +1459,8 @@ async function drainPendingRunnerFindings(maxWaitMs = 2e3, currentSession, curre
   if (maxWaitMs === 0)
     await Promise.resolve();
   if (maxWaitMs > 0 && current.some((entry) => !entry.settled)) {
-    await new Promise((resolve44) => {
-      const timer = setTimeout(resolve44, maxWaitMs);
+    await new Promise((resolve45) => {
+      const timer = setTimeout(resolve45, maxWaitMs);
       timer.unref?.();
     });
   }
@@ -1420,6 +1499,54 @@ function pendingRunnerFindingsSize() {
   return pending.length;
 }
 
+// dist/clients/dispatch/adopted-root-runners.js
+var ADOPTED_ROOT_RUNNER_ALLOWLIST = [
+  "fish-indent",
+  "php-lint"
+];
+var ADMITTED = new Set(ADOPTED_ROOT_RUNNER_ALLOWLIST);
+function isAdoptedRootRunnerAdmitted(runnerId) {
+  return ADMITTED.has(runnerId);
+}
+function filterGroupsForAdoptedRoot(groups) {
+  const filtered = [];
+  for (const group of groups) {
+    const runnerIds = [];
+    for (const runnerId of group.runnerIds) {
+      if (isAdoptedRootRunnerAdmitted(runnerId))
+        runnerIds.push(runnerId);
+    }
+    if (runnerIds.length === 0)
+      continue;
+    filtered.push(runnerIds.length === group.runnerIds.length ? group : { ...group, runnerIds });
+  }
+  return filtered;
+}
+
+// dist/clients/dispatch/lane-copies.js
+function semanticRank(semantic) {
+  if (semantic === "blocking")
+    return 4;
+  if (semantic === "warning")
+    return 3;
+  if (semantic === "fixed")
+    return 2;
+  if (semantic === "silent")
+    return 1;
+  return 0;
+}
+function laneKey(d) {
+  return `${d.line ?? 1}\0${normalizeRuleId(d.rule ?? "")}`;
+}
+function laneCopyStandsFor(lane) {
+  const rankByKey = /* @__PURE__ */ new Map();
+  for (const d of lane) {
+    const key2 = laneKey(d);
+    rankByKey.set(key2, Math.max(rankByKey.get(key2) ?? 0, semanticRank(d.semantic)));
+  }
+  return (d) => (rankByKey.get(laneKey(d)) ?? -1) >= semanticRank(d.semantic);
+}
+
 // dist/clients/dispatch/rule-policy.js
 function resolvedRulePolicyMap(root) {
   const resolved = resolvePiLensConfig({
@@ -1551,6 +1678,58 @@ function getToolProfile(tool, defectClass) {
   return TOOL_PROFILE_MAP[t] ?? DEFAULT_TOOL_PROFILE;
 }
 
+// dist/clients/dispatch/pre-edit-seed.js
+var PRE_EDIT_SEED_RUNNER_IDS = /* @__PURE__ */ new Set([
+  "actionlint",
+  "biome-check-json",
+  "credo",
+  "detekt",
+  "eslint",
+  "golangci-lint",
+  "hadolint",
+  "htmlhint",
+  "ktlint",
+  "markdownlint",
+  "oxlint",
+  "psscriptanalyzer",
+  "rubocop",
+  "ruff-lint",
+  "rust-clippy",
+  "shellcheck",
+  "spellcheck",
+  "sqlfluff",
+  "stylelint",
+  "swiftlint",
+  "tflint",
+  "vale",
+  "yamllint"
+]);
+function preEditSeedFactKey(filePath) {
+  return `session.preEdit.${filePath}`;
+}
+function classifyPreExisting(seed, current, content, answered) {
+  let lines;
+  const hashAt = (line) => {
+    if (line === void 0)
+      return void 0;
+    lines ??= content.split(/\r?\n/);
+    const text = lines[line - 1];
+    return text === void 0 ? void 0 : lineHashOf(text);
+  };
+  const candidates = current.filter((d) => d.runnerId !== void 0 && PRE_EDIT_SEED_RUNNER_IDS.has(d.runnerId));
+  const { kept } = retainRecordedFindings(seed, candidates, {
+    positionOf: () => ANY_POSITION,
+    keepUnobserved: (d) => d.runnerId === void 0 || !answered.has(d.runnerId),
+    matchesAnywhere: (prior, observed2) => prior.lineHash !== void 0 && prior.lineHash === hashAt(observed2.line)
+  });
+  const observed = new Set(candidates);
+  const preExisting = kept.filter((d) => observed.has(d));
+  return {
+    preExisting,
+    nextSeed: stampLineHashes(kept, content, (d) => observed.has(d))
+  };
+}
+
 // dist/clients/dispatch/utils/format-utils.js
 var EMOJI = {
   blocking: "\u{1F534}",
@@ -1805,6 +1984,9 @@ function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedR
     }
   };
 }
+function deltaBaselineFactKey(filePath) {
+  return `session.baseline.${filePath}`;
+}
 function filterDelta(after, before, keyFn) {
   const beforeSet = new Set((before ?? []).map(keyFn));
   const afterSet = new Set(after.map(keyFn));
@@ -1812,17 +1994,6 @@ function filterDelta(after, before, keyFn) {
   const newItems = after.filter((d) => !beforeSet.has(keyFn(d)));
   return { new: newItems, fixed };
 }
-function semanticRank(semantic) {
-  if (semantic === "blocking")
-    return 4;
-  if (semantic === "warning")
-    return 3;
-  if (semantic === "fixed")
-    return 2;
-  if (semantic === "silent")
-    return 1;
-  return 0;
-}
 function toolPriority(tool, defectClass) {
   return getToolProfile(tool, defectClass).dedupPriority;
 }
@@ -1921,14 +2092,14 @@ function promoteDeltaUnusedToBlockers(diagnostics) {
 }
 function buildCoverageNotice(ctx, runnerLatencies, dedupe) {
   if (!ctx.kind)
-    return void 0;
+    return {};
   const lspEnabled = !ctx.pi.getFlag("no-lsp");
   const primary2 = getPrimaryDispatchGroup(ctx.kind, lspEnabled);
   if (!primary2 || primary2.runnerIds.length === 0)
-    return void 0;
+    return {};
   const relevant = runnerLatencies.filter((r) => primary2.runnerIds.includes(r.runnerId));
   if (relevant.length === 0)
-    return void 0;
+    return {};
   const unconfirmedServerIds = [
     ...new Set(relevant.flatMap((r) => r.unconfirmedServerIds ?? []))
   ];
@@ -1945,7 +2116,7 @@ function buildCoverageNotice(ctx, runnerLatencies, dedupe) {
     const onceKey2 = `${ctx.kind}:${ctx.filePath}:${dedupeSet(silentServerIds)}|${dedupeSet(deferredServerIds)}`;
     if (dedupe) {
       if (coverageNoticeSeen.has(onceKey2))
-        return void 0;
+        return {};
       coverageNoticeSeen.add(onceKey2);
     }
     const coverageParts = [];
@@ -1956,20 +2127,22 @@ function buildCoverageNotice(ctx, runnerLatencies, dedupe) {
       coverageParts.push(`coverage: ${markerFor(silentServerIds)} silent \u2014 diagnostics are incomplete (not a clean result).`);
     }
     return {
-      id: `coverage-partial:${ctx.kind}:${path4.basename(ctx.filePath)}`,
-      message: coverageParts.join("\n"),
-      filePath: ctx.filePath,
-      severity: "warning",
-      semantic: "warning",
-      tool: "pi-lens"
+      notice: {
+        id: `coverage-partial:${ctx.kind}:${path4.basename(ctx.filePath)}`,
+        message: coverageParts.join("\n"),
+        filePath: ctx.filePath,
+        severity: "warning",
+        semantic: "warning",
+        tool: "pi-lens"
+      }
     };
   }
   const primaryHasCoverage = relevant.some(hasUsableResult);
   if (primaryHasCoverage)
-    return void 0;
+    return {};
   const primaryStillInFlight = relevant.some((r) => r.status === "pending" || r.status === "deferred");
   if (primaryStillInFlight)
-    return void 0;
+    return {};
   const plan = getToolPlan(ctx.kind);
   const fallbackRunnerIds = new Set((plan?.groups ?? []).filter((group) => !group.runnerIds.every((runnerId) => primary2.runnerIds.includes(runnerId))).flatMap((group) => group.runnerIds).filter((runnerId) => !primary2.runnerIds.includes(runnerId)));
   const STRUCTURAL_RUNNERS = /* @__PURE__ */ new Set([
@@ -1982,20 +2155,48 @@ function buildCoverageNotice(ctx, runnerLatencies, dedupe) {
   const TYPE_CAPABLE_FALLBACK_RUNNERS = /* @__PURE__ */ new Set(["mypy"]);
   const anyFallbackHasCoverage = runnerLatencies.some((r) => fallbackRunnerIds.has(r.runnerId) && !STRUCTURAL_RUNNERS.has(r.runnerId) && hasUsableResult(r) && (!plan?.capabilities.includes("types") || TYPE_CAPABLE_FALLBACK_RUNNERS.has(r.runnerId)));
   if (anyFallbackHasCoverage)
-    return void 0;
+    return {};
+  const cause = combinePrimaryUnavailableCauses(relevant.flatMap((r) => r.primaryUnavailableCause ?? []));
+  const unconfirmedStatus = cause ? `no language server answered (${PRIMARY_UNAVAILABLE_CAUSE[cause]})` : "not fully checked (a language tool is missing, timed out, or failed to run)";
+  if (cause === "disabled" || cause === "disabledFallback") {
+    const disabledIds = [
+      ...new Set(relevant.flatMap((r) => r.disabledPrimaryServerIds ?? []))
+    ].sort((a, b) => Number(a > b) - Number(a < b));
+    const onceKeys = disabledIds.map((id) => `disabled-primary:${id}`);
+    if (dedupe) {
+      if (onceKeys.every((key2) => coverageNoticeSeen.has(key2)))
+        return { unconfirmedStatus };
+      for (const key2 of onceKeys)
+        coverageNoticeSeen.add(key2);
+    }
+    return {
+      notice: {
+        id: `coverage-disabled:${ctx.kind}:${disabledIds.join(",")}`,
+        message: cause === "disabled" ? `Pi-lens ${ctx.kind} analysis unconfirmed \u2014 Primary LSP (${disabledIds.join(", ")}) is disabled in config by lsp.disabledServers, so no language server checks these files this session (not a clean result).` : `Pi-lens ${ctx.kind} analysis unconfirmed \u2014 Primary LSP (${disabledIds.join(", ")}) is disabled in config by lsp.disabledServers and its fallback did not answer, so no language server checked these files (not a clean result).`,
+        filePath: ctx.filePath,
+        severity: "warning",
+        semantic: "warning",
+        tool: "pi-lens"
+      },
+      unconfirmedStatus
+    };
+  }
   const onceKey = `${ctx.kind}:${ctx.filePath}`;
   if (dedupe) {
     if (coverageNoticeSeen.has(onceKey))
-      return void 0;
+      return { unconfirmedStatus };
     coverageNoticeSeen.add(onceKey);
   }
   return {
-    id: `coverage-unavailable:${ctx.kind}:${path4.basename(ctx.filePath)}`,
-    message: `Pi-lens ${ctx.kind} analysis unavailable \u2014 a language tool is missing, timed out, or failed to run, or the LSP server isn't ready yet, so this file was not fully checked (not a clean result).`,
-    filePath: ctx.filePath,
-    severity: "warning",
-    semantic: "warning",
-    tool: "pi-lens"
+    notice: {
+      id: `coverage-unavailable:${ctx.kind}:${path4.basename(ctx.filePath)}`,
+      message: `Pi-lens ${ctx.kind} analysis unavailable \u2014 a language tool is missing, timed out, or failed to run, or the LSP server isn't ready yet, so this file was not fully checked (not a clean result).`,
+      filePath: ctx.filePath,
+      severity: "warning",
+      semantic: "warning",
+      tool: "pi-lens"
+    },
+    unconfirmedStatus
   };
 }
 var latencyReports = [];
@@ -2008,10 +2209,29 @@ function clearCoverageNoticeState() {
   coverageNoticeSeen.clear();
   generatedSkipRecorded.clear();
 }
+function runnerDispatchContext(ctx, runnerId) {
+  const owed = ctx.owedRanges?.get(runnerId);
+  if (!owed?.length || !ctx.modifiedRanges)
+    return ctx;
+  return {
+    ...ctx,
+    modifiedRanges: rangesOfLines([
+      ...linesOfRanges(ctx.modifiedRanges),
+      ...linesOfRanges(owed)
+    ])
+  };
+}
 async function runGroup(ctx, group, registry, onRunnerResult) {
   const diagnostics = [];
   const latencies = [];
   let hadBlocker = false;
+  const outOfEditScope = [];
+  const inconclusiveRunnerIds = [];
+  const inconclusiveServerIds = [];
+  const collectLaterRunnerIds = [];
+  const editScopedRunnerIds = [];
+  const answeredRunnerIds = [];
+  const coveredRunners = [];
   const runnerIds = group.filterKinds ? group.runnerIds.filter((id) => {
     const runner = registry.get(id);
     return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
@@ -2093,6 +2313,7 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       } catch (error) {
         ctx.log(`Runner ${runner.id} precondition failed: ${error}`);
         shouldRun = false;
+        inconclusiveRunnerIds.push(runner.id);
       }
     }
     if (!shouldRun) {
@@ -2117,10 +2338,11 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       continue;
     }
     const projectRoot = ctx.projectRoot ?? ctx.cwd;
+    const runnerCtx = runnerDispatchContext(ctx, runner.id);
     const observedTier = ctx.writeIndex === void 0 ? "inline" : classifyObservedRunner(projectRoot, runner.id);
     if (observedTier === "collect-later") {
       const markedAtMs = Date.now();
-      const deferred = runRunner(ctx, runner, semantic).then((result2) => {
+      const deferred = runRunner(runnerCtx, runner, semantic).then((result2) => {
         const durationMs = Date.now() - markedAtMs;
         const tier2 = observeRunnerLatency({
           projectRoot,
@@ -2187,6 +2409,8 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
         semantic
       });
       recordRunner(ctx.filePath, runner.id, "pending", 0, 0, ctx.writeIndex);
+      inconclusiveRunnerIds.push(runner.id);
+      collectLaterRunnerIds.push(runner.id);
       logLatency({
         type: "runner",
         filePath: ctx.filePath,
@@ -2199,7 +2423,7 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       });
       continue;
     }
-    const result = await runRunner(ctx, runner, semantic);
+    const result = await runRunner(runnerCtx, runner, semantic);
     onRunnerResult?.(runnerId, result);
     const runnerEnd = Date.now();
     const duration = runnerEnd - runnerStart;
@@ -2254,6 +2478,12 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       },
       ...result.deferredServerIds !== void 0 && {
         deferredServerIds: result.deferredServerIds
+      },
+      ...result.primaryUnavailableCause !== void 0 && {
+        primaryUnavailableCause: result.primaryUnavailableCause
+      },
+      ...result.disabledPrimaryServerIds !== void 0 && {
+        disabledPrimaryServerIds: result.disabledPrimaryServerIds
       }
     });
     logLatency({
@@ -2273,7 +2503,28 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       })) : void 0,
       metadata: failureRowMetadata(result) ?? (skipReason ? { skipReason, ...claimSource !== void 0 && { claimSource } } : void 0)
     });
-    recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
+    if (!ctx.preEditCapture)
+      recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
+    for (const d of result.diagnostics)
+      d.runnerId ??= runnerId;
+    for (const d of result.outOfEditScope ?? []) {
+      d.runnerId ??= runnerId;
+      outOfEditScope.push(d);
+    }
+    if (reachedNoVerdict(result))
+      inconclusiveRunnerIds.push(runnerId);
+    else {
+      answeredRunnerIds.push(runnerId);
+      if (result.coveredBy)
+        coveredRunners.push({
+          runnerId,
+          lane: result.coveredBy,
+          ran: result.skipReason !== "covered-by-primary"
+        });
+      if (result.editScopedVerdict === true)
+        editScopedRunnerIds.push(runnerId);
+    }
+    inconclusiveServerIds.push(...result.unconfirmedServerIds ?? [], ...result.deferredServerIds ?? []);
     diagnostics.push(...result.diagnostics);
     const resultSemantic = result.semantic ?? semantic;
     if (resultSemantic === "blocking" && result.diagnostics.length > 0 || result.diagnostics.some((d) => d.semantic === "blocking")) {
@@ -2283,22 +2534,50 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       break;
     }
   }
-  return { diagnostics, latencies, hadBlocker };
+  return {
+    diagnostics,
+    latencies,
+    hadBlocker,
+    outOfEditScope,
+    inconclusiveRunnerIds,
+    inconclusiveServerIds,
+    collectLaterRunnerIds,
+    editScopedRunnerIds,
+    answeredRunnerIds,
+    coveredRunners
+  };
 }
 async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
   const _overallStart = Date.now();
   if (ctx.analysisRootMode === "adopted") {
-    return {
-      diagnostics: [],
-      blockers: [],
-      warnings: [],
-      baselineWarningCount: 0,
-      fixed: [],
-      resolvedCount: 0,
-      output: "",
-      blockerOutput: "",
-      hasBlockers: false
-    };
+    const planned = groups.flatMap((g) => g.runnerIds);
+    groups = filterGroupsForAdoptedRoot(groups);
+    const admitted = new Set(groups.flatMap((g) => g.runnerIds));
+    logLatency({
+      type: "phase",
+      filePath: ctx.filePath,
+      phase: "dispatch_adopted_root_allowlist",
+      durationMs: 0,
+      metadata: {
+        admissionList: ADOPTED_ROOT_RUNNER_ALLOWLIST.join(","),
+        admitted: groups.flatMap((g) => g.runnerIds).join(","),
+        refused: planned.flatMap((id) => admitted.has(id) ? [] : [id]).join(","),
+        noAdmittedRunner: groups.length === 0
+      }
+    });
+    if (groups.length === 0) {
+      return {
+        diagnostics: [],
+        blockers: [],
+        warnings: [],
+        baselineWarningCount: 0,
+        fixed: [],
+        resolvedCount: 0,
+        output: "",
+        blockerOutput: "",
+        hasBlockers: false
+      };
+    }
   }
   if (ctx.fileRole === "generated") {
     const evidence = ctx.generatedEvidence;
@@ -2340,7 +2619,8 @@ async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
     metadata: {
       groupCount: groups.length,
       kind: ctx.kind,
-      runners: allRunnerIds.join(",")
+      runners: allRunnerIds.join(","),
+      ...ctx.preEditCapture && { preEditCapture: true }
     }
   });
   const groupResults = await Promise.all(groups.map((group) => runGroup(ctx, group, registry, onRunnerResult)));
@@ -2352,17 +2632,51 @@ async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
       reason: "dispatchForFile requires an absolute ctx.filePath to key the delta baseline (refs #2489)"
     });
   }
-  const baselineAbsKey = `session.baseline.${ctx.filePath}`;
+  const baselineAbsKey = deltaBaselineFactKey(ctx.filePath);
   const previousBaseline = ctx.deltaMode && baselinePathSafe ? ctx.facts.getBoundedSessionFact(baselineAbsKey) : void 0;
   const baselineWarnings = previousBaseline?.filter((d) => d.semantic === "warning" || d.semantic === "none");
   const baselineWarningCount = baselineWarnings?.length ?? 0;
-  for (const { diagnostics: groupDiags, latencies, hadBlocker } of groupResults) {
+  const outOfEditScope = [];
+  const inconclusiveRunnerIds = /* @__PURE__ */ new Set();
+  const inconclusiveServerIds = /* @__PURE__ */ new Set();
+  const collectLaterRunnerIds = /* @__PURE__ */ new Set();
+  const editScopedRunnerIds = [];
+  const answeredRunnerIds = /* @__PURE__ */ new Set();
+  const coveredRunners = [];
+  for (const { diagnostics: groupDiags, latencies, hadBlocker, outOfEditScope: groupOutOfScope, inconclusiveRunnerIds: groupRunnerIds, inconclusiveServerIds: groupServerIds, collectLaterRunnerIds: groupCollectLater, editScopedRunnerIds: groupEditScoped, answeredRunnerIds: groupAnswered, coveredRunners: groupCovered } of groupResults) {
     runnerLatencies.push(...latencies);
+    outOfEditScope.push(...groupOutOfScope);
+    for (const id of groupRunnerIds)
+      inconclusiveRunnerIds.add(id);
+    for (const id of groupServerIds)
+      inconclusiveServerIds.add(id);
+    for (const id of groupCollectLater)
+      collectLaterRunnerIds.add(id);
+    editScopedRunnerIds.push(...groupEditScoped);
+    for (const id of groupAnswered)
+      answeredRunnerIds.add(id);
+    coveredRunners.push(...groupCovered);
     allDiagnostics.push(...groupDiags);
     if (hadBlocker)
       stopped = true;
   }
-  const dedupedDiagnostics = dedupeOverlappingDiagnostics(allDiagnostics);
+  const voidedCovers = /* @__PURE__ */ new Set();
+  const laneCopyByRunner = /* @__PURE__ */ new Map();
+  for (const { runnerId, lane, ran } of coveredRunners) {
+    const silent = !answeredRunnerIds.has(lane.runnerId) || lane.serverId !== void 0 && inconclusiveServerIds.has(lane.serverId);
+    if (ran) {
+      if (silent)
+        continue;
+      laneCopyByRunner.set(runnerId, laneCopyStandsFor(allDiagnostics.flatMap((d) => d.runnerId === lane.runnerId && (lane.serverId === void 0 || d.serverId === lane.serverId) ? [d] : [])));
+      continue;
+    }
+    if (!silent)
+      continue;
+    voidedCovers.add(runnerId);
+    inconclusiveRunnerIds.add(runnerId);
+  }
+  const deliveredDiagnostics = laneCopyByRunner.size === 0 ? allDiagnostics : allDiagnostics.flatMap((d) => laneCopyByRunner.get(d.runnerId ?? "")?.(d) ? [] : [d]);
+  const dedupedDiagnostics = dedupeOverlappingDiagnostics(deliveredDiagnostics);
   const fileContent = ctx.facts.getFileFact(ctx.filePath, "file.content") ?? "";
   const rulePolicy = ctx.rulePolicy ?? rulePolicyMapFromConfig(loadPiLensProjectConfig(ctx.projectRoot ?? ctx.cwd).rules);
   const applyOutputFilters = (diags) => {
@@ -2377,11 +2691,33 @@ async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
   };
   let visibleDiagnostics = applyOutputFilters(dedupedDiagnostics);
   let resolvedCount = 0;
+  const stillObserved = outOfEditScope.length > 0 ? applyOutputFilters(outOfEditScope).flatMap((d) => d.semantic === "blocking" ? [d] : []) : [];
+  let heldBackBlockers = [];
   if (ctx.deltaMode && previousBaseline) {
     const filtered = filterDelta(visibleDiagnostics, applyOutputFilters(previousBaseline), (d) => d.id);
+    const isNew = new Set(filtered.new);
+    heldBackBlockers = visibleDiagnostics.filter((d) => d.semantic === "blocking" && !isNew.has(d));
+    stillObserved.push(...promoteDeltaUnusedToBlockers(visibleDiagnostics.flatMap((d) => !isNew.has(d) && d.semantic !== "blocking" && isUnusedValueDiagnostic(d) ? [d] : [])));
     visibleDiagnostics = promoteDeltaUnusedToBlockers(filtered.new);
     resolvedCount = filtered.fixed.length;
   }
+  const seedKey = preEditSeedFactKey(ctx.filePath);
+  const preEditSeed = ctx.deltaMode && baselinePathSafe ? ctx.facts.getBoundedSessionFact(seedKey) : void 0;
+  const seedContent = ctx.facts.getFileFact(ctx.filePath, "file.content");
+  let preExisting = [];
+  if (preEditSeed && seedContent !== void 0) {
+    const classified = classifyPreExisting(preEditSeed, [
+      ...visibleDiagnostics.filter((d) => d.semantic === "blocking"),
+      ...heldBackBlockers
+    ], seedContent, new Set([...answeredRunnerIds].filter((id) => !inconclusiveRunnerIds.has(id))));
+    if (classified.preExisting.length > 0) {
+      const held = new Set(classified.preExisting);
+      visibleDiagnostics = visibleDiagnostics.filter((d) => !held.has(d));
+      heldBackBlockers = heldBackBlockers.filter((d) => !held.has(d));
+      preExisting = classified.preExisting;
+    }
+    ctx.facts.setBoundedSessionFact(seedKey, classified.nextSeed);
+  }
   if (ctx.deltaMode && baselinePathSafe) {
     ctx.facts.setBoundedSessionFact(baselineAbsKey, [...dedupedDiagnostics]);
   }
@@ -2393,21 +2729,21 @@ async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
     provider: ctx.telemetryProvider
   };
   if (fixedItems.length > 0) {
-    import("./chunk-6SDEP3AJ.js").then(({ appendToWorklog }) => {
+    import("./chunk-JUKMK5Y4.js").then(({ appendToWorklog }) => {
       appendToWorklog(ctx.cwd, fixedItems, true, worklogIdentity);
     }).catch(() => {
     });
   }
   const fixableWarnings = warnings.filter((d) => d.fixable);
   if (fixableWarnings.length > 0) {
-    import("./chunk-6SDEP3AJ.js").then(({ appendToWorklog }) => {
+    import("./chunk-JUKMK5Y4.js").then(({ appendToWorklog }) => {
       appendToWorklog(ctx.cwd, fixableWarnings, false, worklogIdentity);
     }).catch(() => {
     });
   }
   const inlineBlockers = blockers;
   const inlineFixed = fixedItems;
-  const coverageNotice = buildCoverageNotice(ctx, runnerLatencies, options?.dedupeCoverageNotice ?? true);
+  const { notice: coverageNotice, unconfirmedStatus } = buildCoverageNotice(ctx, runnerLatencies, options?.dedupeCoverageNotice ?? true);
   const blockerOutput = formatDiagnostics(inlineBlockers, "blocking");
   let output = blockerOutput;
   output += formatDiagnostics(inlineFixed, "fixed");
@@ -2463,7 +2799,19 @@ async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
       // (above, `metadata: { groupCount, kind, runners }`) fires before the
       // baseline read ever runs and cannot carry either value.
       baselineHit: previousBaseline !== void 0,
-      baselineWarningCount
+      baselineWarningCount,
+      // #4484: blockers still observed that the delta did not call new.
+      heldBackBlockers: heldBackBlockers.length,
+      // #4483: whether a pre-edit seed was read, and the blocking linter
+      // findings it reported as pre-existing.
+      preEditSeed: preEditSeed !== void 0,
+      preExisting: preExisting.length,
+      ...ctx.preEditCapture && { preEditCapture: true },
+      // #4484 r2: findings that only keep a recorded blocker pending, and
+      // the sources whose silence is no evidence.
+      stillObserved: stillObserved.length,
+      inconclusiveRunners: inconclusiveRunnerIds.size,
+      inconclusiveServers: inconclusiveServerIds.size
     }
   });
   return {
@@ -2476,7 +2824,21 @@ async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
     resolvedCount,
     output,
     blockerOutput,
-    hasBlockers: blockers.length > 0
+    hasBlockers: blockers.length > 0,
+    ...heldBackBlockers.length > 0 && { heldBackBlockers },
+    ...preExisting.length > 0 && { preExisting },
+    ...stillObserved.length > 0 && { stillObserved },
+    ...editScopedRunnerIds.some((id) => !voidedCovers.has(id)) && {
+      editScopedRunnerIds: editScopedRunnerIds.flatMap((id) => voidedCovers.has(id) ? [] : [id])
+    },
+    ...(inconclusiveRunnerIds.size > 0 || inconclusiveServerIds.size > 0) && {
+      inconclusiveSources: {
+        runnerIds: [...inconclusiveRunnerIds],
+        serverIds: [...inconclusiveServerIds],
+        collectLaterRunnerIds: [...collectLaterRunnerIds]
+      }
+    },
+    ...unconfirmedStatus !== void 0 && { unconfirmedStatus }
   };
 }
 var RUNNER_TIMEOUT_MS = RUNTIME_CONFIG.dispatch.runnerTimeoutMs;
@@ -2557,6 +2919,16 @@ var DEFAULT_NEIGHBOUR_BUDGET = 40;
 var CASCADE_NEIGHBOUR_BUDGET = Math.max(MIN_NEIGHBOUR_BUDGET, Number.parseInt(process.env.PI_LENS_CASCADE_NEIGHBOUR_BUDGET ?? "40", 10) || DEFAULT_NEIGHBOUR_BUDGET);
 var NEIGHBOUR_BUDGET_OVERRIDDEN = process.env.PI_LENS_CASCADE_NEIGHBOUR_BUDGET !== void 0 && CASCADE_NEIGHBOUR_BUDGET !== DEFAULT_NEIGHBOUR_BUDGET;
 
+// dist/clients/dispatch/runners/utils.js
+import * as fs4 from "node:fs";
+function readFileContent(filePath) {
+  try {
+    return fs4.readFileSync(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+
 // dist/clients/dispatch/utils/lsp-diagnostics.js
 function convertLspDiagnostics(diags, filePath, options = {}) {
   const tool = options.tool ?? "lsp";
@@ -2585,7 +2957,10 @@ function convertLspDiagnostics(diags, filePath, options = {}) {
       autoFixAvailable: false,
       fixKind: hasSuggestion ? "suggestion" : void 0,
       fixSuggestion: options.fixSuggestionByIndex?.get(idx),
-      scanOrigin: options.scanOrigin
+      scanOrigin: options.scanOrigin,
+      // #4484 r2: the publishing server, so a run that leaves it
+      // unconfirmed keeps its recorded blockers. Never identity.
+      ...d.serverId !== void 0 && { serverId: d.serverId }
     };
   });
 }
@@ -2599,7 +2974,8 @@ function applyFindingPolicy(diagnostics, options) {
       root: options.cwd,
       filePath: options.filePath
     }),
-    inlineKept
+    inlineKept,
+    disposed
   };
 }
 function loadProjectRulePolicyMap(cwd) {
@@ -2664,6 +3040,28 @@ function applyPushedFindingPolicy(findings, options) {
   });
   return { kept, suppressed: findings.length - kept.length };
 }
+function applyPushedFindingPolicyByFile(findings, cwd) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const group = byFile.get(finding.filePath);
+    if (group)
+      group.push(finding);
+    else
+      byFile.set(finding.filePath, [finding]);
+  }
+  const kept = [];
+  let suppressed = 0;
+  for (const [filePath, group] of byFile) {
+    const policy = applyPushedFindingPolicy(group, {
+      cwd,
+      filePath,
+      content: readFileContent(filePath)
+    });
+    kept.push(...policy.kept);
+    suppressed += policy.suppressed;
+  }
+  return { kept, suppressed };
+}
 function expandRenderedIdentities(rendered) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2774,6 +3172,12 @@ function formatCacheAgeLabel(scannedAt, nowMs = Date.now()) {
   const remMinutes = ageMinutes % 60;
   return remMinutes === 0 ? `scanned ${ageHours}h ago` : `scanned ${ageHours}h ${remMinutes}m ago`;
 }
+function dispositionSuppressedLine(suppressed, breakdown) {
+  if (suppressed <= 0)
+    return void 0;
+  const lanes = breakdown ? ` (${breakdown})` : "";
+  return `suppressed by disposition: ${suppressed} finding(s)${lanes} 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 admitsProjectWideFindings(sessionRole) {
   return sessionRole === "primary";
 }
@@ -2887,6 +3291,17 @@ var DELIVERY_SURFACES = {
     { evidenceMin: 2 }
   ),
   "runtime-turn:cascade-blocker": labeled(RUNTIME_TURN_FILE, "Turn-end \u{1F9EA} cascade neighbor blocker.", "Cascade results settle synchronously this turn where possible (`settleCascadeRuns`), but an unsettled compute can carry over to a later turn (bounded by a carry cap) \u2014 a carried-over result renders with an explicit `(carried N turns \xB7 scanned Xm ago)` label (#3167, #3168 F3), so the agent can tell it from a fresh observation.", "live", ["cascadeCarrySuffix("], { evidenceMin: 1 }),
+  // #4487: cascade neighbour errors a cascade showed in an EARLIER turn and
+  // no later cascade or edit has shown gone. A cached claim, not a fresh
+  // observation, so each entry passes the freshness gate against its own
+  // read bound (`checkedAt`) before it renders (#4495 review F1, round 3):
+  // a deleted neighbour is forgotten; one written after the check by
+  // something pi never saw is named once as changed and not re-checked.
+  // Survivors carry the `(scanned Xm ago)` age of that read. The evidence is
+  // the two RENDERED lists, so the binding chain walks each back to the gate
+  // call's own arms (a render of the ungated candidates reds, #4495 r2
+  // verify census note).
+  "runtime-turn:cascade-pending-errors": gated(RUNTIME_TURN_FILE, "Turn-end \u{1F4D0} list of cascade neighbour errors shown in an earlier turn and not re-checked since.", ["gateFindingsByPathFreshness"], ["unresolvedNeighbors", "changedShown"]),
   "runtime-turn:cascade-coverage-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end cascade-coverage-gap advisories (graph/binding/budget).", "Explains what the cascade check could NOT confirm this turn \u2014 not a finding with a cited path, an absence-of-coverage disclosure computed from this turn's own indeterminate-run list. An advisory computed from a carried indeterminate run is labeled `(carried N turns \xB7 <age>)` (#3167, #3168 F4 \u2014 dropped on mixed carried/fresh buckets). The age half reads `scan age unknown` on this surface today: no indeterminate-run producer stamps `observedAt` (only the resolved-found plumb does, `clients/cascade-format.ts`), and one unstamped carried run collapses the whole bucket's age rather than claiming the stamped runs' (#3168 F13). The carry COUNT is always real.", "live", ["withCarryLabel("], { evidenceMin: 3 }),
   // #3102: the cold-neighbour cascade run is BUILT here, in the quiet-window
   // reconcile (`onResolvedFound` in index.ts), a turn earlier than the
@@ -2975,16 +3390,185 @@ var DELIVERY_SURFACES = {
   "read-guard-tool-lines:preflight-errors": labeled("clients/read-guard-tool-lines.ts", "Read-guard hashline BLOCKED / RE-READ REQUIRED / PARTIAL APPLY / ALREADY APPLIED preflight errors (#2402).", "Computed fresh per edit attempt and returned as that attempt's rejection \u2014 no cached findings are replayed, so there is no staleness window. The PARTIAL APPLY and ALREADY APPLIED variants describe the same attempt's commit outcome; applied-edit recognition reads RuntimeCoordinator's session-scoped record, which resets with the session.", "live"),
   "mutating-tool:adapter-preflight-errors": labeled("clients/mutating-tool.ts", "Shape-adapter BLOCKED preflight errors for hashline edit inputs the adapter recognized but could not resolve to a range (#2423).", "Computed fresh from the tool input on each attempt and returned as that attempt's rejection, so there is no staleness window. The adapters read only the call's own arguments; nothing cached is replayed.", "live"),
   "tool-call:duplicate-export-blocker": labeled("clients/runtime-tool-call.ts", "Duplicate-export STOP rejection returned inline with the failed edit.", "Synchronous preflight rejection computed per edit attempt; no stored state.", "live"),
-  "agent-behavior:thrashing-notice": labeled("clients/agent-behavior-client.ts", "In-result thrashing/blind-write detection notice.", "Ephemeral notice computed at detection time inside the same tool result \u2014 no persistence and no cache, so nothing can be stale.", "live")
+  "agent-behavior:thrashing-notice": labeled("clients/agent-behavior-client.ts", "In-result thrashing/blind-write detection notice.", "Ephemeral notice computed at detection time inside the same tool result \u2014 no persistence and no cache, so nothing can be stale.", "live"),
+  // ── #1634 enumeration round: the rest of the agent-facing sinks ─────────
+  // Found by the sink census in `tests/clients/finding-delivery-gate.test.ts`,
+  // which derives every production file holding an agent-facing sink (a tool
+  // result's text block, a context or hook message, a tool_call block, a
+  // custom entry, a status/widget line) and fails on one that is neither a
+  // surface `file` here nor classified there.
+  "lsp-navigation:workspace-diagnostics-path": gated(
+    "tools/lsp-navigation.ts",
+    "`lsp_navigation workspaceDiagnostics` with a path: the server's answer for that file, read after a touch that waits for diagnostics.",
+    ["applyProbeFindingPolicy"],
+    // The path read and the tracked snapshot below are the two calls.
+    ["applyProbeFindingPolicy("],
+    { evidenceMin: 2 }
+  ),
+  "lsp-navigation:tracked-snapshot": labeled("tools/lsp-navigation.ts", "`lsp_navigation workspaceDiagnostics` with no path: each tracked file's last client publish.", "A replay of what each language client last published, with no re-check of the file, so every row states its age. The rows also pass the same finding policy as the path read (`readFileContent` supplies the current content), so the label and the disposition filter compose.", "LSP client publish ts", ["lag: formatCacheAgeLabel(ts)", "readFileContent(trackedFile)"]),
+  "runtime-context:persisted-findings": gated(
+    "clients/runtime-context.ts",
+    "Persisted turn-end and test-runner findings replayed into the next context message, the MCP turn_end tool and the Stop hook.",
+    ["validateAdvisoryProvenance"],
+    // peekTurnEndFindings, consumeTurnEndFindings, peekTestFindings.
+    ["validateAdvisoryProvenance(findings.data, cwd, runtime)"],
+    { evidenceMin: 3 }
+  ),
+  "index:turn-summary": labeled("index.ts", "One-line turn summary custom entry (`--lens-turn-summary`).", "Counts drained from this turn's own accumulator (`runtime.turnSummary.consume`) at the quiet window; nothing is replayed from a cache.", "live"),
+  "lens-engine:project-scan": gated("clients/lens-engine.ts", "`pilens_project_scan` (MCP): a fresh cheap project scan.", ["applyPushedFindingPolicyByFile"], ["applyPushedFindingPolicyByFile(scan.diagnostics, cwd)"]),
+  "mcp-server:analyze": labeled("mcp/server.ts", "`pilens_analyze` (MCP): one file's dispatch result.", "A dispatch run for this call, warm or in a fresh worker; the dispatcher applies the finding policy before it returns.", "live"),
+  "mcp-analyze-cli:post-edit-report": labeled("mcp/analyze-cli.ts", "Claude Code PostToolUse hook report (`analyze-cli --hook`).", "Same per-call dispatch as `pilens_analyze`; its Stop-hook output is the `runtime-context:persisted-findings` replay or a fresh turn-end pass.", "live")
 };
 
 // dist/clients/cascade-format.js
+function formatCascadeNeighborDiagnostics(cwd, neighbors, options = {}) {
+  const withErrors = neighbors.filter((n) => n.diagnostics.length > 0);
+  const inconclusive = neighbors.filter((n) => n.inconclusive === true && n.diagnostics.length === 0);
+  const uncovered = neighbors.filter((n) => n.diagnostics.length === 0 && n.inconclusive !== true && (n.unconfirmedServerIds?.length ?? 0) > 0);
+  if (withErrors.length === 0 && inconclusive.length === 0 && uncovered.length === 0) {
+    return "";
+  }
+  const noun = options.noun ?? "neighbor";
+  let out = withErrors.length > 0 ? `\u{1F4D0} Cascade errors in ${withErrors.length} ${noun} file(s) \u2014 fix before finishing turn:` : "";
+  for (const neighbor of withErrors) {
+    const display = toRunnerDisplayPath(cwd, neighbor.filePath);
+    const reason = options.includeReason ? ` reason="${neighbor.reason}"` : "";
+    out += `
+<diagnostics file="${display}"${reason}>`;
+    for (const d of neighbor.diagnostics) {
+      const line = d.line ?? 1;
+      const col = d.column ?? 1;
+      const rule = d.rule ? ` rule=${d.rule}` : "";
+      const since = options.stillPresentSince?.(neighbor, d);
+      const label = since === void 0 ? "" : ` (still present since turn ${since})`;
+      out += `
+  line ${line}, col ${col}${rule}: ${d.message.split("\n")[0].slice(0, 100)}${label}`;
+    }
+    out += "\n</diagnostics>";
+  }
+  if (inconclusive.length > 0) {
+    if (out)
+      out += "\n";
+    out += `\u26A0\uFE0F Cascade diagnostics inconclusive for ${inconclusive.length} ${noun} file(s) \u2014 no clean result was confirmed:`;
+    for (const neighbor of inconclusive) {
+      out += `
+  ${toRunnerDisplayPath(cwd, neighbor.filePath)}`;
+    }
+  }
+  if (uncovered.length > 0) {
+    if (out)
+      out += "\n";
+    out += `\u26A0\uFE0F Cascade scanners did not cover ${uncovered.length} ${noun} file(s) \u2014 no findings does NOT mean clean here:`;
+    for (const neighbor of uncovered) {
+      const servers = (neighbor.unconfirmedServerIds ?? []).join(", ");
+      out += `
+  ${toRunnerDisplayPath(cwd, neighbor.filePath)} (not scanned by ${servers})`;
+    }
+  }
+  return out;
+}
+function composeCascadeSection(block, layout, unansweredPrimaryNote = "") {
+  const diagnosticsBlock = block && unansweredPrimaryNote ? `${block}
+${unansweredPrimaryNote}` : block || unansweredPrimaryNote;
+  if (!diagnosticsBlock && !layout.coverageLine)
+    return "";
+  let out = !diagnosticsBlock ? "" : layout.header ? `${layout.header}
+${diagnosticsBlock}` : diagnosticsBlock;
+  if (layout.truncationLine)
+    out += `
+${layout.truncationLine}`;
+  if (layout.coverageLine) {
+    if (out)
+      out += "\n";
+    out += layout.coverageLine;
+  }
+  if (layout.policySuppressed > 0) {
+    out += `
+suppressed by disposition: ${layout.policySuppressed} finding(s) (marked false-positive or won't-fix).`;
+  }
+  return out;
+}
 function cascadeCarrySuffix(carriedTurns, observedAt) {
   if (carriedTurns === void 0 || carriedTurns < 1)
     return void 0;
   const noun = carriedTurns === 1 ? "turn" : "turns";
   return `(carried ${carriedTurns} ${noun} \xB7 ${formatCacheAgeLabel(observedAt)})`;
 }
+var cascadeUnansweredPrimariesDelivered = /* @__PURE__ */ new Set();
+function resetCascadeUnansweredPrimariesDelivered() {
+  cascadeUnansweredPrimariesDelivered.clear();
+}
+function markCascadeUnansweredPrimariesDelivered(serverIds) {
+  for (const id of serverIds)
+    cascadeUnansweredPrimariesDelivered.add(id);
+}
+function renderCascadeResult(result, shownServerIds) {
+  const unanswered = result.unansweredPrimaries;
+  if (!unanswered)
+    return { text: result.formatted, lines: [], serverIds: [] };
+  const kept = unanswered.notes.filter((note) => note.serverIds.some((id) => !cascadeUnansweredPrimariesDelivered.has(id) && !shownServerIds.has(id)));
+  const serverIds = kept.flatMap((note) => [...note.serverIds]);
+  for (const id of serverIds)
+    shownServerIds.add(id);
+  return {
+    text: unanswered.formattedWithoutNotes,
+    lines: kept.map((note) => note.line),
+    serverIds
+  };
+}
+var MAX_PENDING_NEIGHBORS = 256;
+var pendingNeighbors = new BoundedFifoMap(MAX_PENDING_NEIGHBORS);
+function cascadeErrorKey(diagnostic) {
+  return [
+    diagnostic.id,
+    diagnostic.rule ?? "",
+    diagnostic.line ?? 0,
+    diagnostic.column ?? 0,
+    diagnostic.message
+  ].join(":");
+}
+function cascadeStillPresentSince(filePath, diagnostic, turn) {
+  const first = pendingNeighbors.get(normalizeMapKey(filePath))?.errors.get(cascadeErrorKey(diagnostic));
+  return first !== void 0 && first < turn ? first : void 0;
+}
+function recordDeliveredCascadeNeighbor(filePath, diagnostics, turn, checkedAt) {
+  const key2 = normalizeMapKey(filePath);
+  const previous = pendingNeighbors.get(key2);
+  const errors = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    const k = cascadeErrorKey(d);
+    errors.set(k, previous?.errors.get(k) ?? turn);
+  }
+  pendingNeighbors.delete(key2);
+  if (errors.size === 0)
+    return;
+  if (pendingNeighbors.set(key2, { filePath, errors, checkedAt }).length > 0) {
+    recordDegradationOnce({
+      kind: "cascade-pending-neighbors-evicted",
+      subject: `cap=${MAX_PENDING_NEIGHBORS}`,
+      reason: "the pending cascade neighbour-error record hit its cap; the oldest neighbour's errors are no longer re-served"
+    });
+  }
+}
+function forgetCascadePendingNeighbor(filePath, observedAt) {
+  const key2 = normalizeMapKey(filePath);
+  const entry = pendingNeighbors.get(key2);
+  if (!entry)
+    return;
+  if (observedAt !== void 0 && observedAt <= entry.checkedAt)
+    return;
+  pendingNeighbors.delete(key2);
+}
+function listCascadePendingNeighbors() {
+  return [...pendingNeighbors.values()].map((entry) => ({
+    filePath: entry.filePath,
+    errorCount: entry.errors.size,
+    checkedAt: entry.checkedAt
+  }));
+}
+function resetCascadePendingNeighbors() {
+  pendingNeighbors.clear();
+}
 
 // dist/clients/cascade-logger.js
 import * as path5 from "node:path";
@@ -3097,33 +3681,152 @@ function createDiagnosticTracker() {
 }
 
 // dist/clients/lsp/cascade-tier.js
+var MAX_OUTSTANDING_TOUCHES = 256;
 var OUTSTANDING_TOUCH_MAX_AGE_MS = 15 * 6e4;
-var _outstandingTouches = /* @__PURE__ */ new Map();
+var _outstandingTouches = new BoundedFifoMap(MAX_OUTSTANDING_TOUCHES);
 var _expiredSinceLastSweep = 0;
 var _evictedSinceLastSweep = 0;
+var MAX_LOGGED_PATHS = 20;
+function pruneExpiredOutstandingTouches(now, guard, reads = /* @__PURE__ */ new Map()) {
+  const expired = [];
+  for (const [key2, touch] of _outstandingTouches) {
+    if (now - touch.touchedAt <= OUTSTANDING_TOUCH_MAX_AGE_MS)
+      break;
+    _outstandingTouches.delete(key2);
+    _expiredSinceLastSweep++;
+    expired.push(touch);
+  }
+  if (expired.length === 0)
+    return;
+  let found = 0;
+  let clean = 0;
+  for (const touch of expired) {
+    const outcome = readTouchedClient(touch, now, reads);
+    if (!outcome)
+      continue;
+    if (outcome.outcome === "resolved-found")
+      found++;
+    else
+      clean++;
+    deliverResolvedOutcome(outcome, guard);
+  }
+  logCascade({
+    phase: "cascade_tier3_expired",
+    filePath: "<cascade-registry>",
+    metadata: {
+      count: expired.length,
+      found,
+      clean,
+      unanswered: expired.length - found - clean,
+      maxAgeCapMs: OUTSTANDING_TOUCH_MAX_AGE_MS,
+      paths: expired.slice(0, MAX_LOGGED_PATHS).map((t) => t.filePath),
+      ...expired.length > MAX_LOGGED_PATHS && {
+        pathsTruncated: expired.length - MAX_LOGGED_PATHS
+      }
+    }
+  });
+}
+function readTouchedClient(touch, now, reads) {
+  const client = touch.client?.deref();
+  if (!client || client.serverId !== touch.serverId)
+    return void 0;
+  if (client.isAlive?.() === false)
+    return void 0;
+  let all = reads.get(client);
+  if (all === void 0) {
+    all = client.getAllDiagnostics();
+    reads.set(client, all);
+  }
+  const entry = all.get(normalizeMapKey(touch.filePath));
+  if (!entry || entry.ts <= touch.touchedAt)
+    return void 0;
+  const found = entry.diags.length > 0;
+  return {
+    filePath: touch.filePath,
+    serverId: touch.serverId,
+    outcome: found ? "resolved-found" : "resolved-clean",
+    ageMs: now - touch.touchedAt,
+    diagnosticCount: entry.diags.length,
+    publishedAt: entry.ts,
+    touchedAt: touch.touchedAt,
+    ...found && { diagnostics: entry.diags }
+  };
+}
+function deliverResolvedOutcome(o, guard) {
+  try {
+    if (o.outcome === "resolved-found" && o.diagnostics?.length) {
+      const neighbor = {
+        filePath: o.filePath,
+        serverId: o.serverId,
+        diagnostics: o.diagnostics,
+        ...o.publishedAt !== void 0 ? { publishedAt: o.publishedAt } : {},
+        ...o.touchedAt !== void 0 ? { touchedAt: o.touchedAt } : {}
+      };
+      const deliver = () => _reconcileOptions.onResolvedFound?.(neighbor);
+      if (guard)
+        guard.guardedWrite(o.filePath, deliver);
+      else
+        deliver();
+    } else if (o.outcome === "resolved-clean" && o.publishedAt != null) {
+      _reconcileOptions.onResolvedClean?.({
+        filePath: o.filePath,
+        serverId: o.serverId,
+        publishedAt: o.publishedAt
+      });
+    }
+  } catch {
+  }
+}
 function resetCascadeTierSessionState() {
+  const dropped = _outstandingTouches.size;
   _outstandingTouches.clear();
   _expiredSinceLastSweep = 0;
   _evictedSinceLastSweep = 0;
+  if (dropped > 0) {
+    logCascade({
+      phase: "cascade_tier3_dropped",
+      filePath: "<session-reset>",
+      metadata: { count: dropped }
+    });
+  }
 }
+function peekOutstandingCascadeTouches(guard) {
+  const now = Date.now();
+  const reads = /* @__PURE__ */ new Map();
+  pruneExpiredOutstandingTouches(now, guard, reads);
+  const count = _outstandingTouches.size;
+  if (count === 0)
+    return;
+  let found = 0;
+  let clean = 0;
+  for (const [key2, touch] of _outstandingTouches) {
+    const outcome = readTouchedClient(touch, now, reads);
+    if (!outcome)
+      continue;
+    _outstandingTouches.delete(key2);
+    if (outcome.outcome === "resolved-found")
+      found++;
+    else
+      clean++;
+    deliverResolvedOutcome(outcome, guard);
+  }
+  logCascade({
+    phase: "cascade_tier3_peek",
+    filePath: "<turn_end>",
+    metadata: {
+      count,
+      found,
+      clean,
+      outstanding: _outstandingTouches.size
+    }
+  });
+}
+var _reconcileOptions = {};
 
 // dist/clients/dispatch/runners/ast-grep-napi.js
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as path6 from "node:path";
 
-// dist/clients/deps/ast-grep-napi.js
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-var _require = createRequire(import.meta.url);
-function loadAstGrepNapi() {
-  try {
-    const entry = _require.resolve("@ast-grep/napi");
-    return import(pathToFileURL(entry).href);
-  } catch {
-    return import("@ast-grep/napi");
-  }
-}
-
 // dist/clients/dispatch/priorities.js
 var PRIORITY = {
   LSP_PRIMARY: 4,
@@ -3140,6 +3843,66 @@ var PRIORITY = {
   DEEP_LANGUAGE_ANALYSIS: 50
 };
 
+// dist/clients/dispatch/runners/ast-grep-literal-anchors.js
+var PATTERN_WORD = /\$?[A-Za-z_]\w*/g;
+var LITERAL_REGEX = /^\^?((?:[A-Za-z0-9_"'`:\- =!<>/@#%&,;~]|\\\.)+)\$?$/;
+var RELATIONAL_KEYS = ["has", "inside", "follows", "precedes"];
+function ownLiterals(node) {
+  const literals = [];
+  if (typeof node.pattern === "string") {
+    for (const word of node.pattern.match(PATTERN_WORD) ?? []) {
+      if (!word.startsWith("$"))
+        literals.push(word);
+    }
+  }
+  const regex = typeof node.regex === "string" ? node.regex : "";
+  const literal = LITERAL_REGEX.exec(regex)?.[1];
+  if (literal)
+    literals.push(literal.replaceAll(String.raw`\.`, "."));
+  return literals;
+}
+function anyOf(branches) {
+  if (branches.length === 0 || branches.includes(true))
+    return true;
+  return { or: branches };
+}
+function requirementOf(node, utils, resolving) {
+  if (!node || typeof node !== "object")
+    return true;
+  const of = (child) => requirementOf(child, utils, resolving);
+  const parts = [
+    ...ownLiterals(node),
+    ...RELATIONAL_KEYS.map((key2) => of(node[key2])),
+    ...Array.isArray(node.all) ? node.all.map(of) : [],
+    Array.isArray(node.any) ? anyOf(node.any.map(of)) : true
+  ];
+  const name = node.matches;
+  if (typeof name === "string" && utils != null && Object.hasOwn(utils, name) && !resolving.has(name)) {
+    parts.push(requirementOf(utils[name], utils, /* @__PURE__ */ new Set([...resolving, name])));
+  }
+  const required = parts.filter((part) => part !== true);
+  return required.length === 0 ? true : { and: required };
+}
+function satisfied(requirement, text) {
+  if (requirement === true)
+    return true;
+  if (typeof requirement === "string")
+    return text.includes(requirement);
+  if ("and" in requirement) {
+    return requirement.and.every((part) => satisfied(part, text));
+  }
+  return requirement.or.some((part) => satisfied(part, text));
+}
+var requirements = /* @__PURE__ */ new WeakMap();
+function ruleCanMatchText(rule, text) {
+  let requirement = requirements.get(rule);
+  if (requirement === void 0) {
+    requirement = requirementOf(rule.rule, rule.utils, /* @__PURE__ */ new Set());
+    requirements.set(rule, requirement);
+  }
+  return satisfied(requirement, text);
+}
+
 // dist/clients/dispatch/runners/ast-grep-napi.js
 var defaultUnsupportedLanguageLog = /* @__PURE__ */ new Set();
 var UNSUPPORTED_RULE_ID_SAMPLE_SIZE = 5;
@@ -3657,12 +4420,19 @@ function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}) {
       }
       if (!rule.rule)
         continue;
+      if (options.content !== void 0 && !ruleCanMatchText(rule, options.content)) {
+        continue;
+      }
       try {
         const scopes = runsInsideHtmlScript ? htmlInjections.map((injection) => ({
           root: injection.root,
           position(match) {
             const start = match.range().start;
             return filePositionForIndex(fileLineStarts, injection.startIndex + start.index);
+          },
+          endLine(match) {
+            const end = match.range().end;
+            return filePositionForIndex(fileLineStarts, injection.startIndex + end.index).line;
           }
         })) : [
           {
@@ -3670,6 +4440,9 @@ function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}) {
             position(match) {
               const start = match.range().start;
               return { line: start.line, column: start.column };
+            },
+            endLine(match) {
+              return match.range().end.line;
             }
           }
         ];
@@ -3679,7 +4452,9 @@ function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}) {
         if (rule.utils)
           nativeConfig.utils = rule.utils;
         const collected = [];
+        const withheld = [];
         let rejectLogged = false;
+        const editScoped = options.modifiedRanges !== void 0 && normalizeRuleSeverity(rule.severity) === "error";
         for (const scope of scopes) {
           let found;
           try {
@@ -3694,19 +4469,23 @@ function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}) {
           for (const match of found) {
             if (collected.length >= maxMatchesPerRule)
               break;
-            collected.push({ match, position: scope.position(match) });
+            const position = scope.position(match);
+            if (editScoped && !spanOverlapsModifiedRanges(position.line + 1, scope.endLine(match) + 1, options.modifiedRanges)) {
+              if (withheld.length < maxMatchesPerRule)
+                withheld.push({ position });
+              continue;
+            }
+            collected.push({ match, position });
           }
           if (collected.length >= maxMatchesPerRule)
             break;
         }
-        for (const { position } of collected) {
-          if (diagnostics.length >= maxTotalDiagnostics)
-            break;
+        const toDiagnostic3 = (position) => {
           const severity = normalizeRuleSeverity(rule.severity);
           const semantic = severity === "error" ? "blocking" : "warning";
           const defectClass = classifyDefect(rule.id, "ast-grep-napi", rule.message || rule.id);
           const ruleFix = explicitRuleFixSuggestion(rule);
-          diagnostics.push({
+          return {
             id: `ast-grep-napi-${position.line}-${rule.id}`,
             message: `[${rule.metadata?.category || "slop"}] ${rule.message || rule.id}`,
             filePath,
@@ -3721,7 +4500,15 @@ function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}) {
             autoFixAvailable: false,
             fixKind: ruleFix ? "suggestion" : void 0,
             fixSuggestion: semantic === "blocking" ? ruleFix ?? defaultFixSuggestion(defectClass, rule.id) : ruleFix
-          });
+          };
+        };
+        for (const { position } of collected) {
+          if (diagnostics.length >= maxTotalDiagnostics)
+            break;
+          diagnostics.push(toDiagnostic3(position));
+        }
+        for (const { position } of withheld) {
+          options.outOfEditScope?.push(toDiagnostic3(position));
         }
         if (diagnostics.length >= maxTotalDiagnostics)
           break;
@@ -3743,8 +4530,10 @@ var astGrepNapiRunner = {
     }
     const astGrepLspEnabled = enabledAuxiliaryLspServerIds((f) => ctx.pi?.getFlag?.(f)).includes("ast-grep");
     const astGrepLspPublished = astGrepLspEnabled ? await hasAuxiliaryLspPublishedForRoot("ast-grep", ctx.filePath) : false;
-    if (astGrepLspEnabled && astGrepLspPublished) {
-      if (hasPendingAuxiliaryCoverage(ctx.filePath, "ast-grep")) {
+    const coveredByServer = astGrepLspEnabled && astGrepLspPublished;
+    if (coveredByServer && !ctx.recordedRunnerIds?.has("ast-grep-napi")) {
+      const coveragePending = hasPendingAuxiliaryCoverage(ctx.filePath, "ast-grep");
+      if (coveragePending) {
         incrementDegradationCount({
           kind: "aux-runner-findings-lost",
           subject: "ast-grep",
@@ -3753,13 +4542,23 @@ var astGrepNapiRunner = {
           reason: `Gate B skipped napi: pending late-auxiliary pair from an EARLIER touch remains undelivered while prior publication satisfies per-file gate (file: ${ctx.filePath})`
         });
       }
-      return { status: "skipped", diagnostics: [], semantic: "none" };
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        // Round 7: the verdict holds only if the server's host answered.
+        ...coveragePending ? {} : {
+          skipReason: "covered-by-primary",
+          coveredBy: { runnerId: "lsp", serverId: "ast-grep" }
+        },
+        ...ctx.blockingOnly && ctx.modifiedRanges?.length ? { editScopedVerdict: true } : {}
+      };
     }
     const sgModule = await loadSg();
     if (!sgModule) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
-    if (!fs4.existsSync(ctx.filePath)) {
+    if (!fs5.existsSync(ctx.filePath)) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const lang = getLang(ctx.filePath, sgModule);
@@ -3768,7 +4567,7 @@ var astGrepNapiRunner = {
     }
     let stats;
     try {
-      stats = fs4.statSync(ctx.filePath);
+      stats = fs5.statSync(ctx.filePath);
     } catch {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
@@ -3781,7 +4580,7 @@ var astGrepNapiRunner = {
       content = contentFromFacts;
     } else {
       try {
-        content = fs4.readFileSync(ctx.filePath, "utf-8");
+        content = fs5.readFileSync(ctx.filePath, "utf-8");
       } catch {
         return { status: "skipped", diagnostics: [], semantic: "none" };
       }
@@ -3803,10 +4602,16 @@ var astGrepNapiRunner = {
       recordNapiFallbackCoverage(ctx.filePath);
       clearPendingAuxiliaryCoverage(ctx.filePath, "ast-grep");
     }
+    const outOfEditScope = [];
     const diagnostics = evaluateAstGrepRules(ctx.filePath, rootNode, ctx.cwd, ctx.kind, {
       blockingOnly: runningAsLspSubstitute ? false : ctx.blockingOnly,
       projectRoot: ctx.projectRoot,
       rulePolicy: ctx.rulePolicy,
+      // #4481: keyed off the per-edit pass, not the substitute floor
+      // above, so a pre-existing blocker on an unchanged line never
+      // STOPs the write in either role.
+      modifiedRanges: ctx.blockingOnly ? ctx.modifiedRanges : void 0,
+      outOfEditScope,
       log: (message) => ctx.log(message),
       content,
       sgModule
@@ -3836,10 +4641,16 @@ var astGrepNapiRunner = {
     } else if (diagnostics.length > 0) {
       semantic = "warning";
     }
-    return findingsResult(diagnostics, {
-      status: hasBlocking ? "failed" : "succeeded",
-      semantic
-    });
+    return {
+      ...findingsResult(diagnostics, {
+        status: hasBlocking ? "failed" : "succeeded",
+        semantic
+      }),
+      ...outOfEditScope.length > 0 && { outOfEditScope },
+      ...coveredByServer && {
+        coveredBy: { runnerId: "lsp", serverId: "ast-grep" }
+      }
+    };
   }
 };
 var ast_grep_napi_default = astGrepNapiRunner;
@@ -4380,7 +5191,7 @@ var biomeCheckJsonRunner = {
 var biome_check_default = biomeCheckJsonRunner;
 
 // dist/clients/dispatch/runners/cpp-check.js
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 import * as path9 from "node:path";
 var compilerCheckers = {
   clang: createAvailabilityChecker("clang", ".exe"),
@@ -4419,7 +5230,7 @@ var CPP_HEADER_EXTENSIONS = /* @__PURE__ */ new Set([
 ]);
 function headerLooksLikeCpp(absPath) {
   try {
-    const content = fs5.readFileSync(absPath, "utf-8");
+    const content = fs6.readFileSync(absPath, "utf-8");
     return /\b(namespace|template|class|constexpr|concept|using)\b|std::|\b(public|private|protected)\s*:/.test(content);
   } catch {
     return false;
@@ -4570,7 +5381,7 @@ var cpp_check_default = cppCheckRunner;
 
 // dist/clients/dispatch/runners/credo.js
 import * as path10 from "node:path";
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 var CREDO_PROBE_BUDGET_MS = 1e4;
 var probeCredo = createCwdCachedProbe((cwd) => safeSpawnAsync("mix", ["credo", "--version"], {
   timeout: CREDO_PROBE_BUDGET_MS,
@@ -4596,7 +5407,7 @@ function parseCredoJson(raw, fallbackPath, cwd) {
   }
 }
 function hasMixExs(cwd) {
-  return fs6.existsSync(path10.join(cwd, "mix.exs"));
+  return fs7.existsSync(path10.join(cwd, "mix.exs"));
 }
 var credoRunner = {
   id: "credo",
@@ -4633,7 +5444,7 @@ var credoRunner = {
 var credo_default = credoRunner;
 
 // dist/clients/dispatch/runners/cue-vet.js
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as path11 from "node:path";
 var cue = createAvailabilityChecker("cue", ".exe", ["version"]);
 function parseCueVetOutput(raw) {
@@ -4738,7 +5549,7 @@ var cueVetRunner = {
     const singleFileArgs = ["vet", "-c=false", `./${fileName}`];
     let touchedContent = null;
     try {
-      touchedContent = fs7.readFileSync(absPath, "utf8");
+      touchedContent = fs8.readFileSync(absPath, "utf8");
     } catch {
       touchedContent = null;
     }
@@ -4943,8 +5754,11 @@ var dartAnalyzeRunner = {
     const parsed = parseToolRun("dart-analyze", {
       result,
       output: raw,
-      // EXIT TABLE (Dart 3.5 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-      exitCodes: { ran: [1, 2] }
+      // EXIT TABLE (Dart 3.13 measured fixture, tests/fixtures/runner-output/
+      // dart-analyze): 0 clean; 1 infos; 2 warnings; 3 errors; other nonzero
+      // rejected. The 3.5 table stopped at 2, so a file with a compile error
+      // read as a rejected invocation and its findings were dropped.
+      exitCodes: { ran: [1, 2, 3] }
     }, (out) => parseDartMachineOutput(out, ctx.filePath, cwd));
     if (parsed.skipped)
       return parsed.skipped;
@@ -4959,7 +5773,7 @@ var dartAnalyzeRunner = {
 var dart_analyze_default = dartAnalyzeRunner;
 
 // dist/clients/dispatch/runners/detekt.js
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as path13 from "node:path";
 var detekt = createAvailabilityChecker("detekt", ".bat");
 var DETEKT_CONFIG_CANDIDATES = [
@@ -5033,7 +5847,7 @@ var DETEKT_FIXABLE_RULES = /* @__PURE__ */ new Set([
 function findDetektConfig(cwd) {
   for (const candidate of DETEKT_CONFIG_CANDIDATES) {
     const full = path13.join(cwd, candidate);
-    if (fs8.existsSync(full))
+    if (fs9.existsSync(full))
       return full;
   }
   return void 0;
@@ -5112,11 +5926,11 @@ var detektRunner = {
 var detekt_default = detektRunner;
 
 // dist/clients/dispatch/runners/dotnet-build.js
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as path14 from "node:path";
 var dotnet = createAvailabilityChecker("dotnet", ".exe");
 function findProjectTarget(cwd) {
-  const entries = fs9.readdirSync(cwd);
+  const entries = fs10.readdirSync(cwd);
   const solution = entries.find((entry) => /\.(sln|slnx)$/i.test(entry));
   if (solution)
     return solution;
@@ -5266,12 +6080,12 @@ ${result.stderr ?? ""}`.trim();
 var dotnet_build_default = dotnetBuildRunner;
 
 // dist/clients/dispatch/runners/elixir-check.js
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import * as path15 from "node:path";
 var mix = createAvailabilityChecker("mix", ".bat");
 var elixirc = createAvailabilityChecker("elixirc", ".bat");
 function hasMixExs2(cwd) {
-  return fs10.existsSync(path15.join(cwd, "mix.exs"));
+  return fs11.existsSync(path15.join(cwd, "mix.exs"));
 }
 var ELIXIR_SNIPPET_LOCATION = /└─\s+(.+?):(\d+)(?::(\d+))?(?::|$)/;
 function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
@@ -5371,7 +6185,7 @@ var elixirCheckRunner = {
       args = ["compile", "--warnings-as-errors"];
     } else if (await elixirc.isAvailableAsync(cwd)) {
       const outDir = path15.join(getProjectDataDir(cwd), "elixir-check");
-      fs10.mkdirSync(outDir, { recursive: true });
+      fs11.mkdirSync(outDir, { recursive: true });
       command = "elixirc";
       args = ["-o", outDir, absPath];
     }
@@ -5706,9 +6520,10 @@ var parseRuffOutput = createLineParser({
   autoFixAvailable: ruffAutofix?.safePipelineAutofix ?? false,
   fixKind: ruffAutofix?.fixKind === "none" ? void 0 : ruffAutofix?.fixKind
 });
+var GO_VET_LINE = /^(?:vet:\s+)?(.+?):(\d+):(\d+):\s*(.+)/;
 var parseGoVetOutput = createLineParser({
   tool: "go-vet",
-  regex: /^(.+?):(\d+):(\d+):\s*(.+)/,
+  regex: GO_VET_LINE,
   extractMessage: (m) => m[4],
   generateId: (m) => `go-vet-${m[2]}`,
   defectClass: "correctness"
@@ -5750,7 +6565,7 @@ var goVetRunner = {
     }
     const absTarget = resolve14(ctx.filePath);
     const relevant = raw.split("\n").filter((line) => {
-      const m = line.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
+      const m = line.match(GO_VET_LINE);
       return m != null && pathsEqual(resolve14(cwd, m[1].trim()), absTarget);
     }).join("\n");
     const diagnostics = parseGoVetOutput(relevant, ctx.filePath, cwd);
@@ -5762,6 +6577,16 @@ var go_vet_default = goVetRunner;
 // dist/clients/dispatch/runners/golangci-lint.js
 import * as path19 from "node:path";
 var golangci = createAvailabilityChecker("golangci-lint", ".exe");
+var OTHER_OUTPUT_FORMATS = [
+  "text",
+  "tab",
+  "html",
+  "checkstyle",
+  "code-climate",
+  "junit-xml",
+  "teamcity",
+  "sarif"
+];
 function describeReplacement(replacement) {
   if (!replacement)
     return void 0;
@@ -5822,12 +6647,18 @@ var golangciRunner = {
     const cmd = await resolveAvailableOrInstall(golangci, "golangci-lint", cwd);
     if (!cmd)
       return { status: "skipped", diagnostics: [], semantic: "none" };
-    const result = await safeSpawnAsync(cmd, ["run", "--out-format=json", ctx.filePath], { timeout: 6e4, cwd });
+    const result = await safeSpawnAsync(cmd, [
+      "run",
+      "--output.json.path=stdout",
+      ...OTHER_OUTPUT_FORMATS.map((format) => `--output.${format}.path=`),
+      "--show-stats=false",
+      ctx.filePath
+    ], { timeout: 6e4, cwd });
     const raw = (result.stdout ?? "").length > 0 ? result.stdout ?? "" : result.status !== 0 ? result.stderr || "" : "";
     const parsed = parseToolRun("golangci-lint", {
       result,
       output: raw,
-      // EXIT TABLE (golangci-lint 1.60 docs https://golangci-lint.run/docs/welcome/quick-start/): 0 clean; 1 findings; 2 error; 3 error; 4 error; 5 error; other nonzero rejected.
+      // EXIT TABLE (golangci-lint v2 docs https://golangci-lint.run/docs/welcome/quick-start/; 2.14.0 exits 1 on findings and 3 on an unknown flag): 0 clean; 1 findings; 2 error; 3 error; 4 error; 5 error; other nonzero rejected.
       exitCodes: { ran: [1, 2, 3, 4, 5] }
     }, (raw2) => parseGolangciJson(raw2, ctx.filePath, cwd));
     if (parsed.skipped)
@@ -5922,7 +6753,7 @@ var hadolint_default = hadolintRunner;
 
 // dist/clients/dispatch/runners/helm-lint.js
 import * as path21 from "node:path";
-var helm = createAvailabilityChecker("helm", ".exe");
+var helm = createAvailabilityChecker("helm", ".exe", ["version", "--short"]);
 var inFlightByChartRoot = new PathKeyedMap(normalizeMapKey);
 var HELM_LINT_TIMEOUT_MS = 3e4;
 var MAX_HELM_LINT_OUTPUT_BYTES = 8 * 1024 * 1024;
@@ -5936,14 +6767,17 @@ function isWithin(root, candidate) {
   return relative5 === "" || !relative5.startsWith(`..${path21.sep}`) && relative5 !== ".." && !path21.isAbsolute(relative5);
 }
 function diagnosticLocation(message, chartRoot) {
-  const location = message.match(/(?:^|\s)([^:\r\n]+\.(?:ya?ml|tpl|json))(?::(\d+))?(?::\d+)?(?::|\s)/i);
-  if (!location) {
+  const location = message.match(/(?:^|[\s(])((?:[^\s:()\r\n]*\/[^:()\r\n"]*?|[^\s:()\r\n]+)\.(?:ya?ml|tpl|json))(?::(\d+))?(?=[:\s)]|$)/i);
+  const [, found, rawLine] = location ?? [];
+  if (!found) {
     return { filePath: path21.join(chartRoot, "Chart.yaml"), message };
   }
-  const candidate = path21.resolve(chartRoot, location[1]);
+  const embedded = !message.startsWith(found);
+  const relative5 = embedded ? found.slice(found.indexOf("/") + 1) : found;
+  const candidate = path21.resolve(chartRoot, relative5);
   return {
     filePath: isWithin(chartRoot, candidate) ? candidate : path21.join(chartRoot, "Chart.yaml"),
-    line: location[2] ? Number(location[2]) : void 0,
+    line: rawLine ? Number(rawLine) : void 0,
     message
   };
 }
@@ -6058,10 +6892,10 @@ var helmLintRunner = {
 var helm_lint_default = helmLintRunner;
 
 // dist/clients/dispatch/runners/helm-render.js
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os from "node:os";
 import * as path22 from "node:path";
-var helm2 = createAvailabilityChecker("helm", ".exe");
+var helm2 = createAvailabilityChecker("helm", ".exe", ["version", "--short"]);
 var trivy = createAvailabilityChecker("trivy", ".exe");
 var inFlightByChartRoot2 = new PathKeyedMap(normalizeMapKey);
 var RENDER_TIMEOUT_MS = 3e4;
@@ -6095,10 +6929,10 @@ function resolveTemplateSource(sourceRef, chartRoot, realChartRoot) {
   if (!isWithin2(chartRoot, candidate))
     return null;
   try {
-    if (!fs11.lstatSync(candidate).isFile())
+    if (!fs12.lstatSync(candidate).isFile())
       return null;
-    const root = realChartRoot ?? fs11.realpathSync(chartRoot);
-    if (!isWithin2(root, fs11.realpathSync(candidate)))
+    const root = realChartRoot ?? fs12.realpathSync(chartRoot);
+    if (!isWithin2(root, fs12.realpathSync(candidate)))
       return null;
   } catch {
     return null;
@@ -6107,7 +6941,7 @@ function resolveTemplateSource(sourceRef, chartRoot, realChartRoot) {
 }
 function canonicalChartRoot(chartRoot) {
   try {
-    return fs11.realpathSync(chartRoot);
+    return fs12.realpathSync(chartRoot);
   } catch {
     return chartRoot;
   }
@@ -6342,7 +7176,7 @@ function collectRenderedFiles(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs11.readdirSync(dir, { withFileTypes: true });
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -6381,7 +7215,7 @@ function readRenderedTree(outputDir, chartRoot) {
   for (const renderedPath of walk2.files) {
     let content;
     try {
-      content = fs11.readFileSync(renderedPath, "utf-8");
+      content = fs12.readFileSync(renderedPath, "utf-8");
     } catch {
       unreadable += 1;
       continue;
@@ -6500,7 +7334,7 @@ function logRenderPass(filePath, chartRoot, startedAt, metadata) {
     metadata: { chartRoot, ...metadata }
   });
 }
-function discardScratchDir(outputDir, filePath, remove = (target) => fs11.rmSync(target, { recursive: true, force: true })) {
+function discardScratchDir(outputDir, filePath, remove = (target) => fs12.rmSync(target, { recursive: true, force: true })) {
   try {
     remove(outputDir);
   } catch (error) {
@@ -6521,7 +7355,7 @@ async function renderAndValidate(chartRoot, cwd, filePath) {
   const helmCmd = await resolveAvailableOrInstall(helm2, "helm", cwd);
   if (!helmCmd)
     return helmUnavailableResult(cwd);
-  const outputDir = fs11.mkdtempSync(path22.join(os.tmpdir(), "pi-lens-helm-render-"));
+  const outputDir = fs12.mkdtempSync(path22.join(os.tmpdir(), "pi-lens-helm-render-"));
   try {
     const render = await safeSpawnAsync(helmCmd, ["template", "pi-lens-render", chartRoot, "--output-dir", outputDir], {
       cwd,
@@ -6842,9 +7676,30 @@ function normalizeKtlintResults(parsed) {
   }
   return null;
 }
+function parseResults(text) {
+  try {
+    return normalizeKtlintResults(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+function parseReporterDocument(raw) {
+  const lines = raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^\s*[[{]/.test(line));
+  if (start < 0)
+    return parseResults(raw);
+  for (let end = lines.length - 1; end >= start; end--) {
+    if (!/[\]}]\s*$/.test(lines[end] ?? ""))
+      continue;
+    const results = parseResults(lines.slice(start, end + 1).join("\n"));
+    if (results)
+      return results;
+  }
+  return null;
+}
 function parseKtlintOutput(raw, filePath, cwd) {
   try {
-    const parsed = normalizeKtlintResults(JSON.parse(raw));
+    const parsed = parseReporterDocument(raw);
     if (!parsed)
       return null;
     const autofix = getAutofixCapability("ktlint");
@@ -6855,15 +7710,15 @@ function parseKtlintOutput(raw, filePath, cwd) {
         continue;
       for (const err of result.errors ?? []) {
         diagnostics.push({
-          id: `ktlint-${err.ruleId}-${err.line}-${err.col}`,
-          message: `[${err.ruleId}] ${err.detail}`,
+          id: `ktlint-${err.rule}-${err.line}-${err.column}`,
+          message: `[${err.rule}] ${err.message}`,
           filePath,
           line: err.line,
-          column: err.col,
+          column: err.column,
           severity: "warning",
           semantic: "warning",
           tool: "ktlint",
-          rule: err.ruleId,
+          rule: err.rule,
           fixable: true,
           autoFixAvailable: autofix?.safePipelineAutofix ?? false,
           fixKind: autofix?.fixKind === "none" ? void 0 : autofix?.fixKind
@@ -7037,16 +7892,6 @@ async function demoteInferredProjectSweepResults(results, cwd, service, signal)
   return out;
 }
 
-// dist/clients/dispatch/runners/utils.js
-import * as fs12 from "node:fs";
-function readFileContent(filePath) {
-  try {
-    return fs12.readFileSync(filePath, "utf-8");
-  } catch {
-    return void 0;
-  }
-}
-
 // dist/clients/dispatch/runners/lsp.js
 var LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
 var LSP_DIAGNOSTICS_WAIT_MS = 2500;
@@ -7083,13 +7928,23 @@ var lspRunner = {
     }
     const lspService = getLSPService();
     if (!lspService.supportsLSP(ctx.filePath)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
+      const { disabledServerIds: disabledPrimaryServerIds } = disabledPrimaries(ctx.filePath);
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        ...disabledPrimaryServerIds.length > 0 && {
+          primaryUnavailableCause: "disabled",
+          disabledPrimaryServerIds
+        }
+      };
     }
     let lspDiags = [];
     let serverFailed = false;
     let lspClientReady = true;
     let diagnosticsInconclusive = false;
     let inconclusiveServerIds = [];
+    let primaryUnavailable;
     let unconfirmedServerIds = [];
     let deferredServerIds = [];
     let usedWarmAttach = false;
@@ -7127,6 +7982,15 @@ var lspRunner = {
         lspDiags = touched.diags;
         diagnosticsInconclusive = touched.inconclusive === true;
         inconclusiveServerIds = touched.inconclusiveServerIds ?? [];
+        if (touched.inconclusiveReason === "primary-unavailable") {
+          const disabledPrimaryServerIds = touched.disabledPrimaryServerIds ?? [];
+          primaryUnavailable = {
+            primaryUnavailableCause: touched.primaryUnavailableCause ?? primaryUnavailableCause(inconclusiveServerIds, disabledPrimaryServerIds),
+            ...disabledPrimaryServerIds.length > 0 && {
+              disabledPrimaryServerIds
+            }
+          };
+        }
         unconfirmedServerIds = [
           .../* @__PURE__ */ new Set([
             ...touchCoverageGap(touched),
@@ -7178,10 +8042,20 @@ var lspRunner = {
       };
     }
     if (!lspClientReady) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        primaryUnavailableCause: "unstarted"
+      };
     }
     if (diagnosticsInconclusive && lspDiags.length === 0) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        ...primaryUnavailable
+      };
     }
     if (lspDiags.length === 0) {
       if (deferredServerIds.length > 0) {
@@ -7246,7 +8120,15 @@ var lspRunner = {
       }));
     }
     const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
-    const keptDiagnostics = retagAuxiliaryDiagnostics(diagnostics, validLspDiags, content, { cwd: ctx.cwd, fileRole: ctx.fileRole });
+    const rawRangeByDiagnostic = new Map(diagnostics.map((d, i) => [d, validLspDiags[i]?.range]));
+    const retaggedDiagnostics = retagAuxiliaryDiagnostics(diagnostics, validLspDiags, content, { cwd: ctx.cwd, fileRole: ctx.fileRole });
+    const keptDiagnostics = [];
+    const outOfEditScope = [];
+    for (const d of retaggedDiagnostics) {
+      const range = ctx.blockingOnly && d.tool === "ast-grep" && d.semantic === "blocking" ? rawRangeByDiagnostic.get(d) : void 0;
+      const inScope = range === void 0 || spanOverlapsModifiedRanges(range.start.line + 1, (range.end?.line ?? range.start.line) + 1, ctx.modifiedRanges);
+      (inScope ? keptDiagnostics : outOfEditScope).push(d);
+    }
     const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
     const resultSemantic = hasErrors ? "blocking" : keptDiagnostics.length > 0 ? "warning" : "none";
     return {
@@ -7261,7 +8143,8 @@ var lspRunner = {
       },
       ...deferredServerIds.length > 0 && {
         deferredServerIds: [...deferredServerIds]
-      }
+      },
+      ...outOfEditScope.length > 0 && { outOfEditScope }
     };
   }
 };
@@ -7791,13 +8674,9 @@ var phpLintRunner = {
   skipTestFiles: false,
   async run(ctx) {
     const cwd = resolveRunnerCwd(ctx, "php-lint");
-    if (!await php.isAvailableAsync(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = php.getCommand(cwd);
-    if (!cmd) {
+    const cmd = ctx.analysisRootMode === "adopted" ? resolveAdoptedRootCommand("php", ctx, cwd) : await php.isAvailableAsync(cwd) ? php.getCommand(cwd) : null;
+    if (!cmd)
       return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
     const absPath = path30.resolve(cwd, ctx.filePath);
     const result = await safeSpawnAsync(cmd, ["-l", absPath], {
       timeout: 15e3,
@@ -8301,7 +9180,7 @@ var pyrightRunner = {
         cmd = installedPath;
     }
     if (!cmd) {
-      const { findCommandAsync } = await import("./chunk-67WMNWEE.js");
+      const { findCommandAsync } = await import("./chunk-LLJNQKQW.js");
       const foundCmd = await findCommandAsync("pyright");
       if (foundCmd)
         cmd = foundCmd;
@@ -8904,6 +9783,7 @@ var spotbugs_default = spotbugsRunner;
 import * as fs15 from "node:fs";
 import * as path36 from "node:path";
 var shellcheck = createAvailabilityChecker("shellcheck", ".exe");
+var SHELLCHECK_EXIT_CODES = { ran: [1] };
 var SHELLCHECK_DIALECTS = [
   "sh",
   "bash",
@@ -9027,7 +9907,10 @@ var shellcheckRunner = {
         skipReason: "covered-by-primary",
         // WHO claimed (#3968 F2): declared (the row's own covers, gated
         // on the custom row's own command) or builtin-fact.
-        claimSource: cover.claimSource
+        claimSource: cover.claimSource,
+        // #4484 round 8: the skip is a verdict only when that server's
+        // lane answers; the dispatcher voids it otherwise.
+        coveredBy: { runnerId: "lsp", serverId: cover.serverId }
       };
     }
     const dialectInfo = resolveShellFileDialect(ctx.filePath);
@@ -9062,20 +9945,52 @@ var shellcheckRunner = {
     if (result.status === 0 && !result.stdout?.trim()) {
       return { status: "succeeded", diagnostics: [], semantic: "none" };
     }
-    const raw = result.stdout + result.stderr;
-    const diagnostics = parseShellcheckOutput(raw, ctx.filePath, cwd);
+    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const parsed = parseToolRun("shellcheck", { result, output: raw, exitCodes: SHELLCHECK_EXIT_CODES }, (output) => parseShellcheckOutput(output, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
     return finishParsedRun({
       tool: "shellcheck",
       ctx,
       result,
-      diagnostics
+      diagnostics: parsed.diagnostics
     });
   }
 };
 var shellcheck_default = shellcheckRunner;
 
 // dist/clients/dispatch/runners/fish-indent.js
+import { resolve as resolve32 } from "node:path";
 var fishIndent = createAvailabilityChecker("fish_indent");
+var fish = createAvailabilityChecker("fish");
+var SYNTAX_STEP = "fish-syntax-check";
+function parseSyntaxErrors(output, filePath, cwd) {
+  const diagnostics = [];
+  for (const line of output.split("\n")) {
+    const [, reported, lineText, message] = line.match(/^(.+) \(line (\d+)\): (.+)$/) ?? [];
+    if (!reported || !lineText || !message)
+      continue;
+    const wanted = resolve32(cwd, filePath);
+    if (!pathsEqual(resolve32(cwd, reported), wanted) && !(reported.startsWith("~/") && wanted.endsWith(reported.slice(1))))
+      continue;
+    const lineNumber = Number(lineText);
+    diagnostics.push({
+      id: `fish-syntax-${filePath}:${lineNumber}`,
+      message: `fish: ${message.trim()}`,
+      filePath,
+      line: lineNumber,
+      column: 1,
+      severity: "error",
+      semantic: "blocking",
+      tool: "fish-indent",
+      rule: "fish-syntax-error"
+    });
+    break;
+  }
+  return diagnostics;
+}
+var FISH_SYNTAX_EXIT_CODES = { ran: [127] };
+var BLOCKING_VERDICT = { status: "failed", semantic: "blocking" };
 var fishIndentRunner = {
   id: "fish-indent",
   appliesTo: ["fish"],
@@ -9083,12 +9998,27 @@ var fishIndentRunner = {
   skipTestFiles: false,
   async run(ctx) {
     const cwd = resolveRunnerCwd(ctx, "fish-indent");
-    const available = await fishIndent.isAvailableAsync(cwd);
-    if (!available)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const cmd = fishIndent.getCommand(cwd);
+    const cmd = ctx.analysisRootMode === "adopted" ? resolveAdoptedRootCommand("fish_indent", ctx, cwd) : await fishIndent.isAvailableAsync(cwd) ? fishIndent.getCommand(cwd) : null;
     if (!cmd)
       return { status: "skipped", diagnostics: [], semantic: "none" };
+    const fishCmd = ctx.analysisRootMode === "adopted" ? resolveAdoptedRootCommand("fish", ctx, cwd) : await fish.isAvailableAsync(cwd) ? fish.getCommand(cwd) : null;
+    if (fishCmd) {
+      const syntax = await safeSpawnAsync(fishCmd, ["--no-config", "--no-execute", ctx.filePath], { timeout: 1e4, cwd });
+      const parsed = parseToolRun(SYNTAX_STEP, {
+        result: syntax,
+        output: syntax.stderr ?? "",
+        exitCodes: FISH_SYNTAX_EXIT_CODES
+      }, (output) => parseSyntaxErrors(output, ctx.filePath, cwd));
+      if (parsed.diagnostics.length > 0) {
+        return findingsResult(parsed.diagnostics, BLOCKING_VERDICT);
+      }
+    } else {
+      recordDegradationOnce({
+        kind: "fish-syntax-check-unavailable",
+        subject: "fish",
+        reason: "fish not found next to fish_indent: syntax errors are not checked"
+      });
+    }
     const result = await safeSpawnAsync(cmd, ["--check", ctx.filePath], {
       timeout: 1e4,
       cwd
@@ -9096,7 +10026,12 @@ var fishIndentRunner = {
     if (result.status === 0) {
       return { status: "succeeded", diagnostics: [], semantic: "none" };
     }
-    const stderrLine = (result.stderr ?? "").split("\n").find((l) => l.trim());
+    if (result.signal || result.status === null) {
+      const didNotRun = skipUnlessToolRan("fish_indent", { result });
+      if (didNotRun)
+        return didNotRun;
+    }
+    const stderrLine = (result.stderr ?? "").split("\n").find((l) => l.trim() && !pathsEqual(resolve32(cwd, l.trim()), resolve32(cwd, ctx.filePath)));
     if (stderrLine) {
       const lineMatch = stderrLine.match(/\(line\s+(\d+)\)/);
       const line = lineMatch ? Number(lineMatch[1]) : 1;
@@ -9113,10 +10048,7 @@ var fishIndentRunner = {
           rule: "fish-indent-parse-error"
         }
       ];
-      return findingsResult(diagnostics2, {
-        status: "failed",
-        semantic: "blocking"
-      });
+      return findingsResult(diagnostics2, BLOCKING_VERDICT);
     }
     const diagnostics = [
       {
@@ -9167,6 +10099,12 @@ var shfmtRunner = {
       timeout: 1e4,
       cwd
     });
+    const didNotRun = skipUnlessToolRan("shfmt", {
+      result,
+      output: `${result.stdout ?? ""}${result.stderr ?? ""}`
+    });
+    if (didNotRun)
+      return didNotRun;
     if (result.status === 0) {
       return { status: "succeeded", diagnostics: [], semantic: "none" };
     }
@@ -9748,7 +10686,10 @@ var taploRunner = {
         // an unexplained empty output on the delivery surfaces
         // (defect shape 10). F2 adds the claim's provenance beside it.
         skipReason: "covered-by-primary",
-        claimSource: cover.claimSource
+        claimSource: cover.claimSource,
+        // #4484 round 8: the skip is a verdict only when that server's
+        // lane answers; the dispatcher voids it otherwise.
+        coveredBy: { runnerId: "lsp", serverId: cover.serverId }
       };
     }
     let cmd = localBinPath(findLocalBinUpwards("taplo", cwd)) ?? null;
@@ -10596,11 +11537,6 @@ function defaultFixSuggestion2(defectClass, ruleId) {
   }
   return "Refactor this pattern to a safer, explicit form matching project conventions.";
 }
-function isLineInModifiedRanges(line, ranges) {
-  if (!ranges || ranges.length === 0)
-    return true;
-  return ranges.some((r) => line >= r.start && line <= r.end);
-}
 function getTotalLinesChanged(ranges) {
   if (!ranges || ranges.length === 0)
     return 0;
@@ -10725,19 +11661,20 @@ var treeSitterRunner = {
     const contentFromFacts = ctx.facts.getFileFact(filePath, "file.content");
     const contentOverride = contentFromFacts !== void 0 && contentFromFacts !== null ? contentFromFacts : void 0;
     const diagnostics = [];
+    const withheld = [];
+    let queryRunFailed = false;
     try {
       const found = await client.runQueriesOnFile(effectiveQueries, filePath, languageId, { maxResults: 10 }, contentOverride);
       for (const { queryDef: query, match } of found) {
         const { line, column } = match;
         const isSeverityBlocking = query.severity === "error" || query.inline_tier === "blocking" || SILENT_ERROR_QUERY_IDS.has(query.id);
-        if (ctx.blockingOnly && isSeverityBlocking && !isLineInModifiedRanges(line, ctx.modifiedRanges)) {
-          continue;
-        }
+        const endLine = line + (match.matchedText.match(/\n/g)?.length ?? 0);
+        const outOfScope = ctx.blockingOnly && isSeverityBlocking && !spanOverlapsModifiedRanges(line, endLine, ctx.modifiedRanges);
         const semantic = query.severity === "error" ? "blocking" : query.severity === "warning" ? "warning" : "none";
         const defectClass = query.defect_class ?? classifyDefect(query.id, "tree-sitter", query.message);
         const suggestion = query.has_fix && query.fix_action ? `${query.fix_action} this statement` : semantic === "blocking" ? defaultFixSuggestion2(defectClass, query.id) : void 0;
         const hasSuggestedFix = !!query.has_fix;
-        diagnostics.push({
+        (outOfScope ? withheld : diagnostics).push({
           id: `tree-sitter:${query.id}:${line}`,
           message: query.message.replace(/\{\{(\w+)\}\}/g, (_, name) => match.captures[name]?.trim() ?? `{{${name}}}`),
           filePath,
@@ -10759,6 +11696,7 @@ var treeSitterRunner = {
         });
       }
     } catch (err) {
+      queryRunFailed = true;
       const msg = err instanceof Error ? err.message : String(err);
       if (classifyTreeSitterWasmError(err) === "abort") {
         markTreeSitterWasmAborted();
@@ -10818,6 +11756,10 @@ var treeSitterRunner = {
       } catch {
       }
     }
+    const observationExtras = {
+      ...withheld.length > 0 && { outOfEditScope: withheld },
+      ...queryRunFailed && { inconclusive: true }
+    };
     if (diagnostics.length === 0) {
       if (!isTreeSitterWasmAborted() && !client.getLanguage(languageId)) {
         logTreeSitter({
@@ -10827,7 +11769,11 @@ var treeSitterRunner = {
           reason: "grammar_unavailable",
           status: "skipped"
         });
-        return { status: "skipped", diagnostics: [], semantic: "none" };
+        return {
+          status: "skipped",
+          diagnostics: [],
+          semantic: "none"
+        };
       }
       logTreeSitter({
         phase: "runner_complete",
@@ -10839,7 +11785,12 @@ var treeSitterRunner = {
         queryCount: languageQueries.length,
         effectiveQueryCount: effectiveQueries.length
       });
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
+      return {
+        status: "succeeded",
+        diagnostics: [],
+        semantic: "none",
+        ...observationExtras
+      };
     }
     const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
     const blockingCount = diagnostics.filter((d) => d.semantic === "blocking").length;
@@ -10853,10 +11804,13 @@ var treeSitterRunner = {
       queryCount: languageQueries.length,
       effectiveQueryCount: effectiveQueries.length
     });
-    return findingsResult(diagnostics, {
-      status: hasBlocking ? "failed" : "succeeded",
-      semantic: hasBlocking ? "blocking" : "warning"
-    });
+    return {
+      ...findingsResult(diagnostics, {
+        status: hasBlocking ? "failed" : "succeeded",
+        semantic: hasBlocking ? "blocking" : "warning"
+      }),
+      ...observationExtras
+    };
   }
 };
 var tree_sitter_default = treeSitterRunner;
@@ -11267,8 +12221,6 @@ function isTestSuiteOrganizer(calls) {
 // dist/clients/dispatch/rules/high-complexity.js
 var DEFAULT_HIGH_COMPLEXITY_THRESHOLD = 15;
 var DEFAULT_HIGH_COMPLEXITY_DEPTH_THRESHOLD = 6;
-var ccThreshold = DEFAULT_HIGH_COMPLEXITY_THRESHOLD;
-var depthThreshold = DEFAULT_HIGH_COMPLEXITY_DEPTH_THRESHOLD;
 var highComplexityRule = {
   id: "high-complexity",
   requires: ["file.functionSummaries"],
@@ -11279,12 +12231,12 @@ var highComplexityRule = {
     const fns = store.getFileFact(ctx.filePath, "file.functionSummaries") ?? [];
     const diagnostics = [];
     const configuredCcThreshold = ctx.projectConfig?.rules["high-complexity"]?.threshold;
-    const activeCcThreshold = configuredCcThreshold ?? ccThreshold;
+    const activeCcThreshold = configuredCcThreshold ?? DEFAULT_HIGH_COMPLEXITY_THRESHOLD;
     for (const f of fns) {
       if (isTestSuiteOrganizer(f.outgoingCalls))
         continue;
       const ccBreached = f.cyclomaticComplexity >= activeCcThreshold;
-      const depthBreached = f.maxNestingDepth >= depthThreshold;
+      const depthBreached = f.maxNestingDepth >= DEFAULT_HIGH_COMPLEXITY_DEPTH_THRESHOLD;
       if (!ccBreached && !depthBreached)
         continue;
       const parts = [];
@@ -11310,7 +12262,6 @@ var highComplexityRule = {
 
 // dist/clients/dispatch/rules/high-fan-out.js
 var DEFAULT_HIGH_FAN_OUT_THRESHOLD = 20;
-var fanOutThreshold = DEFAULT_HIGH_FAN_OUT_THRESHOLD;
 var highFanOutRule = {
   id: "high-fan-out",
   requires: ["file.functionSummaries"],
@@ -11321,7 +12272,7 @@ var highFanOutRule = {
     const fns = store.getFileFact(ctx.filePath, "file.functionSummaries") ?? [];
     const diagnostics = [];
     const configuredFanOutThreshold = ctx.projectConfig?.rules["high-fan-out"]?.threshold;
-    const activeFanOutThreshold = configuredFanOutThreshold ?? fanOutThreshold;
+    const activeFanOutThreshold = configuredFanOutThreshold ?? DEFAULT_HIGH_FAN_OUT_THRESHOLD;
     for (const f of fns) {
       if (isTestSuiteOrganizer(f.outgoingCalls))
         continue;
@@ -11680,6 +12631,8 @@ function applyProjectLensConfig(cwd) {
   return loadPiLensProjectConfig(cwd);
 }
 var sessionFacts = new FactStore("dispatch");
+var preEditCaptureFacts = new FactStore("pre-edit-capture");
+var preEditCapturesInFlight = /* @__PURE__ */ new Map();
 setFactStoreEvictionReporter((subject, axis, reason) => {
   if (axis === "pinned-over-budget") {
     recordDegradationOnce({
@@ -11861,12 +12814,16 @@ function resetDispatchBaselines(cwd) {
   resetAstGrepNapiLoadState();
   resetTreeSitterClientLoadState();
   sessionFacts.clearAll();
+  for (const controller of preEditCapturesInFlight.values())
+    controller.abort();
+  preEditCaptureFacts.clearAll();
   resetSessionSlopScore();
   clearCoverageNoticeState();
   clearReviewGraphWorkspaceCache();
   clearReverseDepsIndexCache();
   clearModuleGraphCache();
-  recentlyCleanNeighborCache.clear();
+  resetCascadeUnansweredPrimariesDelivered();
+  resetCascadePendingNeighbors();
   primaryFilesThisTurn.clear();
   cascadeSessionStats = {
     runs: 0,
@@ -11882,7 +12839,6 @@ var cascadeSessionStats = {
   diagnosticsSurfaced: 0,
   coldSnapshotTouches: 0
 };
-var recentlyCleanNeighborCache = /* @__PURE__ */ new Map();
 var primaryFilesThisTurn = /* @__PURE__ */ new Set();
 var MAX_PER_FILE = RUNTIME_CONFIG.pipeline.cascadeMaxDiagnosticsPerFile;
 var MAX_FILES = RUNTIME_CONFIG.pipeline.cascadeMaxFiles;
@@ -11910,8 +12866,16 @@ var CASCADE_GRAPH_KINDS = /* @__PURE__ */ new Set([
   "ruby",
   "cxx"
 ]);
+var IMPLICIT_SCOPE_NEIGHBOR_CAP = MAX_FILES * 2;
 async function dispatchLintWithResult(filePath, cwd, pi, modifiedRanges, logContext, options) {
-  const ctx = createDispatchContext(filePath, cwd, pi, sessionFacts, options?.blockingOnly ?? true, modifiedRanges, options?.projectRoot, options?.writeIndex, options?.telemetryModel, options?.telemetryProvider, options?.sessionGeneration, options?.sessionId, options?.analysisRootMode);
+  const created = createDispatchContext(filePath, cwd, pi, sessionFacts, options?.blockingOnly ?? true, modifiedRanges, options?.projectRoot, options?.writeIndex, options?.telemetryModel, options?.telemetryProvider, options?.sessionGeneration, options?.sessionId, options?.analysisRootMode);
+  const ctx = options?.owedRanges?.size || options?.recordedRunnerIds?.size ? {
+    ...created,
+    ...options.owedRanges?.size && { owedRanges: options.owedRanges },
+    ...options.recordedRunnerIds?.size && {
+      recordedRunnerIds: options.recordedRunnerIds
+    }
+  } : created;
   sessionFacts.clearFileFactsFor(ctx.filePath);
   try {
     const kind = ctx.kind;
@@ -12042,14 +13006,17 @@ function enforceWarmWordIndexLruCap() {
       return;
   }
 }
+function usableWarmWordIndex(index) {
+  return index?.forward ? index : void 0;
+}
 function acquireWarmWordIndex(cwd) {
   const key2 = path50.resolve(cwd);
   let entry = warmWordIndexes.get(key2);
   if (!entry) {
     const snapshot = loadProjectSnapshot(key2);
-    const index = deserializeWordIndex(snapshot?.wordIndex) ?? void 0;
+    const index = usableWarmWordIndex(deserializeWordIndex(snapshot?.wordIndex) ?? void 0);
     entry = {
-      index: index?.forward ? index : void 0,
+      index,
       timer: void 0,
       leases: 0,
       lastUsedAt: Date.now(),
@@ -12077,6 +13044,26 @@ function acquireWarmWordIndex(cwd) {
     }
   };
 }
+function adoptPublishedWarmWordIndex(cwd, published, trigger) {
+  const index = usableWarmWordIndex(published);
+  if (!index)
+    return;
+  const key2 = path50.resolve(cwd);
+  const entry = warmWordIndexes.get(key2);
+  if (!entry || entry.index)
+    return;
+  entry.index = index;
+  entry.lastUsedAt = Date.now();
+  scheduleWarmWordIndexIdleEviction(key2, entry);
+  logWordIndex({
+    phase: "warm_cache_adopted",
+    cwd: key2,
+    trigger,
+    indexedFileCount: index.docCount,
+    tokens: index.postings.size
+  });
+}
+setWordIndexPublishedListener(adoptPublishedWarmWordIndex);
 function _resetWarmWordIndexCacheForTests() {
   for (const entry of warmWordIndexes.values())
     clearWarmWordIndexTimer(entry);
@@ -12139,7 +13126,13 @@ async function warmLspForFile(absPath, host) {
       clientScope: "primary",
       maxClientWaitMs: WARMUP_CLIENT_WAIT_MS,
       maxDiagnosticsWaitMs: WARMUP_DIAGNOSTICS_WAIT_MS,
-      source: "mcp-warmup"
+      source: "mcp-warmup",
+      // #3405: every caller of `analyzeFile` (the MCP hosts' post-write hooks,
+      // warm and cold, and `pilens_analyze`) asks about the bytes on disk now,
+      // and this is the analysis's first push of them, so it is the save. A
+      // save-triggered server (Expert compiles on didSave and on nothing else)
+      // answers an MCP host's edit only because of it.
+      saved: true
     });
   } catch {
   }
@@ -12154,6 +13147,7 @@ async function analyzeFile(filePath, cwd, options = {}) {
   const start = Date.now();
   const result = await dispatchLintWithResult(absPath, cwd, host, void 0, void 0, {
     blockingOnly: options.blockingOnly ?? false,
+    analysisRootMode: resolveAnalysisRoot(absPath, cwd),
     // #3791: this is a pull surface. Each call is an independent question,
     // so the synthetic coverage notice must come back on every call rather
     // than being latched once per session by the dispatcher — otherwise a
@@ -12259,6 +13253,18 @@ export {
   CacheManager,
   getDiagnosticTracker,
   normalizeRuleId,
+  readFileContent,
+  applyRulePolicy,
+  convertLspDiagnostics,
+  applyFindingPolicy,
+  loadProjectRulePolicyMap,
+  inlineBlockerIdentities,
+  applyPushedFindingPolicy,
+  applyPushedFindingPolicyByFile,
+  applyLspFindingPolicy,
+  filterFindingsByDisposition,
+  stampLineHashes,
+  owedByContentOnly,
   getToolPlan,
   resetObservedRunnerLatency,
   requeueRunnerFindings,
@@ -12266,25 +13272,28 @@ export {
   dropStaleRunnerFindings,
   resetPendingRunnerFindings,
   pendingRunnerFindingsSize,
-  applyRulePolicy,
+  laneCopyStandsFor,
   DELTA_UNUSED_PROMOTION_NOTE,
   formatDiagnostics,
   createDispatchContext,
   getLatencyReports,
   cascadeSettleWaitMs,
-  convertLspDiagnostics,
-  applyFindingPolicy,
-  loadProjectRulePolicyMap,
-  inlineBlockerIdentities,
-  applyPushedFindingPolicy,
-  applyLspFindingPolicy,
-  filterFindingsByDisposition,
   markUnreconciledFindings,
   formatCacheAgeLabel,
+  dispositionSuppressedLine,
   admitsProjectWideFindings,
+  formatCascadeNeighborDiagnostics,
+  composeCascadeSection,
   cascadeCarrySuffix,
+  markCascadeUnansweredPrimariesDelivered,
+  renderCascadeResult,
+  cascadeStillPresentSince,
+  recordDeliveredCascadeNeighbor,
+  forgetCascadePendingNeighbor,
+  listCascadePendingNeighbors,
   logCascade,
   resetCascadeTierSessionState,
+  peekOutstandingCascadeTouches,
   loadSg,
   canHandle,
   getLang,