@remnic/core 9.6.37 → 9.6.39

package/dist/{chunk-MXAGJHTA.js → chunk-NREKOGZ2.js}

@@ -18,7 +18,7 @@ import {
 } from "./chunk-T4WDJPEZ.js";
 import {
   getOperation
-} from "./chunk-GQURC4B7.js";
+} from "./chunk-VTRF5QBX.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -27,7 +27,7 @@ import {
 } from "./chunk-D7FOKIY5.js";
 import {
   EngramAccessInputError
-} from "./chunk-OXVKR5OU.js";
+} from "./chunk-RU73ZROD.js";
 import {
   readEnvVar
 } from "./chunk-JUC24CTX.js";
@@ -3771,4 +3771,4 @@ export {
   MCP_SUPPORTED_PROTOCOL_VERSIONS,
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-MXAGJHTA.js.map
+//# sourceMappingURL=chunk-NREKOGZ2.js.map

package/dist/{chunk-H4FHR4UM.js → chunk-PQG2AOL4.js}

@@ -37,7 +37,7 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-3AC5UYKI.js";
+} from "./chunk-METJNEIB.js";
 import {
   markProjectedMemoryPathInvalid,
   readProjectedGovernanceRecord,
@@ -7207,4 +7207,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-H4FHR4UM.js.map
+//# sourceMappingURL=chunk-PQG2AOL4.js.map

package/dist/{chunk-WSOEYOHN.js → chunk-PWSZNML3.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-BRDJ2HFP.js";
 import {
   MaintenanceScheduler
-} from "./chunk-JODHPNLN.js";
+} from "./chunk-5ELELET5.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -26,7 +26,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-B5GBWBCZ.js";
+} from "./chunk-GCTJG5MP.js";
 import {
   SharedContextManager
 } from "./chunk-UI4FVU6T.js";
@@ -202,7 +202,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-FVTLSFWU.js";
+} from "./chunk-WHZ7MK72.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -212,14 +212,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-2K3OSLHE.js";
+} from "./chunk-7TEWOG3R.js";
 import {
   ThreadingManager
 } from "./chunk-DBRYEIGY.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-DEKIXXIG.js";
+} from "./chunk-ZIKJD6NL.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -232,14 +232,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-B4LPRAWL.js";
+} from "./chunk-2V6L3L56.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-VHJARF5R.js";
+} from "./chunk-XH2Y6UIW.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-23G3T2Q5.js";
+} from "./chunk-7XY6TJLM.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -274,7 +274,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-AXALUFAH.js";
+} from "./chunk-3BZDBG7U.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -323,7 +323,7 @@ import {
   createCorrectionService,
   detectPassiveCorrections,
   qmdCollectionPathParts
-} from "./chunk-OXVKR5OU.js";
+} from "./chunk-RU73ZROD.js";
 import {
   importCapsule
 } from "./chunk-M5QKGHCR.js";
@@ -339,7 +339,7 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-W2AHSCKY.js";
+} from "./chunk-AZK3NEHL.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -394,7 +394,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-7ZYBDQ7V.js";
+} from "./chunk-CVEEJKRD.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -409,7 +409,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-H4FHR4UM.js";
+} from "./chunk-PQG2AOL4.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -446,7 +446,7 @@ import {
 } from "./chunk-SVOZFLIQ.js";
 import {
   confidenceTier
-} from "./chunk-3AC5UYKI.js";
+} from "./chunk-METJNEIB.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -23092,4 +23092,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-WSOEYOHN.js.map
+//# sourceMappingURL=chunk-PWSZNML3.js.map

package/dist/{chunk-OXVKR5OU.js → chunk-RU73ZROD.js}

@@ -31,10 +31,10 @@ import {
 } from "./chunk-BT7NVCML.js";
 import {
   toRecallExplainJson
-} from "./chunk-DQ42IQSK.js";
+} from "./chunk-5SORASJK.js";
 import {
   estimateRecallTokens
-} from "./chunk-W2AHSCKY.js";
+} from "./chunk-AZK3NEHL.js";
 import {
   decideDisclosureEscalation
 } from "./chunk-H7XKCNR6.js";
@@ -70,7 +70,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-O6YI4CVI.js";
+} from "./chunk-ZSDRGPMV.js";
 import {
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
@@ -111,11 +111,11 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-7ZYBDQ7V.js";
+} from "./chunk-CVEEJKRD.js";
 import {
   parseEntityFile,
   selfDeps
-} from "./chunk-H4FHR4UM.js";
+} from "./chunk-PQG2AOL4.js";
 import {
   supersessionKeysForFact
 } from "./chunk-EHK6KZHK.js";
@@ -128,7 +128,7 @@ import {
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-3AC5UYKI.js";
+} from "./chunk-METJNEIB.js";
 import {
   getMemoryProjectionPath
 } from "./chunk-RHOZ5LLO.js";
@@ -1204,12 +1204,12 @@ async function findArchitectureCardMemory(storage) {
   });
   return cards[0] ?? null;
 }
-function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDir, memoryDir, readFile6, writeVersion) {
+function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDir, memoryDir, readFile7, writeVersion) {
   return {
     async snapshotIfExists(memory) {
       if (!enabled) return;
       try {
-        const fullContent = await readFile6(memory.path);
+        const fullContent = await readFile7(memory.path);
         await writeVersion(
           memory.path,
           fullContent,
@@ -1227,6 +1227,9 @@ function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDi
 
 // src/coding/codegraph-runtime.ts
 import path2 from "path";
+import { readFile as readFile2, realpath } from "fs/promises";
+import { readFileSync, realpathSync } from "fs";
+import { pathToFileURL } from "url";
 import { createHash } from "crypto";
 var CODEGRAPH_SPECIFIER = "@remnic/coding-graph";
 function codegraphSurfaceVisible(config) {
@@ -1394,7 +1397,8 @@ function makeCodegraphRuntimeDelegates() {
     runReindex: (store, repoRoot, mode) => runCodegraphReindex({ store, repoRoot, mode }),
     reportIndexStatus: (store, repoRoot) => reportCodegraphIndexStatus({ store, repoRoot }),
     detectChanges: (store, repoRoot, head) => detectCodegraphChanges({ store, repoRoot, head }),
-    ingestTraces: (store, traces) => ingestCodegraphTraces({ store, traces })
+    ingestTraces: (store, traces) => ingestCodegraphTraces({ store, traces }),
+    runLspResolution: (store, repoRoot, lspConfig) => runCodegraphLspResolution({ store, repoRoot, lspConfig })
   };
 }
 async function runCodegraphReindex(params) {
@@ -1445,6 +1449,316 @@ async function runCodegraphReindex(params) {
     return { ok: false, code: "store_error", message: msg };
   }
 }
+async function lspPathEscapesRoot(repoRoot, absPath) {
+  try {
+    const [realRoot, realAbs] = await Promise.all([realpath(repoRoot), realpath(absPath)]);
+    const rel = path2.relative(realRoot, realAbs);
+    return rel === ".." || rel.startsWith(".." + path2.sep) || path2.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+function lspPathEscapesRootSync(repoRoot, absPath) {
+  try {
+    const realRoot = realpathSync(repoRoot);
+    const realAbs = realpathSync(absPath);
+    const rel = path2.relative(realRoot, realAbs);
+    return rel === ".." || rel.startsWith(".." + path2.sep) || path2.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_LSP_SERVERS = {
+  typescript: { command: "typescript-language-server", args: ["--stdio"] },
+  tsx: { command: "typescript-language-server", args: ["--stdio"] },
+  javascript: { command: "typescript-language-server", args: ["--stdio"] },
+  python: { command: "pyright-langserver", args: ["--stdio"] },
+  go: { command: "gopls", args: [] },
+  rust: { command: "rust-analyzer", args: [] }
+};
+async function runCodegraphLspResolution(params) {
+  const mod = await loadCodegraphModule();
+  if (mod === null) {
+    return { ok: false, code: "package_missing", message: "@remnic/coding-graph is not installed." };
+  }
+  if (typeof mod.executeLspResolution !== "function" || typeof mod.planLspUpgrades !== "function" || typeof mod.LspClient?.connect !== "function") {
+    return { ok: false, code: "runtime_unavailable", message: "LSP resolution is not available in the installed @remnic/coding-graph." };
+  }
+  const engine = mod.createCodingGraphEngine?.() ?? null;
+  if (engine === null) {
+    return { ok: false, code: "engine_unavailable", message: "createCodingGraphEngine is not available." };
+  }
+  const repoRoot = path2.resolve(params.repoRoot);
+  const gitFactory = mod.defaultCodingGitInvoker;
+  if (typeof gitFactory !== "function") {
+    return { ok: true, upgraded: 0, unresolved: 0, budgetExhausted: 0 };
+  }
+  const tracked = gitFactory().listTrackedFiles(repoRoot);
+  if (!("paths" in tracked)) {
+    return { ok: true, upgraded: 0, unresolved: 0, budgetExhausted: 0 };
+  }
+  const resolvedCalleesBySrc = /* @__PURE__ */ new Map();
+  const alreadyResolved = (filePath, srcQualifiedName, calleeName) => {
+    const key = `${filePath}\0${srcQualifiedName}`;
+    let names = resolvedCalleesBySrc.get(key);
+    if (names === void 0) {
+      names = /* @__PURE__ */ new Set();
+      if (typeof params.store.resolvedCalleeNames === "function") {
+        for (const name of params.store.resolvedCalleeNames(srcQualifiedName, "heuristic", filePath)) {
+          names.add(name);
+        }
+      }
+      resolvedCalleesBySrc.set(key, names);
+    }
+    return names.has(calleeName);
+  };
+  const sites = [];
+  const gatheredCountByFile = /* @__PURE__ */ new Map();
+  const filteredCountByFile = /* @__PURE__ */ new Map();
+  const filteredSrcByFile = /* @__PURE__ */ new Map();
+  const parsedFiles = /* @__PURE__ */ new Set();
+  for (const rel of tracked.paths) {
+    const absPath = path2.join(repoRoot, rel);
+    if (await lspPathEscapesRoot(repoRoot, absPath)) continue;
+    let content;
+    try {
+      content = await readFile2(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = await engine.parseFile({ path: rel, content });
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || !("ok" in parsed) || parsed.ok !== true || !("ir" in parsed)) continue;
+    const ir = parsed.ir;
+    if (!ir || typeof ir !== "object" || !("callSites" in ir) || !Array.isArray(ir.callSites)) continue;
+    parsedFiles.add(rel);
+    const language = "language" in ir && typeof ir.language === "string" ? ir.language : "";
+    const symbols = "symbols" in ir && Array.isArray(ir.symbols) ? ir.symbols : [];
+    const contentBytes = Buffer.from(content, "utf-8");
+    for (const site of ir.callSites) {
+      if (!site || typeof site !== "object" || !("span" in site)) continue;
+      const span = site.span;
+      if (!span || typeof span !== "object" || !("startByte" in span) || typeof span.startByte !== "number") continue;
+      const calleeName = "calleeNameCandidates" in site && Array.isArray(site.calleeNameCandidates) && typeof site.calleeNameCandidates[0] === "string" ? site.calleeNameCandidates[0] : "";
+      if (calleeName.length === 0) continue;
+      let srcQualifiedName = "";
+      let bestSpanSize = Number.POSITIVE_INFINITY;
+      for (const sym of symbols) {
+        if (!sym || typeof sym !== "object" || !("span" in sym) || !("qualifiedName" in sym)) continue;
+        const ss = sym.span;
+        if (!ss || typeof ss !== "object" || !("startByte" in ss) || !("endByte" in ss)) continue;
+        if (typeof ss.startByte !== "number" || typeof ss.endByte !== "number") continue;
+        if (ss.startByte <= span.startByte && span.startByte < ss.endByte) {
+          const size = ss.endByte - ss.startByte;
+          if (size < bestSpanSize) {
+            bestSpanSize = size;
+            srcQualifiedName = typeof sym.qualifiedName === "string" ? sym.qualifiedName : "";
+          }
+        }
+      }
+      if (srcQualifiedName.length === 0) continue;
+      const memberAccess = "memberAccess" in site && site.memberAccess === true;
+      if (!memberAccess && alreadyResolved(rel, srcQualifiedName, calleeName)) {
+        filteredCountByFile.set(rel, (filteredCountByFile.get(rel) ?? 0) + 1);
+        let srcs = filteredSrcByFile.get(rel);
+        if (srcs === void 0) {
+          srcs = /* @__PURE__ */ new Map();
+          filteredSrcByFile.set(rel, srcs);
+        }
+        const callees = srcs.get(srcQualifiedName);
+        if (callees === void 0) srcs.set(srcQualifiedName, /* @__PURE__ */ new Set([calleeName]));
+        else callees.add(calleeName);
+        continue;
+      }
+      const nameIdx = contentBytes.indexOf(Buffer.from(calleeName, "utf-8"), span.startByte);
+      const endByte = "endByte" in span && typeof span.endByte === "number" ? span.endByte : span.startByte + calleeName.length;
+      const calleeByteOffset = nameIdx >= 0 && nameIdx < endByte ? nameIdx : span.startByte;
+      sites.push({ filePath: rel, language, content, calleeByteOffset, calleeName, srcQualifiedName });
+      gatheredCountByFile.set(rel, (gatheredCountByFile.get(rel) ?? 0) + 1);
+    }
+  }
+  const canPreserve = typeof params.store.callEdgesForCaller === "function";
+  const preservedEdgesForFile = (rel) => {
+    const srcs = filteredSrcByFile.get(rel);
+    if (srcs === void 0 || !canPreserve) return [];
+    const preserved = [];
+    for (const [src] of srcs) {
+      const heuristicDsts = new Set(
+        params.store.callEdgesForCaller(src, rel, "heuristic").map((e) => e.dstQualifiedName)
+      );
+      for (const edge of params.store.callEdgesForCaller(src, rel, "lsp")) {
+        if (!heuristicDsts.has(edge.dstQualifiedName)) continue;
+        preserved.push({
+          srcQualifiedName: edge.srcQualifiedName,
+          dstQualifiedName: edge.dstQualifiedName,
+          type: edge.type
+        });
+      }
+    }
+    return preserved;
+  };
+  if (typeof params.store.reconcileLspEdges === "function") {
+    for (const rel of parsedFiles) {
+      if ((gatheredCountByFile.get(rel) ?? 0) !== 0) continue;
+      const filteredCount = filteredCountByFile.get(rel) ?? 0;
+      if (filteredCount > 0 && !canPreserve) continue;
+      params.store.reconcileLspEdges(rel, preservedEdgesForFile(rel));
+    }
+  }
+  if (sites.length === 0) {
+    return { ok: true, upgraded: 0, unresolved: 0, budgetExhausted: 0 };
+  }
+  const byLanguage = /* @__PURE__ */ new Map();
+  const srcToFiles = /* @__PURE__ */ new Map();
+  for (const site of sites) {
+    const group = byLanguage.get(site.language);
+    if (group === void 0) byLanguage.set(site.language, [site]);
+    else group.push(site);
+    const files = srcToFiles.get(site.srcQualifiedName);
+    if (files === void 0) srcToFiles.set(site.srcQualifiedName, /* @__PURE__ */ new Set([site.filePath]));
+    else files.add(site.filePath);
+  }
+  const configServers = params.lspConfig.servers ?? {};
+  const timeoutMs = params.lspConfig.timeoutMs ?? 3e3;
+  let remainingBudget = Math.max(1, Math.floor(params.lspConfig.maxRequestsPerRun ?? 500));
+  const rootUri = pathToFileURL(repoRoot).href;
+  const resolveContent = (filePath) => {
+    const absPath = path2.join(repoRoot, filePath);
+    if (lspPathEscapesRootSync(repoRoot, absPath)) return null;
+    try {
+      return readFileSync(absPath, "utf-8");
+    } catch {
+      return null;
+    }
+  };
+  let upgraded = 0;
+  let unresolved = 0;
+  let budgetExhausted = 0;
+  const degradations = [];
+  for (const [language, group] of byLanguage) {
+    if (remainingBudget <= 0) {
+      budgetExhausted += group.length;
+      continue;
+    }
+    const rawSpec = configServers[language] ?? DEFAULT_LSP_SERVERS[language];
+    if (rawSpec === void 0) {
+      degradations.push({
+        language,
+        code: "no_launch_spec",
+        message: `No LSP server configured for ${language} (${group.length} candidate call site(s)); set codingKnowledge.lsp.servers.${language}.`
+      });
+      unresolved += group.length;
+      continue;
+    }
+    const launchSpec = { command: rawSpec.command, args: rawSpec.args ?? [] };
+    const plan = mod.planLspUpgrades(group, { maxRequests: remainingBudget });
+    budgetExhausted += plan.budgetExhausted;
+    remainingBudget -= plan.requests.length;
+    if (plan.requests.length === 0) continue;
+    const plannedCountByFile = /* @__PURE__ */ new Map();
+    for (const req of plan.requests) {
+      if (req && typeof req === "object" && "filePath" in req && typeof req.filePath === "string") {
+        plannedCountByFile.set(req.filePath, (plannedCountByFile.get(req.filePath) ?? 0) + 1);
+      }
+    }
+    const connected = await mod.LspClient.connect({ launchSpec, rootUri, timeoutMs });
+    if (!connected.ok) {
+      const deg = connected.degradation;
+      const code = deg && typeof deg === "object" && "code" in deg && typeof deg.code === "string" ? deg.code : "connect_failed";
+      const message = deg && typeof deg === "object" && "detail" in deg && typeof deg.detail === "string" ? deg.detail : `LSP server for ${language} failed to connect.`;
+      degradations.push({ language, code, message });
+      unresolved += plan.requests.length;
+      remainingBudget += plan.requests.length;
+      continue;
+    }
+    const client = connected.client;
+    let skippedEdgesTotal = 0;
+    const skippedFiles = /* @__PURE__ */ new Set();
+    try {
+      const result = await mod.executeLspResolution(plan.requests, {
+        client,
+        workspaceRoot: repoRoot,
+        resolveContent,
+        nodeLocator: (filePath, byteOffset) => typeof params.store.findNodeBySpan === "function" ? params.store.findNodeBySpan(filePath, byteOffset) : null,
+        applyUpgrades: async (upgrades) => {
+          if (typeof params.store.upsertEdges !== "function") {
+            throw new Error("store.upsertEdges is not available");
+          }
+          const result2 = await params.store.upsertEdges(upgrades);
+          if (!result2.ok) {
+            degradations.push({
+              language,
+              code: "edge_write_failed",
+              message: `upsertEdges failed for ${language}: ${result2.code}.`
+            });
+            throw new Error(`upsertEdges failed: ${result2.code}`);
+          }
+          if (result2.skipped > 0) {
+            skippedEdgesTotal += result2.skipped;
+            for (const upgrade of upgrades) {
+              for (const file of srcToFiles.get(upgrade.srcQualifiedName) ?? []) {
+                skippedFiles.add(file);
+              }
+            }
+            degradations.push({
+              language,
+              code: "edges_skipped",
+              message: `upsertEdges persisted ${result2.persisted} and skipped ${result2.skipped} edge(s) for ${language} (unresolvable endpoints).`
+            });
+          }
+        },
+        reconcileLspEdges: (filePath, assertedEdges) => {
+          if (typeof params.store.reconcileLspEdges !== "function") return;
+          if (plannedCountByFile.get(filePath) !== gatheredCountByFile.get(filePath)) return;
+          if (skippedFiles.has(filePath)) return;
+          if ((filteredCountByFile.get(filePath) ?? 0) > 0 && !canPreserve) return;
+          params.store.reconcileLspEdges(filePath, [...assertedEdges, ...preservedEdgesForFile(filePath)]);
+        }
+      });
+      if (result && typeof result === "object" && "upgraded" in result && typeof result.upgraded === "number") {
+        upgraded += Math.max(0, result.upgraded - skippedEdgesTotal);
+        unresolved += "unresolved" in result && typeof result.unresolved === "number" ? result.unresolved : 0;
+        budgetExhausted += "budgetExhausted" in result && typeof result.budgetExhausted === "number" ? result.budgetExhausted : 0;
+        if ("degradation" in result && result.degradation && typeof result.degradation === "object") {
+          const rd = result.degradation;
+          degradations.push({
+            language,
+            code: "code" in rd && typeof rd.code === "string" ? rd.code : "lsp_degraded",
+            message: "detail" in rd && typeof rd.detail === "string" ? rd.detail : `LSP pass for ${language} degraded mid-run.`
+          });
+        }
+      } else {
+        unresolved += plan.requests.length;
+      }
+    } catch (err) {
+      const detail = displayErrorDetail(err);
+      return {
+        ok: false,
+        code: "lsp_resolution_error",
+        message: detail.length > 0 ? `LSP resolution failed: ${detail}.` : "LSP resolution failed."
+      };
+    } finally {
+      const disposable = client;
+      if (typeof disposable.dispose === "function") {
+        try {
+          await disposable.dispose();
+        } catch {
+        }
+      }
+    }
+  }
+  return {
+    ok: true,
+    upgraded,
+    unresolved,
+    budgetExhausted,
+    ...degradations.length > 0 ? { degradations } : {}
+  };
+}
 async function reportCodegraphIndexStatus(params) {
   const mod = await loadCodegraphModule();
   if (mod === null) {
@@ -1786,6 +2100,17 @@ async function handleIndex(request, ctx) {
   if (!outcome.ok) {
     return { tool: request.tool, ok: false, code: outcome.code, message: outcome.message };
   }
+  let lspUpgradeSummary;
+  const lspConfig = ctx.config.codingKnowledge.lsp;
+  if (lspConfig?.enabled === true && ctx.runLspResolution) {
+    const lspResult = await ctx.runLspResolution(store, repoRoot, lspConfig);
+    lspUpgradeSummary = lspResult.ok ? {
+      upgraded: lspResult.upgraded ?? 0,
+      unresolved: lspResult.unresolved ?? 0,
+      budgetExhausted: lspResult.budgetExhausted ?? 0,
+      ...lspResult.degradations !== void 0 && lspResult.degradations.length > 0 ? { degradations: lspResult.degradations } : {}
+    } : { error: lspResult.code ?? "lsp_error", message: lspResult.message ?? "" };
+  }
   const stats = store.schemaStats();
   return {
     tool: request.tool,
@@ -1795,7 +2120,8 @@ async function handleIndex(request, ctx) {
       mode: outcome.mode,
       filesIngested: outcome.filesIngested,
       head: outcome.head,
-      stats
+      stats,
+      ...lspUpgradeSummary ? { lsp: lspUpgradeSummary } : {}
     }
   };
 }
@@ -1943,7 +2269,7 @@ function isLikelyCypher(input) {
 }
 
 // src/coding/session-delta.ts
-import { readFile as readFile2, writeFile, mkdir, rename } from "fs/promises";
+import { readFile as readFile3, writeFile, mkdir, rename } from "fs/promises";
 import path3 from "path";
 var MAX_DELTA_COMMITS = 20;
 var MAX_DELTA_FILES = 50;
@@ -2009,7 +2335,7 @@ function sessionDeltaStatePath(memoryDir, namespace) {
 }
 async function readLastSeenState(statePath) {
   try {
-    const raw = await readFile2(statePath, "utf8");
+    const raw = await readFile3(statePath, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return null;
     const obj = parsed;
@@ -2423,7 +2749,7 @@ var CorrectionContractError = class extends Error {
 };
 
 // src/correction/correction-planner.ts
-import { mkdir as mkdir2, readFile as readFile3, rename as rename2, unlink, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rename as rename2, unlink, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
 import path4 from "path";
 var REDACTED_REQUEST_TEXT = "[redacted \u2014 never-store/redaction correction text withheld from the pending-plan file]";
 var CorrectionPlanner = class _CorrectionPlanner {
@@ -2627,7 +2953,7 @@ var CorrectionPlanner = class _CorrectionPlanner {
     return serializeMutations(`correction-plan:${file}`, async () => {
       let raw;
       try {
-        raw = await readFile3(file, "utf-8");
+        raw = await readFile4(file, "utf-8");
       } catch (err) {
         const code = err?.code;
         if (code === "ENOENT") return null;
@@ -2667,7 +2993,7 @@ var CorrectionPlanner = class _CorrectionPlanner {
     await serializeMutations(`correction-plan:${file}`, async () => {
       let raw;
       try {
-        raw = await readFile3(file, "utf-8");
+        raw = await readFile4(file, "utf-8");
       } catch (err) {
         const code = err?.code;
         if (code === "ENOENT") return;
@@ -10924,4 +11250,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-OXVKR5OU.js.map
+//# sourceMappingURL=chunk-RU73ZROD.js.map