@remnic/core 9.3.650 → 9.3.652

package/src/qmd.test.ts

@@ -183,6 +183,108 @@ test("QmdClient preserves configured qmdPath diagnostics when all probes fail",
   }
 });
 
+test("QmdClient read-only availability failures preserve operational state", async () => {
+  const { QmdClient } = await import("./qmd.js");
+  const originalPath = process.env.PATH;
+  const originalWindowsPath = process.env.Path;
+  const missingQmdPath = path.join(
+    os.tmpdir(),
+    `remnic-missing-readonly-qmd-${process.pid}-${Date.now()}`,
+    "qmd.cmd",
+  );
+
+  process.env.PATH = "";
+  process.env.Path = "";
+  try {
+    const client = new QmdClient("test-collection", 10, {
+      qmdPath: missingQmdPath,
+      qmdFallbackPaths: [],
+    });
+    (client as any).available = true;
+    (client as any).qmdPath = "qmd";
+    (client as any).qmdPathSource = "auto-path";
+    (client as any).cliVersion = "qmd 2.5.3";
+    (client as any).qmdCapabilities = resolveQmdCapabilities("qmd 2.5.3");
+    (client as any).lastCliProbeError = null;
+
+    assert.equal(await client.checkAvailability(), false);
+
+    assert.equal(client.isAvailable(), true);
+    assert.equal((client as any).qmdPath, "qmd");
+    assert.equal((client as any).qmdPathSource, "auto-path");
+    assert.equal((client as any).cliVersion, "qmd 2.5.3");
+    assert.equal((client as any).lastCliProbeError, null);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    if (originalWindowsPath === undefined) delete process.env.Path;
+    else process.env.Path = originalWindowsPath;
+  }
+});
+
+test("QmdClient read-only availability preserves live daemon availability", async () => {
+  const { QmdClient } = await import("./qmd.js");
+  const originalPath = process.env.PATH;
+  const originalWindowsPath = process.env.Path;
+  const missingQmdPath = path.join(
+    os.tmpdir(),
+    `remnic-missing-daemon-qmd-${process.pid}-${Date.now()}`,
+    "qmd.cmd",
+  );
+
+  process.env.PATH = "";
+  process.env.Path = "";
+  try {
+    const client = new QmdClient("test-collection", 10, {
+      qmdPath: missingQmdPath,
+      qmdFallbackPaths: [],
+    });
+    (client as any).daemonAvailable = true;
+    (client as any).daemonSession = { isActive: () => true };
+
+    assert.equal(await client.checkAvailability(), true);
+    assert.equal(client.isAvailable(), true);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    if (originalWindowsPath === undefined) delete process.env.Path;
+    else process.env.Path = originalWindowsPath;
+  }
+});
+
+test("QmdClient read-only availability clears stale daemon availability", async () => {
+  const { QmdClient } = await import("./qmd.js");
+  const originalPath = process.env.PATH;
+  const originalWindowsPath = process.env.Path;
+  const missingQmdPath = path.join(
+    os.tmpdir(),
+    `remnic-missing-stale-daemon-qmd-${process.pid}-${Date.now()}`,
+    "qmd.cmd",
+  );
+
+  process.env.PATH = "";
+  process.env.Path = "";
+  try {
+    const client = new QmdClient("test-collection", 10, {
+      qmdPath: missingQmdPath,
+      qmdFallbackPaths: [],
+    });
+    (client as any).daemonAvailable = true;
+    (client as any).daemonSession = { isActive: () => false };
+    (client as any).lastDaemonCheckAtMs = Date.now();
+
+    assert.equal(await client.checkAvailability(), false);
+    assert.equal(client.isAvailable(), false);
+    assert.equal((client as any).daemonAvailable, false);
+    assert.equal((client as any).lastDaemonCheckAtMs, 0);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    if (originalWindowsPath === undefined) delete process.env.Path;
+    else process.env.Path = originalWindowsPath;
+  }
+});
+
 test("QmdClient applies chunk strategy to normal and forced embed args", async () => {
   const { QmdClient } = await import("./qmd.js");
   const client = new QmdClient("test", 5, {

package/src/qmd.ts

@@ -1362,6 +1362,22 @@ export class QmdClient implements SearchBackend {
     return cliOk || this.daemonAvailable;
   }
 
+  async checkAvailability(execution?: SearchExecutionOptions): Promise<boolean> {
+    const cliAvailable = await this.probeCli({
+      allowAutoUpgrade: false,
+      preserveStateOnFailure: true,
+      signal: execution?.signal,
+    });
+    if (this.daemonAvailable && this.daemonSession?.isActive()) {
+      return true;
+    }
+    if (this.daemonAvailable) {
+      this.daemonAvailable = false;
+      this.lastDaemonCheckAtMs = 0;
+    }
+    return cliAvailable;
+  }
+
   private async probeDaemon(): Promise<boolean> {
     this.lastDaemonCheckAtMs = Date.now();
     const normalizedPath = this.qmdPath.trim() || "qmd";
@@ -1409,7 +1425,32 @@ export class QmdClient implements SearchBackend {
     }
   }
 
-  private async probeCli(): Promise<boolean> {
+  private async probeCli(
+    options: {
+      allowAutoUpgrade?: boolean;
+      preserveStateOnFailure?: boolean;
+      signal?: AbortSignal;
+    } = {},
+  ): Promise<boolean> {
+    const priorState = options.preserveStateOnFailure === true
+      ? {
+        available: this.available,
+        qmdPath: this.qmdPath,
+        qmdPathSource: this.qmdPathSource,
+        cliVersion: this.cliVersion,
+        lastCliProbeError: this.lastCliProbeError,
+        qmdCapabilities: this.qmdCapabilities,
+      }
+      : null;
+    const restorePriorState = (): void => {
+      if (!priorState) return;
+      this.available = priorState.available;
+      this.qmdPath = priorState.qmdPath;
+      this.qmdPathSource = priorState.qmdPathSource;
+      this.cliVersion = priorState.cliVersion;
+      this.lastCliProbeError = priorState.lastCliProbeError;
+      this.qmdCapabilities = priorState.qmdCapabilities;
+    };
     let configuredProbeFailure: string | null = null;
     const markProbeFailure = (err: unknown): void => {
       this.lastCliProbeError = err instanceof Error ? err.message : String(err);
@@ -1431,12 +1472,14 @@ export class QmdClient implements SearchBackend {
       this.cliVersion = parseQmdVersionOutput(result.stdout, result.stderr);
       this.qmdCapabilities = resolveQmdCapabilities(this.cliVersion);
       this.lastCliProbeError = null;
-      await this.maybeAutoUpgradeQmd();
+      if (options.allowAutoUpgrade !== false) {
+        await this.maybeAutoUpgradeQmd();
+      }
     };
 
     if (this.configuredQmdPath) {
       try {
-        const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, this.configuredQmdPath, undefined, this.qmdRuntimeEnv);
+        const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, this.configuredQmdPath, options.signal, this.qmdRuntimeEnv);
         await recordProbeSuccess(result, this.configuredQmdPath, "configured");
         return true;
       } catch (err) {
@@ -1452,7 +1495,7 @@ export class QmdClient implements SearchBackend {
 
     // Try PATH first
     try {
-      const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, "qmd", undefined, this.qmdRuntimeEnv);
+      const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, "qmd", options.signal, this.qmdRuntimeEnv);
       await recordProbeSuccess(result, "qmd", "auto-path");
       return true;
     } catch (err) {
@@ -1460,7 +1503,7 @@ export class QmdClient implements SearchBackend {
       // Try fallback paths
       for (const fallbackPath of this.qmdFallbackPaths) {
         try {
-          const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, fallbackPath, undefined, this.qmdRuntimeEnv);
+          const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, fallbackPath, options.signal, this.qmdRuntimeEnv);
           await recordProbeSuccess(result, fallbackPath, "auto-fallback");
           log.info(`QMD: found at ${fallbackPath}`);
           return true;
@@ -1469,8 +1512,12 @@ export class QmdClient implements SearchBackend {
           // Continue to next fallback
         }
       }
-      this.available = false;
-      restoreConfiguredProbeFailure();
+      if (priorState) {
+        restorePriorState();
+      } else {
+        this.available = false;
+        restoreConfiguredProbeFailure();
+      }
       return false;
     }
   }

package/src/response-guidance-recall.ts

@@ -1,9 +1,19 @@
 import { buildEvidencePack, type EvidencePackItem } from "./evidence-pack.js";
 import type { ExplicitCueRecallEngine } from "./explicit-cue-recall.js";
+import {
+  gatherAcrossReadSessions,
+  resolveLcmReadSessionIds,
+} from "./lcm-fallback-read.js";
 
 export interface ResponseGuidanceRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
   sessionId?: string;
+  /**
+   * Ordered, read-authorized LCM read key set (primary overlay → project/root
+   * fallbacks). When present, evidence is gathered across EVERY key and merged
+   * under this section's budget (#1505 codex P2). Falls back to `sessionId`.
+   */
+  sessionIds?: readonly (string | undefined)[];
   query: string;
   maxChars: number;
   maxItemChars?: number;
@@ -157,7 +167,17 @@ export async function buildResponseGuidanceRecallSection(
   ) {
     return "";
   }
-  const items = await collectGuidanceItems(options, intents);
+  // #1505 codex P2: gather candidates across the ordered LCM read key set
+  // (primary overlay → project/root fallbacks) and UNION them into the existing
+  // rank/dedupe/budget pass, so stronger project-fallback guidance is not masked
+  // by a weak primary-key hit. `gatherAcrossReadSessions` isolates a per-key read
+  // failure so a corrupt/locked fallback index can't discard the primary key's
+  // guidance; the single-key path collects exactly once and propagates a failure
+  // as before — byte-for-byte the pre-#1505 behavior.
+  const items: EvidencePackItem[] = [];
+  await gatherAcrossReadSessions(resolveLcmReadSessionIds(options), async (sessionId) => {
+    items.push(...(await collectGuidanceItems({ ...options, sessionId }, intents)));
+  });
   const ranked = rankAndDedupeGuidanceItems(items, options.query, intents)
     .slice(0, maxResults);
   if (ranked.length === 0) {

package/src/search/port.ts

@@ -42,6 +42,12 @@ export function resolveEnsureCollectionArgs(
 export interface SearchBackend {
   // ── Lifecycle ──
   probe(): Promise<boolean>;
+  /**
+   * Optional non-mutating availability probe for health/readiness checks.
+   * Implementations must avoid auto-upgrades, collection creation, daemon
+   * startup, or any other runtime-modifying side effects.
+   */
+  checkAvailability?(execution?: SearchExecutionOptions): Promise<boolean>;
   isAvailable(): boolean;
   debugStatus(): string;
 

package/src/targeted-fact-recall.ts

@@ -4,10 +4,20 @@ import {
   type EvidencePackItem,
 } from "./evidence-pack.js";
 import type { ExplicitCueRecallEngine } from "./explicit-cue-recall.js";
+import {
+  gatherAcrossReadSessions,
+  resolveLcmReadSessionIds,
+} from "./lcm-fallback-read.js";
 
 export interface TargetedFactRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
   sessionId?: string;
+  /**
+   * Ordered, read-authorized LCM read key set (primary overlay → project/root
+   * fallbacks). When present, evidence is gathered across EVERY key and merged
+   * under this section's budget (#1505 codex P2). Falls back to `sessionId`.
+   */
+  sessionIds?: readonly (string | undefined)[];
   query: string;
   maxChars: number;
   maxItemChars?: number;
@@ -43,10 +53,21 @@ export async function buildTargetedFactRecallSection(
     return "";
   }
 
-  const searchItems = await collectTargetedFactSearchItems(options);
-  const scannedItems = await collectTargetedFactScanItems(options);
+  // #1505 codex P2: gather candidates across the ordered LCM read key set
+  // (primary overlay → project/root fallbacks) and UNION them into the existing
+  // rank/dedupe/budget pass, so stronger project-fallback evidence is not masked
+  // by a weak primary-key hit. `gatherAcrossReadSessions` isolates a per-key read
+  // failure so a corrupt/locked fallback index can't discard the primary key's
+  // evidence; the single-key path collects exactly one search+scan pair and
+  // propagates a failure as before — byte-for-byte the pre-#1505 behavior.
+  const collected: EvidencePackItem[] = [];
+  await gatherAcrossReadSessions(resolveLcmReadSessionIds(options), async (sessionId) => {
+    const scoped = { ...options, sessionId };
+    collected.push(...(await collectTargetedFactSearchItems(scoped)));
+    collected.push(...(await collectTargetedFactScanItems(scoped)));
+  });
   const ranked = rankAndDedupeTargetedFactItems(
-    [...searchItems, ...scannedItems],
+    collected,
     options.query,
   ).slice(0, maxResults);