@remnic/core 9.3.650 → 9.3.652

package/dist/{chunk-QKE4LHNR.js → chunk-4HYSMH7D.js}

@@ -1,6 +1,6 @@
 import {
   isValidCapsuleSince
-} from "./chunk-BUKK5SWA.js";
+} from "./chunk-KQAFEZQX.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
@@ -432,4 +432,4 @@ export {
   actionConfidenceRequestSchema,
   validateRequest
 };
-//# sourceMappingURL=chunk-QKE4LHNR.js.map
+//# sourceMappingURL=chunk-4HYSMH7D.js.map

package/dist/{chunk-DDRNDPX4.js → chunk-4SKKVWLQ.js}

@@ -1,6 +1,6 @@
 import {
   getVerdictKind
-} from "./chunk-M75TBFKQ.js";
+} from "./chunk-Z2OXSMZK.js";
 import {
   scoreImportance
 } from "./chunk-JXS5PDQ7.js";
@@ -1161,4 +1161,4 @@ export {
   syncWearableSource,
   defaultTimezone
 };
-//# sourceMappingURL=chunk-DDRNDPX4.js.map
+//# sourceMappingURL=chunk-4SKKVWLQ.js.map

package/dist/chunk-5FOCXX5E.js

@@ -0,0 +1,34 @@
+// src/lcm-fallback-read.ts
+var UNDEFINED_SESSION_SENTINEL = " <lcm-sessionless>";
+function resolveLcmReadSessionIds(target) {
+  const source = target.sessionIds && target.sessionIds.length > 0 ? target.sessionIds : [target.sessionId];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const sessionId of source) {
+    const key = sessionId === void 0 ? UNDEFINED_SESSION_SENTINEL : sessionId;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(sessionId);
+  }
+  return out.length > 0 ? out : [target.sessionId];
+}
+async function gatherAcrossReadSessions(sessionIds, gather) {
+  if (sessionIds.length <= 1) {
+    for (const sessionId of sessionIds) {
+      await gather(sessionId);
+    }
+    return;
+  }
+  for (const sessionId of sessionIds) {
+    try {
+      await gather(sessionId);
+    } catch {
+    }
+  }
+}
+
+export {
+  resolveLcmReadSessionIds,
+  gatherAcrossReadSessions
+};
+//# sourceMappingURL=chunk-5FOCXX5E.js.map

package/dist/chunk-5FOCXX5E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lcm-fallback-read.ts"],"sourcesContent":["/**\n * Shared helper for reading LCM-backed recall sections across the ordered,\n * read-authorized fallback key set (#1505 codex P2 \"Merge LCM fallback reads\n * instead of short-circuiting\").\n *\n * Background: a branch-scoped session archives its LCM rows under whichever\n * coding-overlay namespace was effective at write time, so its evidence can be\n * split across the primary overlay key AND the project / root fallback keys.\n * Normal QMD/file recall already searches the primary namespace PLUS\n * `codingOverlay.readFallbacks` and MERGES the rows. The LCM read path must do\n * the same: query EVERY authorized read key and merge the candidate evidence\n * into each section's existing dedupe + rank + budget pass, instead of stopping\n * at the first key that happens to yield a (possibly weak) hit.\n *\n * Each section already owns a section-appropriate dedupe (a `seen` set or a\n * `rankAndDedupe…` step), so the fan-out only needs to resolve the ordered,\n * deduped read-key set and UNION the per-key candidates into that existing\n * pipeline — the budget is then applied exactly once to the union. Centralizing\n * the key-set resolution here (rather than re-implementing per builder) follows\n * CLAUDE.md rule 22 (scope resolution must be deduplicated).\n */\n\n/** A recall section's LCM read target: either a single key or an ordered set. */\nexport interface LcmReadSessionTarget {\n  /**\n   * The single LCM read `session_id` (pre-#1505 behavior). `undefined` means a\n   * sessionless, archive-wide read with no `session_id` filter.\n   */\n  sessionId?: string;\n  /**\n   * The ordered, read-authorized LCM read key set (primary overlay key first,\n   * then project / root fallbacks) the orchestrator derived from the same\n   * readable namespace set normal recall searches. When present and non-empty,\n   * it supersedes `sessionId`.\n   */\n  sessionIds?: readonly (string | undefined)[];\n}\n\n// `undefined` (a sessionless, archive-wide read) is a distinct, legitimate read\n// target, so it needs a non-string sentinel in the dedupe set. A leading space\n// keeps it disjoint from every real session key / namespaced LCM key (which are\n// `[A-Za-z0-9._-]` plus the U+001F namespace sentinel, never leading-space).\nconst UNDEFINED_SESSION_SENTINEL = \" <lcm-sessionless>\";\n\n/**\n * Resolve the ordered, deduped set of LCM read `session_id`s a recall section\n * must query.\n *\n * When `sessionIds` is provided (the #1505 fallback unification), it is used\n * verbatim, deduped while preserving first-seen order so the caller queries\n * keys in priority order (primary overlay → fallbacks) without re-querying an\n * identical key (e.g. when two namespaces both collapse to the default store).\n * Otherwise the section reads under the single `sessionId`, so the result is\n * `[sessionId]` — byte-for-byte the pre-#1505 single-key behavior, including a\n * single `undefined` for a sessionless archive-wide read.\n */\nexport function resolveLcmReadSessionIds(\n  target: LcmReadSessionTarget,\n): Array<string | undefined> {\n  const source =\n    target.sessionIds && target.sessionIds.length > 0\n      ? target.sessionIds\n      : [target.sessionId];\n  const seen = new Set<string>();\n  const out: Array<string | undefined> = [];\n  for (const sessionId of source) {\n    const key = sessionId === undefined ? UNDEFINED_SESSION_SENTINEL : sessionId;\n    if (seen.has(key)) continue;\n    seen.add(key);\n    out.push(sessionId);\n  }\n  // Defensive: an all-empty `sessionIds` still collapses to the single-key path.\n  return out.length > 0 ? out : [target.sessionId];\n}\n\n/**\n * Run a per-key LCM `gather` across the resolved read-key set with FAULT\n * ISOLATION across keys (#1505 codex P2 review follow-up).\n *\n * A recall section that reads every key in a bare `for…await` loop loses the\n * WHOLE section if any one key throws (e.g. a `SqliteError` from a corrupt or\n * locked fallback index) — even when the primary overlay key already gathered\n * evidence. The pre-#1505 first-non-empty read never had this problem: it\n * returned the primary key's non-empty result without ever touching a failing\n * fallback. This helper restores that resilience for the merged path: when more\n * than one key is read, a per-key failure is contained so the other keys'\n * evidence survives (best-effort recall — a total failure degrades to an empty\n * section, which the orchestrator already treats as \"no evidence\").\n *\n * SINGLE-KEY is byte-for-byte the pre-#1505 behavior: the gather runs directly,\n * so a failure PROPAGATES exactly as before (the caller / orchestrator catch\n * still logs it). Fault isolation only engages once there is a fallback key that\n * could fail independently of the primary.\n */\nexport async function gatherAcrossReadSessions(\n  sessionIds: ReadonlyArray<string | undefined>,\n  gather: (sessionId: string | undefined) => Promise<void>,\n): Promise<void> {\n  if (sessionIds.length <= 1) {\n    for (const sessionId of sessionIds) {\n      await gather(sessionId);\n    }\n    return;\n  }\n  for (const sessionId of sessionIds) {\n    try {\n      await gather(sessionId);\n    } catch {\n      // One read key failed; keep the evidence already gathered from the other\n      // keys instead of discarding the whole section.\n    }\n  }\n}\n"],"mappings":";AA0CA,IAAM,6BAA6B;AAc5B,SAAS,yBACd,QAC2B;AAC3B,QAAM,SACJ,OAAO,cAAc,OAAO,WAAW,SAAS,IAC5C,OAAO,aACP,CAAC,OAAO,SAAS;AACvB,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,MAAiC,CAAC;AACxC,aAAW,aAAa,QAAQ;AAC9B,UAAM,MAAM,cAAc,SAAY,6BAA6B;AACnE,QAAI,KAAK,IAAI,GAAG,EAAG;AACnB,SAAK,IAAI,GAAG;AACZ,QAAI,KAAK,SAAS;AAAA,EACpB;AAEA,SAAO,IAAI,SAAS,IAAI,MAAM,CAAC,OAAO,SAAS;AACjD;AAqBA,eAAsB,yBACpB,YACA,QACe;AACf,MAAI,WAAW,UAAU,GAAG;AAC1B,eAAW,aAAa,YAAY;AAClC,YAAM,OAAO,SAAS;AAAA,IACxB;AACA;AAAA,EACF;AACA,aAAW,aAAa,YAAY;AAClC,QAAI;AACF,YAAM,OAAO,SAAS;AAAA,IACxB,QAAQ;AAAA,IAGR;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-YAFSTKTH.js → chunk-5V3TAB7D.js}

@@ -8,7 +8,10 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-NT5TINK5.js";
+} from "./chunk-DHGSZ3UD.js";
+import {
+  decideDisclosureEscalation
+} from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
 } from "./chunk-IENGGY2C.js";
@@ -17,9 +20,6 @@ import {
   normalizeTags,
   parseTagMatch
 } from "./chunk-BT7NVCML.js";
-import {
-  decideDisclosureEscalation
-} from "./chunk-H7XKCNR6.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -27,7 +27,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-UMTG2BN2.js";
+} from "./chunk-V4UDXYGG.js";
 import {
   clusterByKey,
   combineNamespaces,
@@ -53,7 +53,7 @@ import {
 } from "./chunk-BEMWL2FZ.js";
 import {
   namespaceCollectionName
-} from "./chunk-NMIOW7XG.js";
+} from "./chunk-JVRPJ7D4.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -92,10 +92,10 @@ import {
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-AMACWKM4.js";
+} from "./chunk-IJHLC5CH.js";
 import {
   parseEntityFile
-} from "./chunk-A4BTPHIN.js";
+} from "./chunk-Y7NWBBHV.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
@@ -111,6 +111,9 @@ import {
 import {
   getMemoryProjectionPath
 } from "./chunk-MB5RSUW6.js";
+import {
+  displayErrorDetail
+} from "./chunk-6KYMPV2O.js";
 import {
   defaultCapsulesDir
 } from "./chunk-ZY2MNJR6.js";
@@ -137,7 +140,7 @@ import {
 } from "./chunk-VFUEZZBS.js";
 import {
   exportCapsule
-} from "./chunk-BUKK5SWA.js";
+} from "./chunk-KQAFEZQX.js";
 import {
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   applyOfflineSyncChangeset,
@@ -1471,6 +1474,8 @@ var EngramAccessService = class {
   async health(namespace) {
     const resolvedNamespace = this.resolveNamespace(namespace);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const searchBackend = this.orchestrator.config.searchBackend ?? "qmd";
+    const qmdEnabled = this.orchestrator.config.qmdEnabled === true;
     let projectionAvailable = false;
     try {
       await stat2(getMemoryProjectionPath(storage.dir));
@@ -1483,12 +1488,179 @@ var EngramAccessService = class {
       memoryDir: storage.dir,
       namespacesEnabled: this.orchestrator.config.namespacesEnabled === true,
       defaultNamespace: this.orchestrator.config.defaultNamespace,
-      searchBackend: this.orchestrator.config.searchBackend ?? "qmd",
-      qmdEnabled: this.orchestrator.config.qmdEnabled === true,
+      searchBackend,
+      qmdEnabled,
+      qmd: await this.qmdHealth(
+        searchBackend,
+        qmdEnabled,
+        resolvedNamespace,
+        this.qmdCollectionForHealth(resolvedNamespace, storage.dir)
+      ),
       nativeKnowledgeEnabled: this.orchestrator.config.nativeKnowledge?.enabled === true,
       projectionAvailable
     };
   }
+  qmdCollectionForHealth(namespace, storageDir) {
+    if (this.orchestrator.config.namespacesEnabled !== true) {
+      return this.orchestrator.config.qmdCollection;
+    }
+    const useLegacyDefaultCollection = namespace === this.orchestrator.config.defaultNamespace && storageDir === this.orchestrator.config.memoryDir;
+    return namespaceCollectionName(this.orchestrator.config.qmdCollection, namespace, {
+      defaultNamespace: this.orchestrator.config.defaultNamespace,
+      useLegacyDefaultCollection
+    });
+  }
+  async qmdHealth(searchBackend, qmdEnabled, namespace, collection) {
+    if (searchBackend !== "qmd" || !qmdEnabled) {
+      return {
+        enabled: qmdEnabled,
+        active: false,
+        degraded: false,
+        mode: searchBackend !== "qmd" ? "not-selected" : "disabled",
+        collection,
+        collectionState: "skipped",
+        installedVersion: null,
+        supportedVersion: null,
+        supported: null,
+        upgradeAvailable: null,
+        doctorAvailable: null,
+        debugStatus: searchBackend !== "qmd" ? `backend=${searchBackend}` : "backend=disabled"
+      };
+    }
+    if (this.orchestrator.config.namespacesEnabled === true) {
+      const namespaceHealth = await this.namespaceQmdHealth(searchBackend, qmdEnabled, namespace, collection);
+      if (namespaceHealth) return namespaceHealth;
+    }
+    const qmd = this.orchestrator.qmd;
+    if (!qmd) {
+      return {
+        enabled: true,
+        active: false,
+        degraded: true,
+        mode: "fallback",
+        collection,
+        collectionState: "unknown",
+        installedVersion: null,
+        supportedVersion: null,
+        supported: null,
+        upgradeAvailable: null,
+        doctorAvailable: null,
+        debugStatus: "backend=unavailable"
+      };
+    }
+    const diagnosticAvailable = await this.qmdProbeAvailable(searchBackend, qmdEnabled);
+    const operationalAvailable = diagnosticAvailable || qmd.isAvailable();
+    const collectionState = diagnosticAvailable ? await this.qmdCollectionState(searchBackend, qmdEnabled, collection) : "unknown";
+    const active = operationalAvailable && collectionState !== "missing";
+    const degraded = searchBackend === "qmd" && qmdEnabled && (!active || !diagnosticAvailable || collectionState === "unknown");
+    const debugStatus = qmd.debugStatus();
+    const versionStatus = "getVersionStatus" in qmd && typeof qmd.getVersionStatus === "function" ? qmd.getVersionStatus() : null;
+    const daemonMode = "isDaemonMode" in qmd && typeof qmd.isDaemonMode === "function" ? qmd.isDaemonMode() === true : false;
+    const mode = searchBackend !== "qmd" ? "not-selected" : !qmdEnabled ? "disabled" : !active ? "fallback" : daemonMode ? "daemon" : "cli";
+    return {
+      enabled: qmdEnabled,
+      active,
+      degraded,
+      mode,
+      collection,
+      collectionState,
+      installedVersion: versionStatus?.installedVersion ?? null,
+      supportedVersion: versionStatus?.supportedVersion ?? null,
+      supported: versionStatus?.supported ?? null,
+      upgradeAvailable: versionStatus?.upgradeAvailable ?? null,
+      doctorAvailable: versionStatus?.capabilities?.doctor ?? null,
+      debugStatus
+    };
+  }
+  async namespaceQmdHealth(searchBackend, qmdEnabled, namespace, fallbackCollection) {
+    if (searchBackend !== "qmd" || !qmdEnabled) return null;
+    const searchHealthForNamespace = this.orchestrator.searchHealthForNamespace;
+    if (typeof searchHealthForNamespace !== "function") return null;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    timer.unref?.();
+    try {
+      const health = await searchHealthForNamespace.call(this.orchestrator, namespace, {
+        signal: controller.signal
+      });
+      const active = health.available && health.collectionState !== "missing";
+      const degraded = !active || health.collectionState === "unknown";
+      const mode = !active ? "fallback" : health.daemonMode === true ? "daemon" : "cli";
+      return {
+        enabled: true,
+        active,
+        degraded,
+        mode,
+        collection: health.collection || fallbackCollection,
+        collectionState: health.collectionState,
+        installedVersion: health.installedVersion,
+        supportedVersion: health.supportedVersion,
+        supported: health.supported,
+        upgradeAvailable: health.upgradeAvailable,
+        doctorAvailable: health.doctorAvailable,
+        debugStatus: health.debugStatus
+      };
+    } catch (error) {
+      const detail = displayErrorDetail(error) || "unknown";
+      return {
+        enabled: true,
+        active: false,
+        degraded: true,
+        mode: "fallback",
+        collection: fallbackCollection,
+        collectionState: "unknown",
+        installedVersion: null,
+        supportedVersion: null,
+        supported: null,
+        upgradeAvailable: null,
+        doctorAvailable: null,
+        debugStatus: `backend=namespace-unavailable error=${detail}`
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async qmdCollectionState(searchBackend, qmdEnabled, collection) {
+    if (searchBackend !== "qmd" || !qmdEnabled) return "skipped";
+    const qmd = this.orchestrator.qmd;
+    if (!qmd.isAvailable()) return "unknown";
+    if (!qmd.checkCollection) return "skipped";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    timer.unref?.();
+    try {
+      return await qmd.checkCollection(collection, {
+        signal: controller.signal
+      });
+    } catch {
+      return "unknown";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async qmdProbeAvailable(searchBackend, qmdEnabled) {
+    if (searchBackend !== "qmd" || !qmdEnabled) return false;
+    const qmd = this.orchestrator.qmd;
+    if (!qmd) return false;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    timer.unref?.();
+    try {
+      return await new Promise((resolve2) => {
+        const onAbort = () => {
+          controller.signal.removeEventListener("abort", onAbort);
+          resolve2(false);
+        };
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+        const probe = typeof qmd.checkAvailability === "function" ? qmd.checkAvailability({ signal: controller.signal }) : qmd.probe();
+        probe.then(resolve2, () => resolve2(false)).finally(() => {
+          controller.signal.removeEventListener("abort", onAbort);
+        });
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   async actionConfidence(request = {}) {
     return evaluateActionConfidence(request);
   }
@@ -5177,4 +5349,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-YAFSTKTH.js.map
+//# sourceMappingURL=chunk-5V3TAB7D.js.map