@herbertgao/pi-extensions 2026.10.2 → 2026.10.3

package/node_modules/pi-lens/dist/{chunk-TVN5N6GY.js → chunk-MTDRLSI7.js}

@@ -1,66 +1,69 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   emitBounded
-} from "./chunk-ARFCXG7S.js";
+} from "./chunk-OZJINN4O.js";
 import {
   createReadGuardEditBatchSummary,
   getReadGuardCorrelationId,
   logReadGuardEvent,
   normalizeMessage,
+  sanitizeCorrelationId,
   stableFindingId
-} from "./chunk-OAXNDZJ7.js";
+} from "./chunk-3JSEWUWI.js";
 import {
   mapWithConcurrency
 } from "./chunk-XIMYZ3JA.js";
 import {
-  LSP_SERVERS,
   classifyCascadeWaitTier,
   classifyServerWaitTier,
   enforceLspRootCeiling,
   findLocalTyposConfig,
   getAstGrepRuleSources,
+  getServerById,
   getServerInitOverride,
   getServersForFileWithConfig,
   getSessionRootsForTelemetry,
   getStrategy,
   hasProjectBoundaryMarker,
+  isAuxiliary,
   isDirectLspCommandTemporarilyUnavailable,
   isOutsideAllSessionRoots,
   resetClassicTsRepairGuard,
   resetLspLaunchAvailabilityGeneration,
-  resolveLspServerCwd
-} from "./chunk-B3I2UUT4.js";
+  resolveLspServerCwd,
+  serverTraits
+} from "./chunk-IQZXOZ7S.js";
 import {
   findLocalOpengrepConfig
-} from "./chunk-VDBPVIKD.js";
+} from "./chunk-U52SAGRM.js";
 import {
   getSharedTreeSitterClient,
   loadWebTreeSitter,
   logTreeSitterDiagnostic,
   resolveTreeSitterLanguage,
   wasmQueryInput
-} from "./chunk-LW6XKDZQ.js";
+} from "./chunk-UEAHAMEI.js";
 import {
   EXTENSION_TO_GRAMMAR,
   EXTENSION_TO_LSP_ID,
   KIND_TO_GRAMMAR
-} from "./chunk-TGPXLY2J.js";
+} from "./chunk-KJCWXUUS.js";
 import {
   js_yaml_default
 } from "./chunk-QOZXJ4NA.js";
 import {
   buildModuleGraph
-} from "./chunk-V7R425XG.js";
+} from "./chunk-6XX5HCLK.js";
 import {
   HOOK_WALL_BUDGET_MS,
   bounded,
   withDeadline,
   withTimeout
-} from "./chunk-GUOGVTCQ.js";
+} from "./chunk-F5VLZHUW.js";
 import {
   loadProjectSnapshot,
   readJsonCache
-} from "./chunk-AJVLWNFN.js";
+} from "./chunk-AXKPQ6ZI.js";
 import {
   PathKeyedMap
 } from "./chunk-Z3CCVDUB.js";
@@ -70,19 +73,19 @@ import {
   requestWarmCodeActions,
   requestWarmDiagnostics,
   toRunnerDisplayPath
-} from "./chunk-PWFHBTSF.js";
+} from "./chunk-XGUL4SLQ.js";
 import {
   findLocalZizmorConfig,
   logSessionStart
-} from "./chunk-OQGFCZJ4.js";
+} from "./chunk-LD7WFTRX.js";
 import {
   assertInstallAllowed,
   isLspSpawnAllowedByTrust,
   projectTrustDenialReason
-} from "./chunk-NTUJEGDZ.js";
+} from "./chunk-D6YF5HKX.js";
 import {
   getLspCapableKinds
-} from "./chunk-22AVIGXS.js";
+} from "./chunk-VYKKMYVT.js";
 import {
   createGenerationMap,
   createGenerationSource,
@@ -101,22 +104,22 @@ import {
   removeLspChild,
   sampleProcessTreeCpuPercent,
   selectLivePeerInstances
-} from "./chunk-VN2AXLEX.js";
+} from "./chunk-T54VJRAD.js";
 import {
   createSingleFlight
 } from "./chunk-BW5KFIQC.js";
 import {
   SPECIAL_FILENAMES,
   getLanguageId
-} from "./chunk-5ZEJHV35.js";
+} from "./chunk-64LU2OVH.js";
 import {
   detectFileRole
-} from "./chunk-DQ2NZ7C4.js";
+} from "./chunk-N2IRDBZI.js";
 import {
   findGoverningTsconfigDir,
   getDirectoryMarkers,
   registerWorkspaceTopologyReset
-} from "./chunk-VNMT7C64.js";
+} from "./chunk-Z6BB4JLQ.js";
 import {
   writeFileAtomic
 } from "./chunk-2EECBNC5.js";
@@ -125,15 +128,15 @@ import {
   incrementDegradationCount,
   recordDegradation,
   recordDegradationOnce
-} from "./chunk-N3YQJI6O.js";
+} from "./chunk-7ELY2CSM.js";
 import {
   logExtension
-} from "./chunk-O6TQT6RI.js";
+} from "./chunk-34OCDWOS.js";
 import {
   logLatency,
   phaseFinished,
   phaseStarted
-} from "./chunk-5THXD6X5.js";
+} from "./chunk-3PNFWVHT.js";
 import {
   createNdjsonLogger,
   getGlobalPiLensLogDir,
@@ -142,7 +145,7 @@ import {
   isTestMode,
   nextModuleEvaluationOrdinal,
   toPositiveFinite
-} from "./chunk-UK3CMEAL.js";
+} from "./chunk-VSMJK3ZJ.js";
 import {
   BoundedFifoMap,
   BoundedLruCache,
@@ -157,11 +160,12 @@ import {
   normalizeFilePath,
   normalizeMapKey,
   pathsEqual,
+  realpathOrResolve,
   toPosix,
   toProjectRelativePath,
   uriToDiskPath,
   uriToPath
-} from "./chunk-Q5U6FMDI.js";
+} from "./chunk-G3RLJYA2.js";
 import {
   __commonJS,
   __require,
@@ -3966,7 +3970,7 @@ function resyncDocumentOnPastEof(filePath) {
   void (async () => {
     try {
       const [{ getLSPService: getLSPService2 }, content] = await Promise.all([
-        import("./chunk-VCSRSYLF.js"),
+        import("./chunk-RJFED73B.js"),
         fs.promises.readFile(filePath, "utf-8")
       ]);
       await getLSPService2().openFile(filePath, content, {
@@ -4510,7 +4514,7 @@ function findGoModule(cwd, filePath) {
   while (true) {
     try {
       const content = fs3.readFileSync(path2.join(dir, "go.mod"), "utf-8");
-      const m = content.match(/^\s*module\s+(\S+)/m);
+      const m = content.match(/^[^\S\n\r\u2028\u2029]*module\s+(\S+)/m);
       if (m)
         return { moduleDir: dir, modulePath: m[1] };
     } catch {
@@ -6193,6 +6197,7 @@ var liveEmitter = createLiveBusEmitter();
 var liveEmitter2 = createLiveBusEmitter();
 
 // dist/clients/read-guard.js
+import { createHash as createHash3 } from "node:crypto";
 import * as fs7 from "node:fs";
 
 // dist/clients/file-time.js
@@ -6558,6 +6563,71 @@ var DEFAULT_CONFIG = {
 };
 var READ_HASH_MAX_LINES = Math.max(0, Number.parseInt(process.env.PI_LENS_READ_GUARD_HASH_MAX_LINES ?? "3000", 10) || 3e3);
 var READ_BINDING_MAX_BYTES = 4 * 1024 * 1024;
+function hashFileBytes(filePath) {
+  return createHash3("sha256").update(fs7.readFileSync(filePath)).digest("hex");
+}
+var ABSENT_SIZE = -1;
+function observeAuthoredBytes(filePath, knownHash, authoredRanges) {
+  try {
+    const stat2 = fs7.statSync(filePath);
+    const hash = knownHash !== void 0 ? knownHash : stat2.size <= READ_BINDING_MAX_BYTES ? hashFileBytes(filePath) : void 0;
+    return {
+      size: stat2.size,
+      mtimeMs: stat2.mtimeMs,
+      ctimeMs: stat2.ctimeMs,
+      ...hash !== void 0 && { hash },
+      ...authoredRanges !== void 0 && { authoredRanges },
+      ...authoredRanges !== void 0 && {
+        authoredLineCount: splitLines(fs7.readFileSync(filePath, "utf-8")).length
+      }
+    };
+  } catch {
+    return { size: ABSENT_SIZE, mtimeMs: 0, ctimeMs: 0 };
+  }
+}
+function composeAuthoredRanges(previous, next, nextLineCount) {
+  const ranges = previous.authoredLineCount !== void 0 && nextLineCount === previous.authoredLineCount ? [...previous.authoredRanges ?? [], ...next] : next;
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const [start, end] of sorted) {
+    const last = merged.at(-1);
+    if (last && start <= last[1] + 1)
+      last[1] = Math.max(last[1], end);
+    else
+      merged.push([start, end]);
+  }
+  return merged;
+}
+function authoredRangeCovers(authored, touchedLines, editRanges) {
+  if (authored.authoredRanges === void 0)
+    return true;
+  const requested = editRanges ?? (touchedLines ? [touchedLines] : void 0);
+  return requested !== void 0 && requested.every(([start, end]) => authored.authoredRanges.some(([authoredStart, authoredEnd]) => start >= authoredStart && end <= authoredEnd));
+}
+function isValidAuthoredRanges(value) {
+  return Array.isArray(value) && value.every((range) => Array.isArray(range) && range.length === 2 && Number.isFinite(range[0]) && Number.isFinite(range[1]));
+}
+function authoredBytesIntact(filePath, authored) {
+  let stat2;
+  try {
+    stat2 = fs7.statSync(filePath);
+  } catch {
+    return authored.size === ABSENT_SIZE;
+  }
+  if (stat2.size === authored.size && stat2.mtimeMs === authored.mtimeMs && stat2.ctimeMs === authored.ctimeMs)
+    return true;
+  if (authored.hash === void 0 || stat2.size !== authored.size)
+    return false;
+  try {
+    if (hashFileBytes(filePath) !== authored.hash)
+      return false;
+  } catch {
+    return false;
+  }
+  authored.mtimeMs = stat2.mtimeMs;
+  authored.ctimeMs = stat2.ctimeMs;
+  return true;
+}
 var READ_GUARD_MAX_FILES = 256;
 var READ_GUARD_MAX_RECORDS_PER_FILE = 128;
 var NO_TRIM = {
@@ -6592,6 +6662,9 @@ function enforceRecordCapForFile(records) {
 }
 var READ_GUARD_MAX_EDITS_PER_FILE = 256;
 var READ_GUARD_MAX_UNCONSUMED_FILES = 4096;
+var READ_GUARD_MAX_AUTHORED_FILES = READ_GUARD_MAX_UNCONSUMED_FILES;
+var READ_GUARD_MAX_CHECKED_CALLS = 16;
+var READ_GUARD_MAX_CHECKED_PATHS_PER_CALL = 128;
 var READ_GUARD_IDLE_EVICT_MS_DEFAULT = 30 * 6e4;
 function _currentContentMatchesBindingForTests(filePath, binding) {
   try {
@@ -6708,7 +6781,19 @@ var ReadGuard = class {
   // Files that recordWritten() has fired on this session: the only evidence
   // of session authorship, independent of filesystem mtime granularity or
   // clock skew (NFS, FAT32, etc.) and of other writers' mtimes (#3520).
-  writtenThisSession = /* @__PURE__ */ new Set();
+  // Each holds the content identity of the bytes the conversation last
+  // wrote; authorship ends (`retired`) when the disk's bytes differ (#4131).
+  writtenThisSession = /* @__PURE__ */ new Map();
+  // #4187 R4-1: the paths each in-flight call's own `tool_call` pre-write
+  // check ran on, keyed by the call id (`noteCheckedPaths`). A write that
+  // carries no bytes of its own may re-baseline an authorship ONLY for a path
+  // in its own call's set, because the set a tool NAMES at `tool_call` can be
+  // narrower than the set it WRITES: a rename's importers, an ast-grep folder
+  // or its project default, a server-initiated `workspace/applyEdit` that has
+  // no call at all. Bounded by READ_GUARD_MAX_CHECKED_CALLS; session state,
+  // so it dies with the guard every session start replaces, and a branch move
+  // clears it with the authorship it licenses.
+  checkedPathsByCall = /* @__PURE__ */ new Map();
   // Files whose write record idle-expired (#3520): `evictFile` drops the
   // authorship with the rest of the file's state, and a later zero-read edit
   // must say so instead of "you have not read" (false for a file the agent
@@ -6777,6 +6862,15 @@ var ReadGuard = class {
   key(filePath) {
     return normalizeFilePath(filePath);
   }
+  /**
+   * License keys compare paths independently resolved by the tool_call and
+   * the writer. Unlike the general map key, this identity must collapse a
+   * symlink spelling to the file it names; missing files retain an absolute
+   * resolved fallback so the comparison still fails closed.
+   */
+  licenseKey(filePath) {
+    return normalizeFilePath(realpathOrResolve(filePath));
+  }
   idleEvictMs() {
     const value = Number.parseInt(process.env.PI_LENS_READ_GUARD_IDLE_EVICT_MS ?? "", 10);
     return Number.isSafeInteger(value) && value > 0 ? value : READ_GUARD_IDLE_EVICT_MS_DEFAULT;
@@ -6850,17 +6944,58 @@ var ReadGuard = class {
    * and log it once per file (the set is the once-only gate). The set holds
    * at most `READ_GUARD_MAX_FILES` files, oldest dropped first.
    */
-  noteExpiredWrite(filePath) {
+  noteExpiredWrite(filePath, reason = "idle-timeout") {
     if (this.expiredWrites.has(filePath))
       return;
     this.expiredWrites.add(filePath);
+    if (reason === "authorship-cap") {
+      const isRisingEdge = incrementDegradationCount({
+        kind: "read-guard-authorship-cap",
+        subject: this.sessionId,
+        reason: "authorship cap evicted a live write record"
+      });
+      if (isRisingEdge) {
+        logReadGuardEvent({
+          event: "read_file_evicted",
+          sessionId: this.sessionId,
+          filePath,
+          metadata: { reason, authorshipDropped: true }
+        });
+      }
+      return;
+    }
     logReadGuardEvent({
       event: "read_file_evicted",
       sessionId: this.sessionId,
       filePath,
-      metadata: { reason: "idle-timeout", authorshipDropped: true }
+      metadata: { reason, authorshipDropped: true }
     });
   }
+  /**
+   * #4187 R2-6: hold `writtenThisSession` at READ_GUARD_MAX_AUTHORED_FILES.
+   * A retired entry blocks like no entry, so it goes first; a live one is
+   * dropped least recently credited first, as an expired write (#3520).
+   */
+  enforceAuthorshipCap() {
+    let excess = this.writtenThisSession.size - READ_GUARD_MAX_AUTHORED_FILES;
+    if (excess <= 0)
+      return;
+    for (const [filePath, authored] of this.writtenThisSession) {
+      if (excess <= 0)
+        return;
+      if (!authored.retired)
+        continue;
+      this.writtenThisSession.delete(filePath);
+      excess -= 1;
+    }
+    for (const filePath of this.writtenThisSession.keys()) {
+      if (excess <= 0)
+        return;
+      this.writtenThisSession.delete(filePath);
+      this.noteExpiredWrite(filePath, "authorship-cap");
+      excess -= 1;
+    }
+  }
   touchFile(filePath) {
     const now = Date.now();
     this.fileLastUsed.set(filePath, now);
@@ -6893,19 +7028,63 @@ var ReadGuard = class {
     }
   }
   // --- Public API ---
+  /**
+   * Drop every provisional native-read capture still held. The run boundary's
+   * backstop (`handleAgentEnd`): a call's capture is released when the call
+   * ends ({@link dropProvisionalReadByCall}), and only a run that dies
+   * between a read's tool_call and its tool_execution_end leaves one here
+   * (#4185 R2-3, round 4). Returns how many it dropped.
+   */
+  dropProvisionalReads() {
+    let dropped = 0;
+    for (const [filePath, records] of this.reads) {
+      const kept = records.filter((record2) => {
+        if (!record2.provisional)
+          return true;
+        dropped += 1;
+        return false;
+      });
+      if (kept.length === 0)
+        this.reads.delete(filePath);
+      else if (kept.length !== records.length)
+        this.reads.set(filePath, kept);
+    }
+    return dropped;
+  }
+  /**
+   * Drop the tool_call capture of the read call `toolCallId` (the record
+   * whose `source` is `native-read:<call>:provisional`), whatever path
+   * spelling the call's result carries. The delivered record supersedes it
+   * ({@link recordRead}); a call that ended in error, failed by the host or
+   * blocked by a later extension, releases it at tool_execution_end
+   * (`handleToolExecutionEnd`), because alone it satisfied the zero-read
+   * check for an oldText edit of lines the agent never saw (#4185 rounds 2
+   * to 4; `formal/read-guard` FailedReadLive, BlockedReadLive). Keyed by
+   * the call's own identity: a nested call's is unique where its parent's,
+   * the transcript identity a record carries, is shared by every read a
+   * script makes. Returns whether a capture was found.
+   */
+  dropProvisionalReadByCall(toolCallId) {
+    for (const [filePath, records] of this.reads) {
+      const source = `native-read:${toolCallId}:provisional`;
+      const index = records.findIndex((record2) => record2.source === source);
+      if (index < 0)
+        continue;
+      records.splice(index, 1);
+      if (records.length === 0)
+        this.reads.delete(filePath);
+      return true;
+    }
+    return false;
+  }
   /**
    * Record that a file was read.
    * Call this from the tool_call handler after any LSP expansion.
    */
   recordRead(record2, opts) {
     const filePath = this.key(record2.filePath);
-    if (opts?.supersedes) {
-      const records = this.reads.get(filePath);
-      const provisionalSource = `native-read:${opts.supersedes.toolCallId}:provisional`;
-      const provisionalIndex = records?.findIndex((candidate) => candidate.source === provisionalSource);
-      if (provisionalIndex !== void 0 && provisionalIndex >= 0)
-        records.splice(provisionalIndex, 1);
-    }
+    if (opts?.supersedes)
+      this.dropProvisionalReadByCall(opts.supersedes.toolCallId);
     this.knownPathIndex.set(normalizeEphemeralMapKey(record2.filePath), filePath);
     const storedRecord = {
       ...record2,
@@ -6988,6 +7167,101 @@ var ReadGuard = class {
     if (opts?.stampFileTime !== false)
       this.fileTime.read(storedRecord.filePath);
   }
+  /**
+   * #4131: end the file's authorship when its bytes are no longer the ones the
+   * conversation last wrote. Called by every guard decision that relies on
+   * authorship: the zero-read edit check, and the start of a write that
+   * carries no bytes of its own (a recognized bash write's tool_call, the
+   * agent_end drain), which would otherwise re-baseline over the other
+   * writer's bytes. Returns true when it ended the authorship here.
+   */
+  retireChangedAuthorship(rawFilePath) {
+    return this.retireIfChanged(this.key(rawFilePath));
+  }
+  /**
+   * #4187 R4-1: record the paths THIS call's `tool_call` pre-write check ran
+   * on, so the call's own bytes-less write may advance exactly those and no
+   * other path it changes. The `tool_call` handler calls it beside
+   * {@link retireChangedAuthorship}: the licensed set IS the checked set.
+   *
+   * A call id both sides normalize with `sanitizeCorrelationId`, so a producer
+   * passes the host's raw id. No id (a server-initiated `workspace/applyEdit`,
+   * a drain) licenses nothing. Both caps fail closed: a path past
+   * READ_GUARD_MAX_CHECKED_PATHS_PER_CALL, or one named by a call evicted
+   * past READ_GUARD_MAX_CHECKED_CALLS, ends an authorship instead of
+   * re-baselining it, which costs a read and never vouches for a byte the
+   * conversation did not see.
+   */
+  noteCheckedPaths(rawToolCallId, rawPaths) {
+    const toolCallId = sanitizeCorrelationId(rawToolCallId);
+    if (toolCallId === void 0 || rawPaths.length === 0)
+      return;
+    let checked = this.checkedPathsByCall.get(toolCallId);
+    if (!checked) {
+      checked = /* @__PURE__ */ new Set();
+      this.checkedPathsByCall.set(toolCallId, checked);
+      while (this.checkedPathsByCall.size > READ_GUARD_MAX_CHECKED_CALLS) {
+        const oldest = this.checkedPathsByCall.keys().next();
+        if (oldest.done === true)
+          break;
+        this.checkedPathsByCall.delete(oldest.value);
+      }
+    }
+    for (const rawPath of rawPaths) {
+      if (checked.size >= READ_GUARD_MAX_CHECKED_PATHS_PER_CALL)
+        return;
+      checked.add(this.licenseKey(rawPath));
+    }
+  }
+  /**
+   * Consume whether `toolCallId`'s own `tool_call` licensed this path
+   * ({@link noteCheckedPaths}). A `(call,path)` license is single-use: a
+   * settled call id must not re-baseline a later writer's bytes.
+   */
+  consumeCheckedAtCall(toolCallId, filePath) {
+    const callId = sanitizeCorrelationId(toolCallId);
+    if (callId === void 0)
+      return false;
+    const checked = this.checkedPathsByCall.get(callId);
+    const licensedPath = this.licenseKey(filePath);
+    if (checked?.has(licensedPath) !== true)
+      return false;
+    checked.delete(licensedPath);
+    if (checked.size === 0)
+      this.checkedPathsByCall.delete(callId);
+    return true;
+  }
+  /**
+   * {@link retireChangedAuthorship} on a key. `writer` names a write that
+   * ended it after the fact (a bridge write, which no pre-write check
+   * guarded), so the record tells the two triggers apart.
+   */
+  retireIfChanged(filePath, writer3, force = false) {
+    const authored = this.writtenThisSession.get(filePath);
+    if (!authored || authored.retired || !force && authoredBytesIntact(filePath, authored))
+      return false;
+    authored.retired = true;
+    const isRisingEdge = incrementDegradationCount({
+      kind: "read-guard-authorship-retired",
+      subject: filePath,
+      reason: force ? "authored range was unknown; the next edit needs a read" : "another writer changed the bytes the conversation wrote; the next edit needs a read"
+    });
+    if (isRisingEdge)
+      logReadGuardEvent({
+        event: "authorship_retired",
+        sessionId: this.sessionId,
+        filePath,
+        metadata: {
+          authoredSize: authored.size,
+          hashed: authored.hash !== void 0,
+          ...writer3 !== void 0 && { writer: writer3 },
+          ...authored.toolCallId !== void 0 && {
+            toolCallId: authored.toolCallId
+          }
+        }
+      });
+    return true;
+  }
   /**
    * #3525: whether the disk may hold bytes no read or own write accounts
    * for: FileTime moved since its stamp, or there is none. An edit that
@@ -7069,14 +7343,29 @@ var ReadGuard = class {
     const effectiveMode = exemptionMode === "warn" ? "warn" : void 0;
     const fileReads = this.reads.get(filePath);
     if (!fileReads || fileReads.length === 0) {
-      if (this.writtenThisSession.has(filePath)) {
-        this.injectCreationRead(filePath, 0, 0);
+      this.retireChangedAuthorship(filePath);
+      if (this.writtenThisSession.get(filePath)?.retired) {
+        const verdict3 = this.blockOrWarn("authorship-retired", `\u{1F504} RETRYABLE \u2014 File modified since your write: \`${filePath}\` no longer holds the bytes this conversation wrote. Read it first, then retry: \`read path="${filePath}"\`.`, void 0, effectiveMode);
+        this.recordVerdict(filePath, "edit", touchedLines, verdict3, {
+          reasonKind: "authorship_retired"
+        });
+        return verdict3;
+      }
+      const authored = this.writtenThisSession.get(filePath);
+      if (authored && authoredRangeCovers(authored, touchedLines, editRanges)) {
         const verdict3 = this.allow();
         this.recordVerdict(filePath, "edit", touchedLines, verdict3, {
           reasonKind: "session_authored"
         });
         return verdict3;
       }
+      if (authored) {
+        const verdict3 = this.blockOrWarn("authorship-range", `\u{1F504} RETRYABLE \u2014 Edit without read: this write only covered part of \`${filePath}\`; read the requested lines first, then retry.`, void 0, effectiveMode);
+        this.recordVerdict(filePath, "edit", touchedLines, verdict3, {
+          reasonKind: "authorship_range"
+        });
+        return verdict3;
+      }
       const writeRecordExpired = this.expiredWrites.has(filePath);
       const verdict2 = this.blockOrWarn("zero-read", writeRecordExpired ? `\u{1F504} RETRYABLE \u2014 Edit without read: the earlier write record for \`${filePath}\` expired, so it needs a read again. Read it first, then retry: \`read path="${filePath}"\`.` : `\u{1F504} RETRYABLE \u2014 Edit without read: you have not read \`${filePath}\` in this conversation. Read it first, then retry: \`read path="${filePath}"\`.`, void 0, effectiveMode);
       this.recordVerdict(filePath, "edit", touchedLines, verdict2, {
@@ -7267,7 +7556,7 @@ Re-read the relevant section, then retry the edit using the current line range/c
    */
   getTrackedPaths() {
     const tracked = new Set(this.reads.keys());
-    for (const written of this.writtenThisSession)
+    for (const written of this.writtenThisSession.keys())
       tracked.add(written);
     return [...tracked];
   }
@@ -7335,7 +7624,7 @@ Re-read the relevant section, then retry the edit using the current line range/c
     this.knownPathIndex.set(normalizeEphemeralMapKey(rawFilePath), filePath);
     if (opts?.stampFileTime !== false)
       this.fileTime.read(filePath);
-    this.writtenThisSession.add(filePath);
+    this.creditAuthorship(filePath, opts);
     if (this.reads.has(filePath))
       this.consumedReadFiles.add(filePath);
     this.touchFile(filePath);
@@ -7436,24 +7725,68 @@ Re-read the relevant section, then retry the edit using the current line range/c
   }
   /**
    * The files this session authored (#3612, D5): `writtenThisSession`, which
-   * the zero-read check reads. A `/reload` keeps the conversation and its branch, so the
-   * reloaded guard keeps them; every other start resets them.
+   * the zero-read check reads, each with the content identity and transcript
+   * id of its write (#4131, #3603).
    */
   exportAuthorship() {
-    return { written: [...this.writtenThisSession] };
+    return {
+      // A released reader treats every `written` path as authored, so a
+      // retired one is carried in `entries` only.
+      written: [...this.writtenThisSession].flatMap(([filePath, authored]) => authored.retired ? [] : [filePath]),
+      entries: [...this.writtenThisSession].map(([filePath, authored]) => ({
+        filePath,
+        ...authored
+      }))
+    };
   }
   /**
-   * Restore {@link exportAuthorship}'s output. Null-safe on a malformed
-   * payload; a row from a released writer may carry a `sessionStartMs`, which
-   * is ignored.
+   * Restore {@link exportAuthorship}'s output for the branch this session
+   * starts on (#3603): the {@link importBranch} rule, an entry is imported
+   * iff its write's `toolCallId` is in `onBranch`. Its content identity
+   * comes with it, so bytes another writer changed meanwhile end it at the
+   * next check. A released writer's row (#3612: `written` paths only, maybe a
+   * `sessionStartMs`) names no write, so it imports nothing. Null-safe on a
+   * malformed payload; never throws.
    */
-  importAuthorship(state5) {
+  importAuthorship(state5, onBranch) {
+    const result = { imported: 0, dropped: 0 };
     const authorship = state5;
+    const entries = Array.isArray(authorship?.entries) ? authorship.entries : [];
+    const withEntry = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const candidate = entry;
+      if (typeof candidate?.filePath !== "string")
+        continue;
+      withEntry.add(candidate.filePath);
+      if (typeof candidate.toolCallId !== "string" || !onBranch.has(candidate.toolCallId) || typeof candidate.size !== "number" || typeof candidate.mtimeMs !== "number" || typeof candidate.ctimeMs !== "number" || candidate.hash !== void 0 && typeof candidate.hash !== "string" || candidate.retired !== void 0 && candidate.retired !== true || candidate.authoredRanges !== void 0 && !isValidAuthoredRanges(candidate.authoredRanges) || candidate.authoredLineCount !== void 0 && typeof candidate.authoredLineCount !== "number") {
+        result.dropped += 1;
+        continue;
+      }
+      const filePath = this.key(candidate.filePath);
+      this.knownPathIndex.set(normalizeEphemeralMapKey(candidate.filePath), filePath);
+      this.writtenThisSession.set(filePath, {
+        size: candidate.size,
+        mtimeMs: candidate.mtimeMs,
+        ctimeMs: candidate.ctimeMs,
+        ...candidate.hash !== void 0 && { hash: candidate.hash },
+        toolCallId: candidate.toolCallId,
+        ...candidate.retired === true && { retired: true },
+        ...candidate.authoredRanges !== void 0 && {
+          authoredRanges: candidate.authoredRanges
+        },
+        ...candidate.authoredLineCount !== void 0 && {
+          authoredLineCount: candidate.authoredLineCount
+        }
+      });
+      result.imported += 1;
+    }
+    this.enforceAuthorshipCap();
     if (Array.isArray(authorship?.written)) {
       for (const filePath of authorship.written)
-        if (typeof filePath === "string")
-          this.writtenThisSession.add(filePath);
+        if (typeof filePath === "string" && !withEntry.has(filePath))
+          result.dropped += 1;
     }
+    return result;
   }
   /**
    * Keep exactly the reads the conversation still shows the agent, after it
@@ -7464,8 +7797,10 @@ Re-read the relevant section, then retry the edit using the current line range/c
    * is re-verified or re-stamped here: the FileTime stamps are cleared, so
    * each kept record must pass the per-line hash check against disk at the
    * next edit. A stamp taken on the abandoned branch would otherwise vouch
-   * for bytes this branch never showed. Edits, authored-write and
-   * pending-creation state came from the old branch too, so they go.
+   * for bytes this branch never showed. Authorship follows the same rule
+   * (#3603): it stays, retired or not, iff the write it came from is on the
+   * branch, and its content identity still decides. Edits, idle-expiry
+   * marks and pending creations came from the old branch, so they go.
    */
   retainBranch(onBranch) {
     const result = { kept: 0, dropped: 0 };
@@ -7482,10 +7817,13 @@ Re-read the relevant section, then retry the edit using the current line range/c
       }
       this.reads.delete(filePath);
     }
+    for (const [filePath, authored] of this.writtenThisSession)
+      if (authored.toolCallId === void 0 || !onBranch.has(authored.toolCallId))
+        this.writtenThisSession.delete(filePath);
     this.edits.clear();
-    this.writtenThisSession.clear();
     this.expiredWrites.clear();
     this.pendingCreations.clear();
+    this.checkedPathsByCall.clear();
     this.fileTime.clear();
     moveBranch(this.scope);
     return result;
@@ -7555,6 +7893,70 @@ Re-read the relevant section, then retry the edit using the current line range/c
     return this.edits.get(key) ?? [];
   }
   // --- Private helpers ---
+  /**
+   * #4187 R4-1: whether a write may re-baseline an EXISTING authorship over
+   * the bytes it just landed. One rule, three caller classes:
+   *
+   * - `advanceAuthorship` omitted — the caller checked this exact path
+   *   immediately before writing (a native edit's preflight, a drain's
+   *   `retireChangedAuthorshipBeforeDrain`), so the only unaccounted bytes
+   *   are its own. Advance.
+   * - `true` — a bytes-less in-process tool write (an LSP edit, an ast-grep
+   *   apply, a diagnostic-mark suppress, an observed replay). Advance only a
+   *   path its OWN `tool_call` checked ({@link noteCheckedPaths}): the set a
+   *   tool names can be narrower than the set it writes, and a path outside
+   *   it ends the authorship instead.
+   * - `false` — a record with no pre-write check at all (a co-process
+   *   producer, the settled sweep). Never advance.
+   *
+   * A path with no entry is a first credit only when the writer supplies
+   * evidence for it. Partial bridge credits retain their reported range;
+   * settled-sweep drift supplies no such evidence (#4210).
+   */
+  mayAdvanceAuthorship(filePath, opts) {
+    if (opts?.advanceAuthorship === void 0)
+      return true;
+    if (opts.advanceAuthorship !== true)
+      return false;
+    return this.consumeCheckedAtCall(opts.toolCallId, filePath);
+  }
+  /**
+   * #4131: record the content identity of the bytes `recordWritten` just
+   * credited. A retired authorship is never resumed (see
+   * `AuthoredBytes.retired`).
+   */
+  creditAuthorship(filePath, opts) {
+    const existing = this.writtenThisSession.get(filePath);
+    if (!existing && opts?.allowFirstAuthorship === false)
+      return;
+    if (existing?.retired)
+      return;
+    if (opts?.authorship === "unknown") {
+      if (existing)
+        this.retireIfChanged(filePath, "bridge", true);
+      return;
+    }
+    if (existing && !this.mayAdvanceAuthorship(filePath, opts)) {
+      this.retireIfChanged(filePath, "bridge");
+      return;
+    }
+    const observed = observeAuthoredBytes(filePath, opts?.contentHash, opts?.authoredRanges);
+    const { authoredRanges: _observedRanges, ...observedWithoutRanges } = observed;
+    const composedRanges = existing?.authoredRanges === void 0 ? existing ? void 0 : observed.authoredRanges : opts?.authoredRanges === void 0 ? void 0 : composeAuthoredRanges(existing, opts.authoredRanges, observed.authoredLineCount);
+    const toolCallId = opts?.toolCallId ?? existing?.toolCallId;
+    this.writtenThisSession.delete(filePath);
+    this.writtenThisSession.set(filePath, {
+      ...observedWithoutRanges,
+      ...composedRanges !== void 0 ? {
+        authoredRanges: composedRanges,
+        ...observed.authoredLineCount !== void 0 && {
+          authoredLineCount: observed.authoredLineCount
+        }
+      } : {},
+      ...toolCallId !== void 0 && { toolCallId }
+    });
+    this.enforceAuthorshipCap();
+  }
   /**
    * `writtenContent`, when the write's bytes are known, is the agent's view
    * of the file: hashed from it, not from a disk another writer may have
@@ -8841,7 +9243,7 @@ function classifyDiagnostic(d) {
 import * as path9 from "node:path";
 
 // dist/clients/dispatch/runners/yaml-rule-parser.js
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import * as fs10 from "node:fs";
 import * as path8 from "node:path";
 var OVERLY_BROAD_PATTERNS = ["$NAME", "$FIELD", "$_", "$X", "$VAR", "$EXPR"];
@@ -8884,8 +9286,14 @@ function loadYamlRuleFiles(files2, severityFilter) {
     const documents = content.split(/^---\s*$/m).filter((doc) => doc.trim());
     for (const document of documents) {
       const rule = parseSimpleYaml(document.trim());
-      if (!rule?.id)
+      if (!rule?.id) {
+        recordDegradationOnce({
+          kind: "ast-grep-rule-invalid",
+          subject: file,
+          reason: "ast-grep rule could not be parsed"
+        });
         continue;
+      }
       if (severityFilter && rule.severity !== severityFilter)
         continue;
       rules.push(rule);
@@ -8895,7 +9303,7 @@ function loadYamlRuleFiles(files2, severityFilter) {
 }
 function loadYamlRulesFresh(ruleDir, severityFilter) {
   const files2 = findYamlRuleFiles(ruleDir);
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   for (const file of files2) {
     hash.update(path8.relative(ruleDir, file));
     hash.update("\0");
@@ -9343,12 +9751,12 @@ function getFullScanWallClockMs() {
 }
 
 // dist/clients/lsp/document-drift.js
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import nodeFs from "node:fs";
 function fingerprintDocumentContent(content) {
   if (content.length <= 96)
     return `${content.length}:${content}`;
-  return `${content.length}:${createHash4("sha256").update(content).digest("hex")}`;
+  return `${content.length}:${createHash5("sha256").update(content).digest("hex")}`;
 }
 var SKIPPED = {
   checked: 0,
@@ -10100,7 +10508,10 @@ function uniqueDetails(files2, fileDetails) {
     const key = keyFor(detail.filePath);
     const previous = byPath.get(key);
     if (!previous) {
-      byPath.set(key, detail);
+      byPath.set(key, {
+        ...detail,
+        ranges: detail.ranges ?? (detail.range ? [detail.range] : void 0)
+      });
       continue;
     }
     byPath.set(key, {
@@ -10109,6 +10520,11 @@ function uniqueDetails(files2, fileDetails) {
         start: Math.min(previous.range.start, detail.range.start),
         end: Math.max(previous.range.end, detail.range.end)
       } : previous.range ?? detail.range,
+      ranges: [
+        ...previous.ranges ?? (previous.range ? [previous.range] : []),
+        ...detail.ranges ?? (detail.range ? [detail.range] : [])
+      ],
+      authorshipUnknown: previous.authorshipUnknown === true || detail.authorshipUnknown === true,
       importsChanged: previous.importsChanged || detail.importsChanged
     });
   }
@@ -10118,6 +10534,7 @@ function uniqueDetails(files2, fileDetails) {
     // range is still enough to invalidate the touched-file turn state;
     // never synchronously re-read the whole file here.
     range: { start: 1, end: 1 },
+    authorshipUnknown: true,
     importsChanged: true
   });
 }
@@ -10133,7 +10550,18 @@ function bookkeepLspMutation(context, files2, fileDetails) {
     }
     if (sessionLive && context.readGuard) {
       try {
-        context.readGuard.recordWritten(filePath, { stampFileTime: false });
+        context.readGuard.recordWritten(filePath, {
+          stampFileTime: false,
+          advanceAuthorship: true,
+          ...detail.authorshipUnknown !== true && detail.ranges !== void 0 && {
+            authorship: "partial",
+            authoredRanges: detail.ranges.map(({ start, end }) => [start, end])
+          },
+          ...detail.authorshipUnknown === true && { authorship: "unknown" },
+          ...context.toolCallId !== void 0 && {
+            toolCallId: context.toolCallId
+          }
+        });
       } catch (err) {
         context.dbg?.(`lsp mutation read-guard stamp failed for ${filePath}: ${err}`);
       }
@@ -10152,11 +10580,19 @@ function bookkeepLspMutation(context, files2, fileDetails) {
         }
       } else {
         try {
+          const editRanges = detail.ranges && detail.authorshipUnknown !== true ? detail.ranges.map(({ start, end }) => [start, end]) : detail.range && detail.authorshipUnknown !== true ? [[detail.range.start, detail.range.end]] : void 0;
           const recorded = bridge.recordMutation({
             filePath,
             kind: "edit",
-            editRanges: detail.range ? [[detail.range.start, detail.range.end]] : void 0,
+            ...detail.range !== void 0 && {
+              touchedLines: [detail.range.start, detail.range.end]
+            },
+            ...detail.authorshipUnknown === true && {
+              authorshipUnknown: true
+            },
+            ...editRanges !== void 0 ? { editRanges } : {},
             consumer: context.tool,
+            provenance: "observed",
             // Real value threaded through, not the bridge's own
             // historical `false` default (#2450 review round 2, F1) —
             // the tsserver organize-imports/add-import case is exactly
@@ -10166,7 +10602,12 @@ function bookkeepLspMutation(context, files2, fileDetails) {
             // enqueues a deferred autofix/format pass for an LSP-applied
             // edit (#2450 review round 2, F3).
             deferAutofix: false,
-            ...context.session && { lineage: context.session }
+            ...context.session && { lineage: context.session },
+            // #4187 R4-1: the same license the direct branch threads, so
+            // the two branches stay equivalent for the same write.
+            ...context.toolCallId !== void 0 && {
+              toolCallId: context.toolCallId
+            }
           });
           if (!recorded) {
             context.dbg?.(`lsp mutation bridge dropped ${filePath} (recordMutation() returned false \u2014 see the mutation_bridge debug output for the reason: malformed entry, out-of-scope path, or a bookkeeping error)`);
@@ -10349,10 +10790,10 @@ async function raceToCompletion(promises4, shouldComplete, options = { timeoutMs
   let completed = false;
   let remaining = promises4.length;
   const descriptors = options.descriptors ?? [];
-  const hasAuxiliaries = descriptors.some((d) => d.role === "auxiliary");
-  const auxIndices = hasAuxiliaries ? new Set(descriptors.map((d, i) => d.role === "auxiliary" ? i : -1).filter((i) => i >= 0)) : /* @__PURE__ */ new Set();
-  const primaryCount = promises4.length - auxIndices.size;
-  let primaryRemaining = primaryCount;
+  const hasAuxiliaries = descriptors.some((d) => isAuxiliary(d));
+  const auxIndices = hasAuxiliaries ? new Set(descriptors.map((d, i) => isAuxiliary(d) ? i : -1).filter((i) => i >= 0)) : /* @__PURE__ */ new Set();
+  const languageCount = promises4.length - auxIndices.size;
+  let languageRemaining = languageCount;
   let auxGraceStarted = false;
   return new Promise((resolve9) => {
     const timeout = setTimeout(() => {
@@ -10394,7 +10835,7 @@ async function raceToCompletion(promises4, shouldComplete, options = { timeoutMs
         finalize();
         return;
       }
-      if (hasAuxiliaries && primaryRemaining === 0 && !auxGraceStarted) {
+      if (hasAuxiliaries && languageRemaining === 0 && !auxGraceStarted) {
         startAuxGrace();
       }
       const collected = results.filter((r) => r !== void 0);
@@ -10402,7 +10843,7 @@ async function raceToCompletion(promises4, shouldComplete, options = { timeoutMs
         if (options.graceMs !== void 0 && options.graceMs > 0 && !graceTimer) {
           graceTimer = setTimeout(() => finalize(), options.graceMs);
         } else if (auxGraceStarted) {
-        } else if (!hasAuxiliaries || primaryRemaining === 0) {
+        } else if (!hasAuxiliaries || languageRemaining === 0) {
           finalize();
         }
       }
@@ -10415,14 +10856,14 @@ async function raceToCompletion(promises4, shouldComplete, options = { timeoutMs
           results[index] = result;
           remaining--;
           if (!isAux)
-            primaryRemaining--;
+            languageRemaining--;
           check();
         }
       }).catch(() => {
         if (!completed) {
           remaining--;
           if (!isAux)
-            primaryRemaining--;
+            languageRemaining--;
           check();
         }
       });
@@ -11364,13 +11805,23 @@ async function applyWorkspaceEdit(edit, cwd, options = {}) {
           }
           const content = await fs11.readFile(diskPath, "utf-8");
           const updated = applyTextEditsToString(content, edits, "utf-16");
+          const changesLineCount = edits.some((edit2) => {
+            const removedLines = edit2.range.end.line - edit2.range.start.line;
+            const insertedLines = (edit2.newText.match(/\r\n|\r|\n/g) ?? []).length;
+            return removedLines !== insertedLines;
+          });
           await fs11.writeFile(diskPath, updated, "utf-8");
           const start = Math.min(...edits.map((item) => item.range.start.line + 1));
-          const end = Math.max(...edits.map((item) => item.range.end.line + 1));
+          const end = Math.max(...edits.map((item) => item.range.end.line + (item.range.end.character === 0 && item.range.end.line > item.range.start.line ? 0 : 1)));
           touchedFiles.add(filePath);
           fileDetails.push({
             filePath,
             range: { start, end },
+            ranges: edits.map((item) => ({
+              start: item.range.start.line + 1,
+              end: item.range.end.line + (item.range.end.character === 0 && item.range.end.line > item.range.start.line ? 0 : 1)
+            })),
+            authorshipUnknown: changesLineCount,
             importsChanged: importsSignature(content) !== importsSignature(updated)
           });
           markApplied(op);
@@ -11387,6 +11838,7 @@ async function applyWorkspaceEdit(edit, cwd, options = {}) {
           fileDetails.push({
             filePath,
             range: { start: 1, end: 1 },
+            authorshipUnknown: true,
             importsChanged: false
           });
           markApplied(op);
@@ -11405,10 +11857,12 @@ async function applyWorkspaceEdit(edit, cwd, options = {}) {
           fileDetails.push({
             filePath: oldPath,
             range: { start: 1, end: 1 },
+            authorshipUnknown: true,
             importsChanged: true
           }, {
             filePath: newPath,
             range: { start: 1, end: 1 },
+            authorshipUnknown: true,
             importsChanged: true
           });
           markApplied(op);
@@ -11424,6 +11878,7 @@ async function applyWorkspaceEdit(edit, cwd, options = {}) {
           fileDetails.push({
             filePath,
             range: { start: 1, end: 1 },
+            authorshipUnknown: true,
             importsChanged: true
           });
           markApplied(op);
@@ -15166,6 +15621,43 @@ function getLanguageId2(filePath) {
   return LANGUAGE_EXTENSIONS[base] ?? LANGUAGE_EXTENSIONS[base.toLowerCase()] ?? getBasenameLanguageId(base);
 }
 
+// dist/clients/lsp/spawn-history.js
+var MAX_SERVER_HISTORIES = 64;
+var successfulSpawnDurationMs = new BoundedFifoMap(MAX_SERVER_HISTORIES);
+function recordSuccessfulLspSpawn(serverId, durationMs) {
+  if (!Number.isFinite(durationMs) || durationMs < 0)
+    return;
+  successfulSpawnDurationMs.delete(serverId);
+  successfulSpawnDurationMs.set(serverId, durationMs);
+}
+function getSuccessfulLspSpawnDurationMs(serverId) {
+  return successfulSpawnDurationMs.get(serverId);
+}
+
+// dist/clients/lsp/auxiliary-lifecycle.js
+function readEnvAuxGraceMs() {
+  const raw = process.env.PI_LENS_AUX_GRACE_MS;
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return void 0;
+  return parsed;
+}
+var DEFAULT_AUX_GRACE_CEILING_MS = 2e3;
+var MAX_ADAPTIVE_AUX_GRACE_CEILING_MS = 8e3;
+var ADAPTIVE_AUX_GRACE_MARGIN_MS = 500;
+function auxWaitBudgetMs(serverId, isCold, configuredCeilingMs, declaredWaitMs) {
+  if (configuredCeilingMs !== void 0 || !isCold) {
+    return Math.min(declaredWaitMs, configuredCeilingMs ?? DEFAULT_AUX_GRACE_CEILING_MS);
+  }
+  const observedSpawnMs = getSuccessfulLspSpawnDurationMs(serverId);
+  if (observedSpawnMs === void 0 || observedSpawnMs <= 0) {
+    return Math.min(declaredWaitMs, DEFAULT_AUX_GRACE_CEILING_MS);
+  }
+  return Math.min(MAX_ADAPTIVE_AUX_GRACE_CEILING_MS, Math.max(declaredWaitMs, observedSpawnMs + ADAPTIVE_AUX_GRACE_MARGIN_MS));
+}
+
 // dist/clients/lazy-import.js
 function createLazyImport(load) {
   let cached;
@@ -15183,7 +15675,7 @@ function createLazyImport(load) {
 }
 
 // dist/clients/lsp-lazy.js
-var lazyLsp = createLazyImport(() => import("./chunk-VCSRSYLF.js"));
+var lazyLsp = createLazyImport(() => import("./chunk-RJFED73B.js"));
 function warmLspService() {
   return lazyLsp.get();
 }
@@ -15252,19 +15744,6 @@ function promoteToLocal(reason) {
   record("takeover", state4.cwd ?? process.cwd(), reason, pid);
 }
 
-// dist/clients/lsp/spawn-history.js
-var MAX_SERVER_HISTORIES = 64;
-var successfulSpawnDurationMs = new BoundedFifoMap(MAX_SERVER_HISTORIES);
-function recordSuccessfulLspSpawn(serverId, durationMs) {
-  if (!Number.isFinite(durationMs) || durationMs < 0)
-    return;
-  successfulSpawnDurationMs.delete(serverId);
-  successfulSpawnDurationMs.set(serverId, durationMs);
-}
-function getSuccessfulLspSpawnDurationMs(serverId) {
-  return successfulSpawnDurationMs.get(serverId);
-}
-
 // dist/clients/lsp/index.js
 function textDocumentSaveOf(client) {
   if (typeof client.getSaveOptions !== "function")
@@ -15425,29 +15904,7 @@ function readTsserverSyncGraceMs() {
     return 300;
   return parsed;
 }
-function readEnvAuxGraceMs() {
-  const raw = process.env.PI_LENS_AUX_GRACE_MS;
-  if (raw === void 0)
-    return void 0;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed < 0)
-    return void 0;
-  return parsed;
-}
-var DEFAULT_AUX_GRACE_CEILING_MS = 2e3;
-var MAX_ADAPTIVE_AUX_GRACE_CEILING_MS = 8e3;
 var MAX_TOUCH_CANDIDATES = 8;
-var ADAPTIVE_AUX_GRACE_MARGIN_MS = 500;
-function auxWaitBudgetMs(serverId, isCold, configuredCeilingMs, declaredWaitMs) {
-  if (configuredCeilingMs !== void 0 || !isCold) {
-    return Math.min(declaredWaitMs, configuredCeilingMs ?? DEFAULT_AUX_GRACE_CEILING_MS);
-  }
-  const observedSpawnMs = getSuccessfulLspSpawnDurationMs(serverId);
-  if (observedSpawnMs === void 0 || observedSpawnMs <= 0) {
-    return Math.min(declaredWaitMs, DEFAULT_AUX_GRACE_CEILING_MS);
-  }
-  return Math.min(MAX_ADAPTIVE_AUX_GRACE_CEILING_MS, Math.max(declaredWaitMs, observedSpawnMs + ADAPTIVE_AUX_GRACE_MARGIN_MS));
-}
 var DIAGNOSTICS_SEMANTIC_SETTLE_THRESHOLD_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_LSP_DIAGNOSTICS_SEMANTIC_THRESHOLD_MS ?? "250", 10) || 250);
 var DIAGNOSTICS_SEMANTIC_SETTLE_WAIT_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_LSP_DIAGNOSTICS_SEMANTIC_SETTLE_MS ?? "400", 10) || 400);
 var EARLY_UNBLOCK_GRACE_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_LSP_EARLY_UNBLOCK_GRACE_MS ?? "400", 10) || 400);
@@ -15476,14 +15933,21 @@ function groupFilesByPrimaryServer(files2) {
     const servers = getServersForFileWithConfig(filePath);
     const primary = servers[0]?.id ?? "none";
     const group = byServer.get(primary);
+    const fallbackFamilyHeads = /* @__PURE__ */ new Map();
+    const familyHeads = servers.map((server) => {
+      const head = server.fallbackFor ? fallbackFamilyHeads.get(server.fallbackFor) ?? server.fallbackFor : server.id;
+      fallbackFamilyHeads.set(server.id, head);
+      return head;
+    });
+    const multiServer = new Set(familyHeads).size > 1;
     if (group) {
       group.files.push(filePath);
-      if (servers.length > 1)
+      if (multiServer)
         group.multiServer = true;
     } else {
       byServer.set(primary, {
         files: [filePath],
-        multiServer: servers.length > 1
+        multiServer
       });
     }
   }
@@ -15527,7 +15991,7 @@ function notifyWriteBudgetMs() {
   return Number.isFinite(raw) && raw > 0 ? raw : 2e3;
 }
 function primaryServerWaitFloorMs(filePath, maxWaitMs) {
-  const serverWaitOverrideMs = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary").reduce((max, server) => Math.max(max, server.clientWaitTimeoutMs ?? 0), 0);
+  const serverWaitOverrideMs = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s)).reduce((max, server) => Math.max(max, server.clientWaitTimeoutMs ?? 0), 0);
   return Math.max(maxWaitMs ?? 0, serverWaitOverrideMs);
 }
 var NOTIFY_WEDGED_BUDGET_MULTIPLIER = 5;
@@ -15545,15 +16009,6 @@ function notifyStallCpuSampleMs() {
   return Number.isFinite(raw) && raw > 0 ? raw : 1200;
 }
 var NOTIFY_STALL_CPU_BUSY_FLOOR_PERCENT = 10;
-var AUX_NOTIFY_INFLIGHT_DEFAULT = 8;
-function auxNotifyInflightLimit(info) {
-  const perServer = info.notifyInflightLimit;
-  if (typeof perServer === "number" && Number.isFinite(perServer) && perServer > 0) {
-    return Math.floor(perServer);
-  }
-  const raw = Number(process.env.PI_LENS_LSP_AUX_NOTIFY_INFLIGHT);
-  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : AUX_NOTIFY_INFLIGHT_DEFAULT;
-}
 function workspacePullBudgetMs() {
   const raw = Number(process.env.PI_LENS_LSP_WORKSPACE_PULL_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : 3e4;
@@ -15608,8 +16063,11 @@ async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceD
   return files2;
 }
 var LSPService = class _LSPService {
+  static MAX_SIBLING_ANNOUNCEMENTS = 1024;
   sessionCwd;
   state;
+  /** Content hashes already announced to a sibling root in this service. */
+  siblingAnnouncementHashes = new BoundedFifoMap(_LSPService.MAX_SIBLING_ANNOUNCEMENTS);
   workspaceProbeLogged = /* @__PURE__ */ new Set();
   /** Per-service immutable root-boundary verdicts; root detectors cache hits too. */
   projectBoundaryCache = /* @__PURE__ */ new Map();
@@ -15945,6 +16403,38 @@ var LSPService = class _LSPService {
   checkDestroyed() {
     return this.isDestroyed;
   }
+  /**
+   * Keep live same-server clients in sibling package roots current. A
+   * didOpen/didChange only updates the client that owns the touched root, but
+   * TypeScript importers in another package can retain the old module graph.
+   * The notification uses each client's existing #271 watch queue.
+   */
+  announceToSiblings(filePath, content, contentHash2 = this.hashContent(content)) {
+    const normalizedPath = normalizeMapKey(filePath);
+    if (this.siblingAnnouncementHashes.get(normalizedPath) === contentHash2) {
+      return Promise.resolve();
+    }
+    return Promise.all(getServersForFileWithConfig(filePath).map((server) => this.resolveServerRoot(server, filePath).then((root) => {
+      if (!root)
+        return false;
+      const ownKey = `${server.id}:${normalizeMapKey(root)}`;
+      return this.notifyLiveClientsForServer(server.id, filePath, 2, ownKey, false);
+    }))).then(() => {
+      this.siblingAnnouncementHashes.set(normalizedPath, contentHash2);
+    });
+  }
+  notifyLiveClientsForServer(serverId, filePath, type, ownKey, includeOwn) {
+    let notified = false;
+    const prefix = `${serverId}:`;
+    for (const [key, client] of this.state.clients) {
+      if (!key.startsWith(prefix) || !includeOwn && key === ownKey || !client.isAlive()) {
+        continue;
+      }
+      client.notify.watchedFileChange(filePath, type);
+      notified = true;
+    }
+    return notified;
+  }
   async withClientSpawnGate(operation) {
     const previous = this.clientSpawnGate;
     let release;
@@ -16484,7 +16974,7 @@ var LSPService = class _LSPService {
       return false;
     if (record2.gateOpen)
       return false;
-    return record2.unacked >= auxNotifyInflightLimit(entry.info);
+    return record2.unacked >= serverTraits(entry.info).notifyInflightLimit;
   }
   /**
    * #1714: hold the next notify until this auxiliary has proven it PROCESSED the
@@ -16495,10 +16985,12 @@ var LSPService = class _LSPService {
    * sends ONE request round-trip (`pingLiveness`, #1277,
    * clients/lsp/client.ts:2577).
    *
-   * WHY A REPLY PROVES PROCESSING, measured rather than assumed. ast-grep-lsp is
-   * tower-lsp-server and drains its message stream in order on one task, so a
-   * request written after N `didOpen`s is answered after those N are scanned.
-   * Live probe against the real binary, 30 real repository files:
+   * WHY A REPLY PROVES PROCESSING, measured rather than assumed, and declared
+   * as the `replyOrdering: "single-task-ordered"` trait on the row that was
+   * measured (#1722, #1756 stage 1). ast-grep-lsp is tower-lsp-server and
+   * drains its message stream in order on one task, so a request written after
+   * N `didOpen`s is answered after those N are scanned. Live probe against the
+   * real binary, 30 real repository files:
    *
    *   idle `workspace/symbol` reply        0 ms
    *   after 30 didOpens                 2263 ms, 29 of 30 publishes already in
@@ -16512,13 +17004,19 @@ var LSPService = class _LSPService {
    * immaterial against a ceiling of 4 to 8.
    *
    * A server that answered requests off a SEPARATE task would not give this
-   * proof. What keeps that server safe is NOT the fail-open latch below: the
-   * latch never arms for it. Such a server answers the barrier instantly,
-   * `unacked` resets, and the gate stays inert for the whole sweep. Safety comes
-   * from the outcome that inertness produces — the notify sequence is exactly
-   * the pre-#1714 one, and #743's write deadline, backpressure streak and wedge
-   * timer own the stall the same way they did before this change. The throttle
-   * buys such a server nothing; it also costs it nothing.
+   * proof, and one that declares `replyOrdering: "threaded"` is therefore
+   * stepped over below rather than round-tripped. What kept such a server safe
+   * BEFORE the trait existed is NOT the fail-open latch: the latch never arms
+   * for it. It answered the barrier instantly, `unacked` reset, and the gate
+   * stayed inert for the whole sweep. Safety comes from the outcome that
+   * inertness produces — the notify sequence is exactly the pre-#1714 one, and
+   * #743's write deadline, backpressure streak and wedge timer own the stall
+   * the same way they did before this change. The throttle buys such a server
+   * nothing; it also costs it nothing. Declaring the trait reaches that same
+   * end state without spending the round-trip, and `unmeasured` — the default,
+   * and every server that has not been probed — keeps the barrier armed
+   * exactly as before, so an unmeasured server is never granted a pacing
+   * change by omission.
    *
    * The wait is bounded by the CALLER's remaining budget, never by a schedule of
    * its own: every waiter gives the shared round-trip only `waitMs`, so a caller
@@ -16547,10 +17045,11 @@ var LSPService = class _LSPService {
     }
     if (record2.gateOpen)
       return;
-    const limit = auxNotifyInflightLimit(entry.info);
+    const traits = serverTraits(entry.info);
+    const limit = traits.notifyInflightLimit;
     if (record2.unacked < limit)
       return;
-    const ping = entry.client.pingLiveness;
+    const ping = traits.replyOrdering === "threaded" ? void 0 : entry.client.pingLiveness;
     if (!ping) {
       record2.unacked = 0;
       return;
@@ -16806,7 +17305,7 @@ var LSPService = class _LSPService {
     const attached = new Set(spawned.map((entry) => entry.info.id));
     const skipped = [];
     for (const server of getServersForFileWithConfig(filePath)) {
-      if (server.role !== "auxiliary")
+      if (!isAuxiliary(server))
         continue;
       if (attached.has(server.id))
         continue;
@@ -16884,7 +17383,7 @@ var LSPService = class _LSPService {
   async getClientForFile(filePath, maxWaitMs, hardCapMs, resolvedRoots, waitSkipReasons) {
     if (this.checkDestroyed())
       return void 0;
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
+    const servers = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s));
     const rootMemo = /* @__PURE__ */ new Map();
     const partitionCandidates = async () => {
       const resolved2 = await Promise.all(servers.map(async (server) => {
@@ -17107,7 +17606,7 @@ var LSPService = class _LSPService {
       root: await this.resolveServerRoot(server, filePath)
     })))).filter((entry) => entry.root !== void 0);
     for (const { server, root } of rootedServers)
-      if (server.role === "auxiliary")
+      if (isAuxiliary(server))
         auxiliaryRoots?.set(server.id, normalizeMapKey(root));
     let serverCountAttempted = 0;
     const acquisitions = /* @__PURE__ */ new Map();
@@ -17132,7 +17631,7 @@ var LSPService = class _LSPService {
   async getAuxiliaryClientsForFile(filePath, enabledIds, onOutcome, maxWaitMs, signal, hook) {
     if (this.checkDestroyed() || enabledIds.size === 0)
       return [];
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role === "auxiliary" && enabledIds.has(s.id));
+    const servers = getServersForFileWithConfig(filePath).filter((s) => isAuxiliary(s) && enabledIds.has(s.id));
     if (servers.length === 0)
       return [];
     const rootMemo = /* @__PURE__ */ new Map();
@@ -17285,11 +17784,7 @@ var LSPService = class _LSPService {
       const root = await this.resolveServerRoot(server, filePath);
       if (!root)
         continue;
-      const key = `${server.id}:${normalizeMapKey(root)}`;
-      const existing = this.state.clients.get(key);
-      if (existing?.isAlive()) {
-        existing.notify.watchedFileChange(filePath, type);
-      }
+      this.notifyLiveClientsForServer(server.id, filePath, type, `${server.id}:${normalizeMapKey(root)}`, true);
     }
   }
   /**
@@ -17524,7 +18019,7 @@ var LSPService = class _LSPService {
     const root = await this.resolveServerRootOnce(server, filePath, rootMemo);
     if (!root || this.checkDestroyed())
       return void 0;
-    if (server.role !== "auxiliary") {
+    if (!isAuxiliary(server)) {
       resolvedRoots?.set(server.id, normalizeMapKey(root));
     }
     const allowInstall = this.shouldAllowInstall(server.id);
@@ -17875,6 +18370,16 @@ var LSPService = class _LSPService {
       });
       return;
     }
+    const contentHash2 = this.hashContent(content);
+    if (typeof content === "string") {
+      void this.announceToSiblings(filePath, content, contentHash2).catch((cause) => {
+        incrementDegradationCount({
+          kind: "lsp-sibling-announcement",
+          subject: normalizeMapKey(filePath),
+          reason: `sibling notification failed: ${String(cause)}`
+        });
+      });
+    }
     const startedAt = Date.now();
     let fingerprintMemo;
     const contentFingerprint = () => fingerprintMemo ??= fingerprintDocumentContent(content);
@@ -17960,7 +18465,7 @@ var LSPService = class _LSPService {
     const leaseKeys = await this.acquireClientLeases(spawned, filePath);
     if (!leaseKeys) {
       if (this.checkDestroyed()) {
-        const primaryServerIds = spawned.filter((entry) => entry.info.role !== "auxiliary").map((entry) => entry.info.id);
+        const primaryServerIds = spawned.filter((entry) => !isAuxiliary(entry.info)).map((entry) => entry.info.id);
         return {
           diags: [],
           inconclusive: true,
@@ -17998,10 +18503,10 @@ var LSPService = class _LSPService {
       const readPathVersion = (client) => client.getDiagnosticsVersionForPath?.(filePath);
       const diagnosticBaselines = new Map(spawned.map((entry) => [entry.client, readPathVersion(entry.client)]));
       const markedAtMs = Date.now();
-      const touchContentHash = this.hashContent(content);
+      const touchContentHash = contentHash2;
       const bindingMatchesTouchContent = (binding2) => binding2?.contentHash === touchContentHash;
       const carriedAuxiliary = options.collectDiagnostics ? spawned.flatMap((entry) => {
-        if (entry.info.role !== "auxiliary")
+        if (!isAuxiliary(entry.info))
           return [];
         const binding2 = entry.client.getDiagnosticBinding?.(filePath);
         if (!bindingMatchesTouchContent(binding2))
@@ -18009,11 +18514,11 @@ var LSPService = class _LSPService {
         const diags = entry.client.getDiagnostics(filePath);
         return diags.length > 0 ? [{ serverId: entry.info.id, diags, binding: binding2 }] : [];
       }) : [];
-      const auxPublishedThisContent = new Set(spawned.flatMap((entry) => entry.info.role === "auxiliary" && bindingMatchesTouchContent(entry.client.getDiagnosticBinding?.(filePath)) ? [entry.info.id] : []));
+      const auxPublishedThisContent = new Set(spawned.flatMap((entry) => isAuxiliary(entry.info) && bindingMatchesTouchContent(entry.client.getDiagnosticBinding?.(filePath)) ? [entry.info.id] : []));
       const spawnedByServerId = new Map(spawned.map((entry) => [entry.info.id, entry]));
       const auxCoversThisContent = (serverId) => {
         const entry = spawnedByServerId.get(serverId);
-        if (entry?.info.role !== "auxiliary")
+        if (!entry || !isAuxiliary(entry.info))
           return false;
         return auxPublishedThisContent.has(serverId) || bindingMatchesTouchContent(entry.client.getDiagnosticBinding?.(filePath));
       };
@@ -18027,7 +18532,7 @@ var LSPService = class _LSPService {
           if (notifySkippedServerIds.has(entry.info.id))
             return;
           const clientKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
-          const gated = entry.info.role === "auxiliary" && clientKey !== void 0;
+          const gated = isAuxiliary(entry.info) && clientKey !== void 0;
           let slot;
           if (gated && clientKey) {
             const barrierStartedAt = Date.now();
@@ -18115,7 +18620,7 @@ var LSPService = class _LSPService {
         }
       }
       const notifyWriteTimedOut = notifyWriteTimedOutServerIds.length > 0;
-      const primaryEntries = spawned.filter((entry) => entry.info.role !== "auxiliary");
+      const primaryEntries = spawned.filter((entry) => !isAuxiliary(entry.info));
       const primaryServerIds = new Set(primaryEntries.map((e) => e.info.id));
       const primaryNotifyWriteTimedOutServerIds = notifyWriteTimedOutServerIds.filter((id) => primaryServerIds.has(id));
       const primaryNotifyWriteTimedOut = primaryNotifyWriteTimedOutServerIds.length > 0;
@@ -18212,7 +18717,7 @@ var LSPService = class _LSPService {
           }
         }
         const waitStartedAt = Date.now();
-        const hasTouchAuxiliaries = clientScope === "with-auxiliary" && options.collectDiagnostics === true && spawned.some((e) => e.info.role === "auxiliary");
+        const hasTouchAuxiliaries = clientScope === "with-auxiliary" && options.collectDiagnostics === true && spawned.some((e) => isAuxiliary(e.info));
         if (spawned.some((entry) => entry.info.custom === true)) {
           try {
             const snapshotHook = options.hook ?? "tool_result_edit";
@@ -18242,7 +18747,7 @@ var LSPService = class _LSPService {
         const perServerWaitTimeouts = spawned.map((entry, entryIndex) => {
           const declaredServerTimeout = perServerDeclaredTimeouts[entryIndex];
           const observedSpawnMs = getSuccessfulLspSpawnDurationMs(entry.client.serverId);
-          return hasTouchAuxiliaries && entry.info.role === "auxiliary" && coldAuxiliaryServerIds.has(entry.client.serverId) && (configuredAuxCeilingMs !== void 0 || observedSpawnMs !== void 0 && observedSpawnMs > 0) ? auxWaitBudgetMs(entry.client.serverId, true, configuredAuxCeilingMs, declaredServerTimeout) : perServerDeclaredTimeouts[entryIndex];
+          return hasTouchAuxiliaries && isAuxiliary(entry.info) && coldAuxiliaryServerIds.has(entry.client.serverId) && (configuredAuxCeilingMs !== void 0 || observedSpawnMs !== void 0 && observedSpawnMs > 0) ? auxWaitBudgetMs(entry.client.serverId, true, configuredAuxCeilingMs, declaredServerTimeout) : perServerDeclaredTimeouts[entryIndex];
         });
         const firstContactCutOffServerIds = /* @__PURE__ */ new Set();
         const firstContactErroredServerIds = /* @__PURE__ */ new Set();
@@ -18263,10 +18768,10 @@ var LSPService = class _LSPService {
           }
         };
         const perServerRaceBudgets = spawned.map((entry, entryIndex) => {
-          return hasTouchAuxiliaries && entry.info.role === "auxiliary" ? auxWaitBudgetMs(entry.client.serverId, coldAuxiliaryServerIds.has(entry.client.serverId), configuredAuxCeilingMs, perServerDeclaredTimeouts[entryIndex]) : perServerDeclaredTimeouts[entryIndex];
+          return hasTouchAuxiliaries && isAuxiliary(entry.info) ? auxWaitBudgetMs(entry.client.serverId, coldAuxiliaryServerIds.has(entry.client.serverId), configuredAuxCeilingMs, perServerDeclaredTimeouts[entryIndex]) : perServerDeclaredTimeouts[entryIndex];
         });
         const perServerWaits = spawned.map((entry, entryIndex) => {
-          if (hasTouchAuxiliaries && entry.info.role === "auxiliary" && this.isAuxiliaryWaitDemoted(entry.info.id, entry.client.root ?? filePath)) {
+          if (hasTouchAuxiliaries && isAuxiliary(entry.info) && this.isAuxiliaryWaitDemoted(entry.info.id, entry.client.root ?? filePath)) {
             return Promise.resolve(void 0);
           }
           if (this.state.diagnosticsUnsupported.has(entry.info.id) || diagnosticsUnsupportedServerIds.includes(entry.info.id)) {
@@ -18349,8 +18854,8 @@ var LSPService = class _LSPService {
         });
         let pushWaitSettled = false;
         const pushWait = hasTouchAuxiliaries ? (() => {
-          const primaryWaits = perServerWaits.filter((_, i) => spawned[i].info.role !== "auxiliary");
-          const auxWaits = perServerWaits.map((p, i) => spawned[i].info.role === "auxiliary" ? {
+          const primaryWaits = perServerWaits.filter((_, i) => !isAuxiliary(spawned[i].info));
+          const auxWaits = perServerWaits.map((p, i) => isAuxiliary(spawned[i].info) ? {
             promise: p,
             serverId: spawned[i].info.id,
             client: spawned[i].client,
@@ -18532,7 +19037,7 @@ var LSPService = class _LSPService {
           ...new Set(diagnosticsUnsupportedServerIds)
         ];
         if (!hasTouchAuxiliaries && options.collectDiagnostics === true) {
-          const auxEntries = spawned.filter((entry) => entry.info.role === "auxiliary");
+          const auxEntries = spawned.filter((entry) => isAuxiliary(entry.info));
           if (auxEntries.length > 0) {
             const outcomes = auxEntries.map((entry) => {
               const baseline = diagnosticBaselines.get(entry.client);
@@ -18587,9 +19092,9 @@ var LSPService = class _LSPService {
           const waited = spawned.filter((entry) => !deferredResyncServerIds.has(entry.info.id) && !diagnosticsUnsupportedServerIds.includes(entry.info.id));
           const unanswered = waited.filter((entry) => !answeredForThisTouch(entry));
           diagnosticsUnansweredServerIds = unanswered.map((e) => e.info.id);
-          diagnosticsUnansweredPrimaryServerIds = unanswered.filter((entry) => entry.info.role !== "auxiliary").map((e) => e.info.id);
-          const hasWaitedPrimary = waited.some((entry) => entry.info.role !== "auxiliary");
-          const hasUnsupportedPrimary = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+          diagnosticsUnansweredPrimaryServerIds = unanswered.filter((entry) => !isAuxiliary(entry.info)).map((e) => e.info.id);
+          const hasWaitedPrimary = waited.some((entry) => !isAuxiliary(entry.info));
+          const hasUnsupportedPrimary = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && !isAuxiliary(entry.info)));
           diagnosticsTimedOut = !hasWaitedPrimary && !hasUnsupportedPrimary || diagnosticsUnansweredPrimaryServerIds.length > 0;
           for (const entry of unanswered) {
             incrementDegradationCount({
@@ -18662,7 +19167,7 @@ var LSPService = class _LSPService {
       }
       const auxCoveredAtMerge = new Set(spawned.filter((entry) => auxCoversThisContent(entry.info.id)).map((entry) => entry.info.id));
       const uncoveredDeferredServerIds = notifyDeferredServerIds.filter((serverId) => !auxCoveredAtMerge.has(serverId));
-      const staleWriteAuxiliaryServerIds = spawned.filter((entry) => entry.info.role === "auxiliary" && notifyWriteTimedOutServerIds.includes(entry.info.id) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
+      const staleWriteAuxiliaryServerIds = spawned.filter((entry) => isAuxiliary(entry.info) && notifyWriteTimedOutServerIds.includes(entry.info.id) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
       const droppedAuxiliaryServerIds = /* @__PURE__ */ new Set([
         ...uncoveredDeferredServerIds,
         ...staleWriteAuxiliaryServerIds
@@ -18753,7 +19258,7 @@ var LSPService = class _LSPService {
       });
       const inconclusive = verdict.inconclusive;
       const brokenSkippedServerIds = collected !== void 0 ? await this.brokenSkippedAuxiliaryServerIds(filePath, clientScope, options, spawned) : [];
-      const auxNoAnswerServerIds = spawned.filter((entry) => entry.info.role === "auxiliary" && (diagnosticsUnansweredServerIds.includes(entry.info.id) || notifyWriteTimedOutServerIds.includes(entry.info.id)) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
+      const auxNoAnswerServerIds = spawned.filter((entry) => isAuxiliary(entry.info) && (diagnosticsUnansweredServerIds.includes(entry.info.id) || notifyWriteTimedOutServerIds.includes(entry.info.id)) && !auxCoveredAtMerge.has(entry.info.id)).map((entry) => entry.info.id);
       const unconfirmedServerIds = [
         .../* @__PURE__ */ new Set([
           ...auxUnconfirmedServerIds ?? [],
@@ -18823,7 +19328,7 @@ var LSPService = class _LSPService {
         }
       }
       const result = { diags: collected ?? [] };
-      const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && entry.info.role !== "auxiliary"));
+      const primaryDiagnosticsUnsupported = diagnosticsUnsupportedServerIds.some((serverId) => spawned.some((entry) => entry.info.id === serverId && !isAuxiliary(entry.info)));
       if (diagnosticsUnsupportedServerIds.length > 0) {
         result.diagnosticsUnsupportedServerIds = diagnosticsUnsupportedServerIds;
       }
@@ -19122,10 +19627,10 @@ var LSPService = class _LSPService {
     });
     const graceMs = diagnosticsMode === "document" ? 0 : EARLY_UNBLOCK_GRACE_MS;
     const diagDescriptors = spawned.map((entry) => {
-      if (entry.info.role !== "auxiliary")
-        return { role: "primary" };
+      if (!isAuxiliary(entry.info))
+        return { role: entry.info.role };
       const strategy = getStrategy(entry.info.id, entry.client.getLaunchVariant?.());
-      return { role: "auxiliary", budgetMs: strategy.aggregateWaitMs };
+      return { role: entry.info.role, budgetMs: strategy.aggregateWaitMs };
     });
     const perServer = await raceToCompletion(clientWaits, (results) => results.some((r) => r.diagnosticCount > 0 || getStrategy(r.serverId, r.launchVariant).seedFirstPush), {
       timeoutMs: Math.max(...spawned.map((entry) => getStrategy(entry.info.id, entry.client.getLaunchVariant?.()).aggregateWaitMs)),
@@ -19133,8 +19638,9 @@ var LSPService = class _LSPService {
       descriptors: diagDescriptors,
       // #1458 S2: ceiling, not a flat wait — each auxiliary's own
       // budgetMs (above) determines the actual per-touch grace up to
-      // this cap. Matches touchFile's `readEnvAuxGraceMs() ?? 2000`.
-      auxGraceMs: readEnvAuxGraceMs() ?? 2e3
+      // this cap. Matches touchFile's ceiling, and names the shared
+      // constant instead of repeating its value (#1488).
+      auxGraceMs: readEnvAuxGraceMs() ?? DEFAULT_AUX_GRACE_CEILING_MS
     });
     const earlyUnblockedCount = spawned.length - perServer.length;
     const perServerFull = spawned.map((entry) => {
@@ -19341,21 +19847,22 @@ var LSPService = class _LSPService {
    * a polyglot workspace used to win every no-filePath query outright (#1812
    * — a supporting primary server spawned later never got a look-in). Scans
    * for the first LIVE client matching `predicate` (when given), preferring
-   * any primary (non-`"auxiliary"` role) match over an auxiliary one — the
-   * same primary-over-auxiliary preference `getClientForFile` encodes via
-   * its `role !== "auxiliary"` filter (this file, `getClientForFile`) and
+   * any primary (non-auxiliary) match over an auxiliary one — the same
+   * primary-over-auxiliary preference `getClientForFile` encodes via its
+   * `!isAuxiliary` filter (this file, `getClientForFile`) and
    * `getAliveServerIds` groups by. `isAlive()` is required for BOTH the
    * preferred and fallback candidate — mirrors `getCapabilitySnapshots`'s
    * own no-filePath branch (this file, ~line 5868), whose liveness filter
    * this helper otherwise duplicates; without it a dead primary would win
    * over a live, answering auxiliary. Role is read from the map key's
-   * `serverId` prefix against `LSP_SERVERS`, the same single source of
-   * truth `getCapabilitySnapshots` already parses that key from — never a
-   * second, hand-rolled role table. A `serverId` prefix absent from
-   * `LSP_SERVERS` (should not happen in practice — every spawned client's
-   * key is built from a known server's `id`) resolves to `role === undefined`,
-   * which falls through to the primary branch: unknown treated as primary,
-   * never silently dropped. Returns undefined only when NO live client
+   * `serverId` prefix through `getServerById` against `LSP_SERVERS`, the
+   * same single source of truth `getCapabilitySnapshots` already parses that
+   * key from — never a second, hand-rolled role table. A `serverId` prefix
+   * absent from `LSP_SERVERS` (should not happen in practice — every spawned
+   * client's key is built from a known server's `id`) resolves to no server,
+   * which `isAuxiliary` reads as `DEFAULT_LSP_SERVER_ROLE` and so falls
+   * through to the primary branch: unknown treated as primary, never
+   * silently dropped. Returns undefined only when NO live client
    * (primary or auxiliary) matches.
    */
   selectWorkspaceScopeClient(predicate) {
@@ -19367,8 +19874,7 @@ var LSPService = class _LSPService {
         continue;
       const separator = key.indexOf(":");
       const serverId = separator >= 0 ? key.slice(0, separator) : key;
-      const role = LSP_SERVERS.find((s) => s.id === serverId)?.role;
-      if (role === "auxiliary") {
+      if (isAuxiliary(getServerById(serverId))) {
         if (!auxFallback)
           auxFallback = { client, serverId };
         continue;
@@ -19995,7 +20501,7 @@ var LSPService = class _LSPService {
     if (this.checkDestroyed() || options.signal?.aborted) {
       return { performedWarmup: false, failedServerIds: [] };
     }
-    const servers = getServersForFileWithConfig(representativeFile).filter((s) => s.role !== "auxiliary");
+    const servers = getServersForFileWithConfig(representativeFile).filter((s) => !isAuxiliary(s));
     if (servers.length === 0) {
       return { performedWarmup: false, failedServerIds: [] };
     }
@@ -20324,7 +20830,7 @@ var LSPService = class _LSPService {
           const { clients } = await this.getClientsForFile(filePath, WORKSPACE_SWEEP_EXCLUDED_SERVER_IDS);
           for (const entry of clients) {
             let auxKey;
-            if (entry.info.role === "auxiliary") {
+            if (isAuxiliary(entry.info)) {
               auxKey = await this.demonstratedReadyKeyFor(entry.info, filePath);
               if (auxKey && this.auxNotifyBacklogAtCeiling(auxKey, entry)) {
                 continue;
@@ -20760,7 +21266,7 @@ var LSPService = class _LSPService {
    * but slow/wedged" (#1766) — a cold spawn still in flight is not a verdict
    * on a server that doesn't exist yet.
    *
-   * Mirrors the `role !== "auxiliary"` filter getClientForFile applies at
+   * Mirrors the `!isAuxiliary` filter getClientForFile applies at
    * :2146-2148 (kept coupled to that line intentionally): auxiliary servers
    * (opengrep, typos, …) spawn routinely and concurrently with an ALREADY
    * ALIVE primary (dispatch/runners/lsp.ts's with-auxiliary path fires one
@@ -20803,7 +21309,7 @@ var LSPService = class _LSPService {
   describeTouchCandidates(filePath, resolvedRoots, auxiliaryRoots = /* @__PURE__ */ new Map()) {
     const candidates = [];
     for (const server of getServersForFileWithConfig(filePath)) {
-      const auxiliary = server.role === "auxiliary";
+      const auxiliary = isAuxiliary(server);
       if (auxiliary && !auxiliaryRoots.has(server.id))
         continue;
       if (candidates.length >= MAX_TOUCH_CANDIDATES)
@@ -21011,8 +21517,7 @@ var LSPService = class _LSPService {
       if (seen.has(id))
         continue;
       seen.add(id);
-      const role = LSP_SERVERS.find((s) => s.id === id)?.role;
-      (role === "auxiliary" ? aux : primary).push(id);
+      (isAuxiliary(getServerById(id)) ? aux : primary).push(id);
     }
     return [...primary, ...aux];
   }
@@ -21201,7 +21706,6 @@ export {
   getLspIdleEvictMs,
   getLspIdleEvictMsForRoot,
   getLspClientCeiling,
-  auxWaitBudgetMs,
   groupFilesByPrimaryServer,
   createSweepIndexGate,
   runPerServerGroups,