@remnic/core 9.3.651 → 9.3.653

package/src/access-service.ts

@@ -38,6 +38,7 @@ import {
   runMemoryGovernance,
 } from "./maintenance/memory-governance.js";
 import { runProcedureMining } from "./procedural/procedure-miner.js";
+import { displayErrorDetail } from "./runtime/better-sqlite.js";
 import type { PatternReinforcementResult } from "./maintenance/pattern-reinforcement.js";
 import type { LiveConnectorsRunSummary } from "./live-connectors-runner.js";
 import type { WearablesService } from "./wearables/service.js";
@@ -279,10 +280,32 @@ export interface EngramAccessHealthResponse {
   defaultNamespace: string;
   searchBackend: string;
   qmdEnabled: boolean;
+  qmd: EngramAccessQmdHealthResponse;
   nativeKnowledgeEnabled: boolean;
   projectionAvailable: boolean;
 }
 
+export type EngramAccessQmdCollectionState =
+  | "present"
+  | "missing"
+  | "unknown"
+  | "skipped";
+
+export interface EngramAccessQmdHealthResponse {
+  enabled: boolean;
+  active: boolean;
+  degraded: boolean;
+  mode: "cli" | "daemon" | "fallback" | "disabled" | "not-selected";
+  collection: string;
+  collectionState: EngramAccessQmdCollectionState;
+  installedVersion: string | null;
+  supportedVersion: string | null;
+  supported: boolean | null;
+  upgradeAvailable: boolean | null;
+  doctorAvailable: boolean | null;
+  debugStatus: string;
+}
+
 export interface EngramAccessRecallRequest {
   query: string;
   sessionKey?: string;
@@ -2412,6 +2435,8 @@ export class EngramAccessService {
   async health(namespace?: string): Promise<EngramAccessHealthResponse> {
     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 stat(getMemoryProjectionPath(storage.dir));
@@ -2425,13 +2450,260 @@ export class EngramAccessService {
       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,
     };
   }
 
+  private qmdCollectionForHealth(namespace: string, storageDir: string): string {
+    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,
+    });
+  }
+
+  private async qmdHealth(
+    searchBackend: string,
+    qmdEnabled: boolean,
+    namespace: string,
+    collection: string,
+  ): Promise<EngramAccessQmdHealthResponse> {
+    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,
+    };
+  }
+
+  private async namespaceQmdHealth(
+    searchBackend: string,
+    qmdEnabled: boolean,
+    namespace: string,
+    fallbackCollection: string,
+  ): Promise<EngramAccessQmdHealthResponse | null> {
+    if (searchBackend !== "qmd" || !qmdEnabled) return null;
+    const searchHealthForNamespace = (
+      this.orchestrator as Orchestrator & {
+        searchHealthForNamespace?: (
+          namespace: string,
+          execution?: { signal?: AbortSignal },
+        ) => Promise<{
+          collection: string;
+          available: boolean;
+          collectionState: EngramAccessQmdCollectionState;
+          debugStatus: string;
+          installedVersion: string | null;
+          supportedVersion: string | null;
+          supported: boolean | null;
+          upgradeAvailable: boolean | null;
+          doctorAvailable: boolean | null;
+          daemonMode: boolean | null;
+        }>;
+      }
+    ).searchHealthForNamespace;
+    if (typeof searchHealthForNamespace !== "function") return null;
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2_000);
+    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);
+    }
+  }
+
+  private async qmdCollectionState(
+    searchBackend: string,
+    qmdEnabled: boolean,
+    collection: string,
+  ): Promise<EngramAccessQmdCollectionState> {
+    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(), 2_000);
+    timer.unref?.();
+    try {
+      return await qmd.checkCollection(collection, {
+        signal: controller.signal,
+      });
+    } catch {
+      return "unknown";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  private async qmdProbeAvailable(
+    searchBackend: string,
+    qmdEnabled: boolean,
+  ): Promise<boolean> {
+    if (searchBackend !== "qmd" || !qmdEnabled) return false;
+    const qmd = this.orchestrator.qmd;
+    if (!qmd) return false;
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2_000);
+    timer.unref?.();
+    try {
+      return await new Promise<boolean>((resolve) => {
+        const onAbort = () => {
+          controller.signal.removeEventListener("abort", onAbort);
+          resolve(false);
+        };
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+        const probe =
+          typeof qmd.checkAvailability === "function"
+            ? qmd.checkAvailability({ signal: controller.signal })
+            : qmd.probe();
+        probe
+          .then(resolve, () => resolve(false))
+          .finally(() => {
+            controller.signal.removeEventListener("abort", onAbort);
+          });
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
   async actionConfidence(
     request: EngramAccessActionConfidenceRequest = {},
   ): Promise<EngramAccessActionConfidenceResponse> {

package/src/briefing.test.ts

@@ -16,6 +16,7 @@ import {
   focusMatchesMemory,
   buildActiveThreads,
   buildBriefing,
+  buildChainFollowupGenerator,
   BRIEFING_FOLLOWUP_DEFAULT_MODEL,
 } from "./briefing.js";
 import type {
@@ -976,6 +977,75 @@ test("buildBriefing: unrelated LLM errors still produce generic message (no fals
   );
 });
 
+test("buildChainFollowupGenerator accepts markdown-fenced followup JSON", async () => {
+  const generator = buildChainFollowupGenerator({
+    chatCompletion: async () => ({
+      content: [
+        "```json",
+        "{",
+        '  "followups": [',
+        '    { "text": "Check the launch plan", "rationale": "Open commitment found" }',
+        "  ]",
+        "}",
+        "```",
+      ].join("\n"),
+    }),
+  });
+
+  const followups = await generator({
+    sections: {
+      activeThreads: [],
+      recentEntities: [],
+      openCommitments: [{ id: "commit-1", kind: "commitment", text: "Finish launch plan" }],
+      suggestedFollowups: [],
+    },
+    windowLabel: "today",
+    maxFollowups: 3,
+  });
+
+  assert.deepEqual(followups, [
+    {
+      text: "Check the launch plan",
+      rationale: "Open commitment found",
+    },
+  ]);
+});
+
+test("buildChainFollowupGenerator skips parseable non-followup JSON candidates", async () => {
+  const generator = buildChainFollowupGenerator({
+    chatCompletion: async () => ({
+      content: [
+        '{ "metadata": "not followups" }',
+        "```json",
+        "{",
+        '  "followups": [',
+        '    { "text": "Review the launch plan", "rationale": "Actual follow-up block" }',
+        "  ]",
+        "}",
+        "```",
+      ].join("\n"),
+    }),
+  });
+
+  const followups = await generator({
+    sections: {
+      activeThreads: [],
+      recentEntities: [],
+      openCommitments: [{ id: "commit-1", kind: "commitment", text: "Finish launch plan" }],
+      suggestedFollowups: [],
+    },
+    windowLabel: "today",
+    maxFollowups: 3,
+  });
+
+  assert.deepEqual(followups, [
+    {
+      text: "Review the launch plan",
+      rationale: "Actual follow-up block",
+    },
+  ]);
+});
+
 // ──────────────────────────────────────────────────────────────────────────
 // Round 8 Finding UXE4: buildActiveThreads must recompute reason from newer memory
 // ──────────────────────────────────────────────────────────────────────────

package/src/briefing.ts

@@ -1298,27 +1298,37 @@ function parseFollowupResponse(raw: string, max: number): BriefingFollowup[] {
   // JSON.parse throws on invalid JSON — let the caller catch it so the outer
   // try/catch in buildBriefing can set followupsUnavailableReason rather than
   // silently returning an empty array that masks the parse failure.
-  const parsed = JSON.parse(raw) as unknown;
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error(`LLM returned non-object JSON: ${typeof parsed}`);
-  }
-  const arr = (parsed as { followups?: unknown }).followups;
-  if (!Array.isArray(arr)) {
-    throw new Error(`LLM response missing "followups" array`);
-  }
-  const out: BriefingFollowup[] = [];
-  for (const entry of arr) {
-    if (!entry || typeof entry !== "object") continue;
-    const text = (entry as Record<string, unknown>).text;
-    if (typeof text !== "string" || text.trim().length === 0) continue;
-    const rationale = (entry as Record<string, unknown>).rationale;
-    out.push({
-      text: text.trim(),
-      rationale: typeof rationale === "string" ? rationale.trim() : undefined,
-    });
-    if (out.length >= max) break;
+  const candidates = extractJsonCandidates(raw);
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate) as unknown;
+      if (!parsed || typeof parsed !== "object") {
+        throw new Error(`LLM returned non-object JSON: ${typeof parsed}`);
+      }
+      const arr = (parsed as { followups?: unknown }).followups;
+      if (!Array.isArray(arr)) {
+        throw new Error(`LLM response missing "followups" array`);
+      }
+      const out: BriefingFollowup[] = [];
+      for (const entry of arr) {
+        if (!entry || typeof entry !== "object") continue;
+        const text = (entry as Record<string, unknown>).text;
+        if (typeof text !== "string" || text.trim().length === 0) continue;
+        const rationale = (entry as Record<string, unknown>).rationale;
+        out.push({
+          text: text.trim(),
+          rationale: typeof rationale === "string" ? rationale.trim() : undefined,
+        });
+        if (out.length >= max) break;
+      }
+      return out;
+    } catch (err) {
+      lastError = err;
+    }
   }
-  return out;
+  if (lastError) throw lastError;
+  throw new Error("LLM response contained no JSON candidates");
 }
 
 function stringifyError(err: unknown): string {