@remnic/core 10.0.53 → 10.0.54

package/dist/index.js

@@ -181,7 +181,7 @@ import {
   writeManifest,
   writeMeetingEpisodeMemory,
   writeTimelineState
-} from "./chunk-CA6X37OB.js";
+} from "./chunk-2GU6XS4L.js";
 import {
   WEARABLE_SOURCE_PREFIX,
   buildExtractionTurns,
@@ -247,7 +247,7 @@ import {
   timelineAnalysisClientsFromConfig,
   timelineCorrectionDatabasePath,
   timelineDayPath
-} from "./chunk-H4DWSOBQ.js";
+} from "./chunk-PVG7TCUG.js";
 import "./chunk-I74SUMNI.js";
 import {
   PEERS_DIR_NAME,

package/dist/orchestration/maintenance.d.ts

@@ -130,7 +130,7 @@ export declare class MaintenanceScheduler {
      * unavailable or maintenance off), the pass failed, or dispose() abandoned it,
      * so a caller that must not lose the re-index keeps owing it.
      */
-    requestQmdMaintenanceCompletion(): Promise<boolean>;
+    requestQmdMaintenanceCompletion(namespace?: string): Promise<boolean>;
     /**
      * Public entrypoint for tool-driven QMD maintenance requests.
      * Routes through existing debounced/singleflight maintenance controls.

package/dist/orchestration/maintenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"maintenance.d.ts","sourceRoot":"","sources":["../../src/orchestration/maintenance.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"maintenance.d.ts","sourceRoot":"","sources":["../../src/orchestration/maintenance.ts"],"names":[],"mappings":"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"}

package/dist/orchestration/maintenance.js

@@ -1,6 +1,6 @@
 import {
   MaintenanceScheduler
-} from "../chunk-H4DWSOBQ.js";
+} from "../chunk-PVG7TCUG.js";
 import "../chunk-666A3MOW.js";
 import "../chunk-B43P3DTC.js";
 import "../chunk-6CDNOREO.js";

package/dist/orchestration/qmd-maintenance-completion.d.ts

@@ -7,13 +7,18 @@
  */
 export declare class QmdMaintenanceCompletion {
     private waiters;
-    /** Resolves true when a pass that started after this call completed successfully. */
-    wait(): Promise<boolean>;
+    /**
+     * Resolves true when a pass that started after this call completed successfully. With a
+     * `namespace` the request is served as soon as a pass ran that namespace, whatever else it skipped.
+     */
+    wait(namespace?: string): Promise<boolean>;
     /**
      * A pass is starting: take every waiter it will serve and return their settle function.
-     * `defer` keeps them waiting for a later pass (a pass that covered only part of the selection).
+     * `ran` lists the namespaces a namespace-aware pass ran (absent when namespaces are disabled:
+     * one corpus is maintained and the pass outcome applies to every waiter); `defer` keeps the
+     * waiters it did not serve waiting for a later pass (a pass that covered only part of the selection).
      */
-    claim(): (served: boolean, defer?: boolean) => void;
+    claim(): (served: boolean, defer?: boolean, ran?: ReadonlySet<string>) => void;
     /** The scheduler stopped: nothing will serve the waiters. */
     abandon(): void;
 }

package/dist/orchestration/qmd-maintenance-completion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qmd-maintenance-completion.d.ts","sourceRoot":"","sources":["../../src/orchestration/qmd-maintenance-completion.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,OAAO,CAAwC;IAEvD,qFAAqF;IACrF,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAIxB;;;OAGG;IACH,KAAK,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI;IAQnD,6DAA6D;IAC7D,OAAO,IAAI,IAAI;CAGhB"}
+{"version":3,"file":"qmd-maintenance-completion.d.ts","sourceRoot":"","sources":["../../src/orchestration/qmd-maintenance-completion.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,OAAO,CAAyE;IAExF;;;OAGG;IACH,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1C;;;;;OAKG;IACH,KAAK,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,IAAI;IAe9E,6DAA6D;IAC7D,OAAO,IAAI,IAAI;CAGhB"}

package/dist/orchestrator.js

@@ -4,13 +4,13 @@ import {
   graphPathRelativeToStorage,
   mergeGraphExpandedResults,
   qmdStartupCollectionChecksWithTimeout
-} from "./chunk-CA6X37OB.js";
+} from "./chunk-2GU6XS4L.js";
 import "./chunk-YDIOMDBW.js";
 import "./chunk-HM3ZTDAX.js";
 import {
   formatCompressionGuidelinesForRecall
 } from "./chunk-5PHOU5QI.js";
-import "./chunk-H4DWSOBQ.js";
+import "./chunk-PVG7TCUG.js";
 import "./chunk-I74SUMNI.js";
 import "./chunk-ILNPU5W5.js";
 import "./chunk-VZAKYDMJ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.53",
+  "version": "10.0.54",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3346,7 +3346,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^10.0.53"
+    "@remnic/coding-graph": "^10.0.54"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/orchestration/maintenance.test.ts

@@ -3077,6 +3077,66 @@ test("requestQmdMaintenanceCompletion resolves false when dispose() clears the a
   assert.equal(await served, false, "a destroy inside the debounce window must leave the re-index owed");
 });
 
+test("requestQmdMaintenanceCompletion over namespaces: a scoped request is served only when its own namespace ran, an unscoped one by the pass outcome", async () => {
+    const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-qmd-completion-permanent-"));
+  const config = fixtureConfig({
+    memoryDir,
+    namespacesEnabled: true,
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+    maintenanceNamespaceLockStaleMs: 100,
+    qmdAutoEmbedEnabled: false,
+  });
+  const catalog: NamespaceCatalog = Object.assign(Object.create(null), {
+    enabled: true,
+    async listNamespaces() {
+      return [{ namespace: "feature-x", kind: "branch" }];
+    },
+    async markMaintenance() {},
+  });
+  const router: NamespaceSearchRouter = Object.assign(Object.create(null), {
+    async updateNamespacesDetailed(ns: string[]): Promise<NamespaceUpdateResult> {
+      return { backendCount: ns.length, eligibleNamespaces: ns };
+    },
+    async embedNamespaces(): Promise<void> {},
+  });
+  const scheduler = buildScheduler({ config, catalog, router });
+  try {
+    // feature-x is skipped as branch_disabled (never maintained): the pass is served for the
+    // namespaces that ran, but nothing re-indexed feature-x.
+    const unscoped = scheduler.requestQmdMaintenanceCompletion();
+    const forBranch = scheduler.requestQmdMaintenanceCompletion("feature-x");
+    const forDefault = scheduler.requestQmdMaintenanceCompletion("default");
+    await scheduler.runQmdMaintenance();
+    assert.equal(await unscoped, true);
+    assert.equal(await forDefault, true, "default ran");
+    assert.equal(await forBranch, false, "feature-x never ran, so its re-index is still owed");
+  } finally {
+    await scheduler.dispose();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("requestQmdMaintenanceCompletion serves a scoped request when namespaces are disabled and the update ran", async () => {
+  // Without namespaces there is one corpus; the pass has no per-namespace statuses to match.
+  const scheduler = completionScheduler({});
+  try {
+    const served = scheduler.requestQmdMaintenanceCompletion("default");
+    await scheduler.runQmdMaintenance();
+    assert.equal(await served, true);
+  } finally {
+    await scheduler.dispose();
+  }
+});
+
+test("requestQmdMaintenanceCompletion resolves false for a namespace-scoped request when dispose() abandons it", async () => {
+  const scheduler = completionScheduler({});
+  const served = scheduler.requestQmdMaintenanceCompletion("default");
+  await scheduler.dispose();
+  assert.equal(await served, false, "no pass ran the namespace, so the re-index stays owed");
+});
+
 test("requestQmdMaintenanceCompletion resolves false without arming anything when QMD is unavailable or disposed", async () => {
   const unavailable = completionScheduler({ available: false });
   try {
@@ -3300,6 +3360,43 @@ test("requestQmdMaintenanceCompletion over namespaces: true only when a namespac
   }
 });
 
+test("requestQmdMaintenanceCompletion over namespaces: a failed catalog read leaves the request owed (#3289)", async () => {
+  // The configured namespaces still run, but cataloged (dynamic) namespaces were never discovered,
+  // so the re-index is incomplete and the migration must keep its marker.
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-qmd-completion-catalog-"));
+  const config = fixtureConfig({
+    memoryDir,
+    namespacesEnabled: true,
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+    maintenanceNamespaceLockStaleMs: 100,
+    qmdAutoEmbedEnabled: false,
+  });
+  const catalog: NamespaceCatalog = Object.assign(Object.create(null), {
+    enabled: true,
+    async listNamespaces(): Promise<never> {
+      throw new Error("catalog unavailable");
+    },
+    async markMaintenance() {},
+  });
+  const router: NamespaceSearchRouter = Object.assign(Object.create(null), {
+    async updateNamespacesDetailed(ns: string[]): Promise<NamespaceUpdateResult> {
+      return { backendCount: ns.length, eligibleNamespaces: ns };
+    },
+    async embedNamespaces(): Promise<void> {},
+  });
+  const scheduler = buildScheduler({ config, catalog, router });
+  try {
+    const served = scheduler.requestQmdMaintenanceCompletion();
+    await scheduler.runQmdMaintenance();
+    assert.equal(await served, false);
+  } finally {
+    await scheduler.dispose();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("requestQmdMaintenanceCompletion over namespaces: a permanent skip (branch_disabled) does not block serving", async () => {
   // A cataloged branch namespace is never maintained by default; that is a standing configuration,
   // not an unfinished pass, so the ran namespace must still serve the request.
@@ -3424,3 +3521,45 @@ test("requestQmdMaintenanceCompletion over namespaces: a pass that adds no cover
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("requestQmdMaintenanceCompletion over namespaces: a request scoped to a namespace is served once that namespace ran, however the budget ranks the rest", async () => {
+      const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-qmd-completion-budget-"));
+  const config = fixtureConfig({
+    memoryDir,
+    namespacesEnabled: true,
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+    maintenanceNamespaceLockStaleMs: 100,
+    qmdAutoEmbedEnabled: false,
+    maintenanceMaxNamespacesPerCycle: 1,
+  });
+  const catalog: NamespaceCatalog = Object.assign(Object.create(null), {
+    enabled: true,
+    async listNamespaces() {
+      return [{ namespace: "default" }];
+    },
+    async markMaintenance() {},
+  });
+  const router: NamespaceSearchRouter = Object.assign(Object.create(null), {
+    async updateNamespacesDetailed(ns: string[]): Promise<NamespaceUpdateResult> {
+      return { backendCount: ns.length, eligibleNamespaces: ns };
+    },
+    async embedNamespaces(): Promise<void> {},
+  });
+  const scheduler = buildScheduler({ config, catalog, router });
+  try {
+    // Budget 1 with default and shared: default always ranks first and shared is never selected.
+    const forDefault = scheduler.requestQmdMaintenanceCompletion("default");
+    const forShared = scheduler.requestQmdMaintenanceCompletion("shared");
+    await scheduler.runQmdMaintenance();
+    assert.equal(await forDefault, true, "the namespace the migration rewrote ran this pass");
+    // shared starved: the pass added coverage once, then a pass adds none and the request ends unserved.
+    await scheduler.runQmdMaintenance();
+    assert.equal(await forShared, false);
+    assert.equal(scheduler.isQmdMaintenancePending(), false);
+  } finally {
+    await scheduler.dispose();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/orchestration/maintenance.ts

@@ -499,9 +499,9 @@ export class MaintenanceScheduler {
    * unavailable or maintenance off), the pass failed, or dispose() abandoned it,
    * so a caller that must not lose the re-index keeps owing it.
    */
-  requestQmdMaintenanceCompletion(): Promise<boolean> {
+  requestQmdMaintenanceCompletion(namespace?: string): Promise<boolean> {
     if (this.disposed || !this.requestQmdMaintenance()) return Promise.resolve(false);
-    return this.qmdCompletion.wait();
+    return this.qmdCompletion.wait(namespace);
   }
 
   /**
@@ -546,6 +546,8 @@ export class MaintenanceScheduler {
     const settle = this.qmdCompletion.claim();
     let served = false;
     let deferred = false;
+    // Set only by the namespace-aware branch; absent means the pass outcome applies to every waiter.
+    let ranNamespaces: Set<string> | undefined;
 
     try {
       if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
@@ -626,9 +628,13 @@ export class MaintenanceScheduler {
         // request, so a deployment with more namespaces than the cycle budget still converges.
         // Permanent skip reasons describe namespaces this deployment never re-indexes.
         const covered = this.qmdCoveredNamespaces;
+        const ran = new Set<string>();
+        ranNamespaces = ran;
         const before = covered.size;
         for (const status of summary.statuses) {
-          if (status.state === "ran") covered.add(status.namespace);
+          if (status.state !== "ran") continue;
+          covered.add(status.namespace);
+          ran.add(status.namespace);
         }
         const uncovered = summary.statuses.some(
           (status) =>
@@ -636,10 +642,13 @@ export class MaintenanceScheduler {
             (status.reason === "budget_exhausted" || status.reason === "lock_held") &&
             !covered.has(status.namespace),
         );
-        served = summary.ran > 0 && summary.failed === 0 && !uncovered;
-        // Partial progress keeps the waiters for another pass; no progress (or a failure) ends the
-        // request unserved so a stuck namespace cannot re-arm passes forever.
-        deferred = !served && summary.failed === 0 && covered.size > before && !this.disposed;
+        // The batch runner drops namespace "*" skips from the statuses, so a failed catalog read
+        // is only visible on the plan: cataloged namespaces were never discovered this pass.
+        const catalogReadFailed = plan.skipped.some((skip) => skip.reason === "catalog_read_failed");
+        served = summary.ran > 0 && summary.failed === 0 && !uncovered && !catalogReadFailed;
+        // Partial progress keeps the waiters for another pass; no progress, a failure or a failed
+        // catalog read ends the request unserved so the next start asks again.
+        deferred = !served && summary.failed === 0 && !catalogReadFailed && covered.size > before && !this.disposed;
       } else {
         const qmd = this.deps.getQmd();
         // Plain update() is fail-open on every backend: it resolves when the min-interval gate,
@@ -678,7 +687,7 @@ export class MaintenanceScheduler {
       // backoff) does not advance lastUpdateRanAtMs, so it leaves caches warm
       // (#1904, Codex/Cursor).
     } finally {
-      settle(served, deferred);
+      settle(served, deferred, ranNamespaces);
       if (!deferred) this.qmdCoveredNamespaces.clear();
       this.qmdMaintenanceInFlight = false;
       if (deferred) this.qmdMaintenancePending = true;

package/src/orchestration/qmd-maintenance-completion.ts

@@ -6,22 +6,34 @@
  * settles them with the pass outcome, and abandons them on dispose().
  */
 export class QmdMaintenanceCompletion {
-  private waiters: Array<(served: boolean) => void> = [];
+  private waiters: Array<{ resolve: (served: boolean) => void; namespace?: string }> = [];
 
-  /** Resolves true when a pass that started after this call completed successfully. */
-  wait(): Promise<boolean> {
-    return new Promise((resolve) => this.waiters.push(resolve));
+  /**
+   * Resolves true when a pass that started after this call completed successfully. With a
+   * `namespace` the request is served as soon as a pass ran that namespace, whatever else it skipped.
+   */
+  wait(namespace?: string): Promise<boolean> {
+    return new Promise((resolve) => this.waiters.push({ resolve, namespace }));
   }
 
   /**
    * A pass is starting: take every waiter it will serve and return their settle function.
-   * `defer` keeps them waiting for a later pass (a pass that covered only part of the selection).
+   * `ran` lists the namespaces a namespace-aware pass ran (absent when namespaces are disabled:
+   * one corpus is maintained and the pass outcome applies to every waiter); `defer` keeps the
+   * waiters it did not serve waiting for a later pass (a pass that covered only part of the selection).
    */
-  claim(): (served: boolean, defer?: boolean) => void {
+  claim(): (served: boolean, defer?: boolean, ran?: ReadonlySet<string>) => void {
     const claimed = this.waiters.splice(0);
-    return (served, defer = false) => {
-      if (defer) this.waiters.unshift(...claimed);
-      else claimed.forEach((resolve) => resolve(served));
+    return (served, defer = false, ran) => {
+      const requeue: typeof claimed = [];
+      for (const waiter of claimed) {
+        // A scoped waiter needs its own namespace to have run; the pass outcome alone is not enough.
+        const own = waiter.namespace !== undefined && ran !== undefined ? ran.has(waiter.namespace) : served;
+        if (own) waiter.resolve(true);
+        else if (defer) requeue.push(waiter);
+        else waiter.resolve(false);
+      }
+      this.waiters.unshift(...requeue);
     };
   }
 

package/src/orchestrator.ts

@@ -1515,7 +1515,7 @@ export class Orchestrator {
       storage.onEntityMigrationComplete = () => {
         if (!this.acceptingEntityMigrationMaintenance) return false;
         // Settles once a QMD pass covering this request ran; the migration keeps its pending marker until then.
-        const served = this.maintenanceScheduler.requestQmdMaintenanceCompletion();
+        const served = this.maintenanceScheduler.requestQmdMaintenanceCompletion(namespace);
         // Same side effects as before: projection rebuild and ledger-compaction checks, independent of QMD.
         this.requestQmdMaintenance();
         return served;