@remnic/core 10.0.51 → 10.0.53

package/dist/transfer/export-okf.js

@@ -4,24 +4,24 @@ import {
   exportOkfBundle,
   firstHeading,
   parseIncludeStatus
-} from "../chunk-2EXF6IIB.js";
+} from "../chunk-3632XJMR.js";
 import {
   OKF_EXPORT_VERSION
 } from "../chunk-I7TR2OCU.js";
 import "../chunk-D24OXEPB.js";
 import "../chunk-3UXOZBHV.js";
-import "../chunk-JIJAWTRK.js";
+import "../chunk-OCXDZJL4.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-DM5QZ3YU.js";
 import "../chunk-G6A3SGCE.js";
 import "../chunk-G6OFEGUR.js";
-import "../chunk-LXXIV7Y2.js";
-import "../chunk-JS44PBCM.js";
-import "../chunk-5CWH2LKL.js";
-import "../chunk-XKDQTDXN.js";
+import "../chunk-JEX2JL3U.js";
+import "../chunk-U2A56LLF.js";
+import "../chunk-DOJBV6WR.js";
+import "../chunk-PFUXPTBT.js";
 import "../chunk-CYEPCZN5.js";
-import "../chunk-XRFLR3XF.js";
-import "../chunk-7VO6E5UD.js";
+import "../chunk-DLZGSZVC.js";
+import "../chunk-OVZIYLBZ.js";
 import "../chunk-WNEVEMJ3.js";
 import "../chunk-EXYT52NR.js";
 import "../chunk-Y5NLBXPV.js";
@@ -57,8 +57,8 @@ import "../chunk-7CT3AI52.js";
 import "../chunk-G7D6GZ5J.js";
 import "../chunk-7VLBZKNB.js";
 import "../chunk-UUZ7KZAO.js";
-import "../chunk-AJJPXUE6.js";
-import "../chunk-G26YNEOC.js";
+import "../chunk-WBN66HPI.js";
+import "../chunk-NWA6IXR3.js";
 import "../chunk-VILPVT4S.js";
 import "../chunk-AF2XMJKD.js";
 import "../chunk-OR42ZI54.js";

package/dist/verified-recall.js

@@ -1,20 +1,20 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-ROAKLYOL.js";
+} from "./chunk-XHEKS4UN.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-JIJAWTRK.js";
+import "./chunk-OCXDZJL4.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-G6A3SGCE.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-LXXIV7Y2.js";
-import "./chunk-JS44PBCM.js";
-import "./chunk-5CWH2LKL.js";
-import "./chunk-XKDQTDXN.js";
+import "./chunk-JEX2JL3U.js";
+import "./chunk-U2A56LLF.js";
+import "./chunk-DOJBV6WR.js";
+import "./chunk-PFUXPTBT.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-XRFLR3XF.js";
-import "./chunk-7VO6E5UD.js";
+import "./chunk-DLZGSZVC.js";
+import "./chunk-OVZIYLBZ.js";
 import "./chunk-WNEVEMJ3.js";
 import "./chunk-EXYT52NR.js";
 import "./chunk-Y5NLBXPV.js";
@@ -50,8 +50,8 @@ import "./chunk-7CT3AI52.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-7VLBZKNB.js";
 import "./chunk-UUZ7KZAO.js";
-import "./chunk-AJJPXUE6.js";
-import "./chunk-G26YNEOC.js";
+import "./chunk-WBN66HPI.js";
+import "./chunk-NWA6IXR3.js";
 import "./chunk-VILPVT4S.js";
 import "./chunk-AF2XMJKD.js";
 import "./chunk-OR42ZI54.js";

package/dist/who-knows-cli.js

@@ -4,20 +4,20 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-TC55M5PO.js";
-import "./chunk-2ONKXEC7.js";
-import "./chunk-JIJAWTRK.js";
+} from "./chunk-YLN4ZQV4.js";
+import "./chunk-5LBBXI2A.js";
+import "./chunk-OCXDZJL4.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-G6A3SGCE.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-LXXIV7Y2.js";
-import "./chunk-JS44PBCM.js";
-import "./chunk-5CWH2LKL.js";
-import "./chunk-XKDQTDXN.js";
+import "./chunk-JEX2JL3U.js";
+import "./chunk-U2A56LLF.js";
+import "./chunk-DOJBV6WR.js";
+import "./chunk-PFUXPTBT.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-XRFLR3XF.js";
-import "./chunk-7VO6E5UD.js";
+import "./chunk-DLZGSZVC.js";
+import "./chunk-OVZIYLBZ.js";
 import "./chunk-WNEVEMJ3.js";
 import "./chunk-EXYT52NR.js";
 import "./chunk-Y5NLBXPV.js";
@@ -53,8 +53,8 @@ import "./chunk-7CT3AI52.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-7VLBZKNB.js";
 import "./chunk-UUZ7KZAO.js";
-import "./chunk-AJJPXUE6.js";
-import "./chunk-G26YNEOC.js";
+import "./chunk-WBN66HPI.js";
+import "./chunk-NWA6IXR3.js";
 import "./chunk-VILPVT4S.js";
 import "./chunk-AF2XMJKD.js";
 import "./chunk-OR42ZI54.js";

package/dist/who-knows.js

@@ -9,19 +9,19 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-2ONKXEC7.js";
-import "./chunk-JIJAWTRK.js";
+} from "./chunk-5LBBXI2A.js";
+import "./chunk-OCXDZJL4.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-G6A3SGCE.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-LXXIV7Y2.js";
-import "./chunk-JS44PBCM.js";
-import "./chunk-5CWH2LKL.js";
-import "./chunk-XKDQTDXN.js";
+import "./chunk-JEX2JL3U.js";
+import "./chunk-U2A56LLF.js";
+import "./chunk-DOJBV6WR.js";
+import "./chunk-PFUXPTBT.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-XRFLR3XF.js";
-import "./chunk-7VO6E5UD.js";
+import "./chunk-DLZGSZVC.js";
+import "./chunk-OVZIYLBZ.js";
 import "./chunk-WNEVEMJ3.js";
 import "./chunk-EXYT52NR.js";
 import "./chunk-Y5NLBXPV.js";
@@ -57,8 +57,8 @@ import "./chunk-7CT3AI52.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-7VLBZKNB.js";
 import "./chunk-UUZ7KZAO.js";
-import "./chunk-AJJPXUE6.js";
-import "./chunk-G26YNEOC.js";
+import "./chunk-WBN66HPI.js";
+import "./chunk-NWA6IXR3.js";
 import "./chunk-VILPVT4S.js";
 import "./chunk-AF2XMJKD.js";
 import "./chunk-OR42ZI54.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.51",
+  "version": "10.0.53",
   "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.51"
+    "@remnic/coding-graph": "^10.0.53"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/namespaces/search.test.ts

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
 import { NamespaceSearchRouter, normalizeQmdResultPath } from "./search.js";
+import { MaintenanceScheduler } from "../orchestration/maintenance.js";
+import type { NamespaceCatalog } from "./catalog.js";
 import type {
   SearchBackend,
   SearchBackendStatus,
@@ -977,3 +982,119 @@ test("normalizeQmdResultPath strips a real collection prefix but not a category
   // A non-category collection prefix on a plain hit is still stripped.
   assert.equal(normalizeQmdResultPath("openclaw-engram/facts/a.md", "openclaw-engram"), "facts/a.md");
 });
+
+/**
+ * Orama, LanceDB, Meilisearch and remote backends have no updateStrict or
+ * updateCollectionStrict; their plain update() is fail-open. They report whether
+ * an update ran through updateCompleted() (issue #3286).
+ */
+class NonQmdBackend extends FakeBackend {
+  completedCalls = 0;
+
+  constructor(completed: boolean) {
+    super(false);
+    // Instance properties shadow the QMD-only strict methods FakeBackend defines.
+    Object.defineProperty(this, "updateStrict", { value: undefined });
+    Object.defineProperty(this, "updateCollectionStrict", { value: undefined });
+    Object.defineProperty(this, "updateCompleted", {
+      value: async (): Promise<boolean> => {
+        this.completedCalls += 1;
+        return completed;
+      },
+    });
+  }
+}
+
+function nonQmdRouter(completed: boolean, created: NonQmdBackend[], cfg: PluginConfig = config()): NamespaceSearchRouter {
+  return new NamespaceSearchRouter(
+    cfg,
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new NonQmdBackend(completed);
+      created.push(backend);
+      return backend;
+    },
+  );
+}
+
+test("strict updateNamespaces fails for a non-QMD backend whose refresh did not complete", async () => {
+  const created: NonQmdBackend[] = [];
+  const router = nonQmdRouter(false, created);
+
+  await assert.rejects(
+    router.updateNamespaces(["main"], undefined, { strict: true }),
+    /did not complete/,
+  );
+  assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 0, "the fail-open update() is not what strict runs");
+});
+
+test("strict updateNamespaces succeeds for a non-QMD backend whose refresh completed", async () => {
+  const created: NonQmdBackend[] = [];
+  const router = nonQmdRouter(true, created);
+
+  assert.equal(await router.updateNamespaces(["main", "shared"], undefined, { strict: true }), 2);
+  assert.equal(created.reduce((sum, backend) => sum + backend.completedCalls, 0), 2);
+  assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 0);
+});
+
+test("non-strict updateNamespaces keeps the fail-open update() for non-QMD backends", async () => {
+  const created: NonQmdBackend[] = [];
+  const router = nonQmdRouter(false, created);
+
+  assert.equal(await router.updateNamespaces(["main"]), 1);
+  assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 1);
+  assert.equal(created.reduce((sum, backend) => sum + backend.completedCalls, 0), 0);
+});
+
+test("strict updateNamespaces falls back to update() for a backend with no strict or completed variant", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false);
+      Object.defineProperty(backend, "updateCollectionStrict", { value: undefined });
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  assert.equal(await router.updateNamespaces(["main"], undefined, { strict: true }), 1);
+  assert.equal(created.reduce((sum, backend) => sum + backend.updates, 0), 1);
+});
+
+test("namespace-mode maintenance is served only when a non-QMD backend's refresh completed", async () => {
+  for (const completed of [true, false]) {
+    const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-3286-ns-completion-"));
+    const cfg: PluginConfig = {
+      ...config(),
+      memoryDir,
+      sharedNamespace: "shared",
+      namespacePolicies: [],
+      maintenanceNamespaceLockStaleMs: 100,
+      qmdMaintenanceEnabled: true,
+      qmdMaintenanceDebounceMs: 60_000,
+      qmdAutoEmbedEnabled: false,
+    };
+    const created: NonQmdBackend[] = [];
+    const router = nonQmdRouter(completed, created, cfg);
+    const catalog: NamespaceCatalog = Object.assign(Object.create(null), {
+      enabled: true,
+      async listNamespaces() {
+        return [{ namespace: "main" }];
+      },
+      async markMaintenance() {},
+    });
+    const qmd: SearchBackend = Object.assign(Object.create(null), { isAvailable: () => true });
+    const scheduler = new MaintenanceScheduler({ config: cfg, getQmd: () => qmd, namespaceSearchRouter: router, namespaceCatalog: catalog });
+    try {
+      const served = scheduler.requestQmdMaintenanceCompletion();
+      await scheduler.runQmdMaintenance();
+      assert.equal(await served, completed, completed ? "a completed refresh serves the request" : "an incomplete refresh must keep the marker owed");
+      assert.ok(created.some((backend) => backend.completedCalls > 0), "maintenance asked the backend whether it completed");
+    } finally {
+      await scheduler.dispose();
+      await rm(memoryDir, { recursive: true, force: true });
+    }
+  }
+});

package/src/namespaces/search.ts

@@ -596,6 +596,14 @@ async function updateBackendRecord(
       await record.backend.updateCollectionStrict(record.collection, execution);
       return;
     }
+    // Backends with no strict variant (Orama, LanceDB, Meilisearch, remote) have a fail-open
+    // update(): it resolves when it returned early or failed. Their updateCompleted() says
+    // whether the refresh ran, so strict callers get a failure instead of a fake success.
+    const completed = await record.backend.updateCompleted?.(execution);
+    if (completed !== undefined) {
+      if (!completed) throw new Error("search backend update did not complete");
+      return;
+    }
   }
   await record.backend.update(execution);
 }

package/src/orchestration/extraction-persist-deps.ts

@@ -106,4 +106,7 @@ export interface ExtractionPersistDeps {
    */
   invalidateGraphEdgeCache?: (storage: StorageManager) => void;
   updateTemporalTagIndexes: (storage: StorageManager, persistedIds: string[]) => Promise<void>;
+  /** Schedule QMD reindex after partial durable writes that throw out of persist. */
+  requestQmdMaintenance: () => void;
+
 }

package/src/orchestration/extraction-persist-promotion.ts

@@ -23,6 +23,11 @@ import {
 import type { MemoryFile, PluginConfig } from "../types.js";
 import type { ResolvedScopeProfilePlan } from "../namespaces/scope-profiles.js";
 import { readDurableSemanticFingerprint, readPromotionReceiptStatus, type MergedTargetPromotionPayload } from "./semantic-merge-promotion-payload.js";
+import type { BehaviorSignalEvent, ExtractionResult } from "../types.js";
+import type { HarmonicConstructionInput } from "../harmonic-construction.js";
+import { dedupeBehaviorSignalsByMemoryAndHash } from "../behavior-signals.js";
+import { persistConstructedHarmonicRecords } from "./harmonic-construction-persist.js";
+
 
 export const confidenceTierOrder = [
   "explicit",
@@ -116,27 +121,110 @@ export async function readActiveMemoriesBothTiers(
   return coldMems.length === 0 ? hotMems : [...hotMems, ...coldMems];
 }
 
+
 /**
- * PR #2016: after `writeSealedMemory` has made a fact `.md` durable with its
- * fact-hash flush deferred (#1909 batching), a throw in the fallible post-write
- * work (contradiction resolve, indexing, shared promotion, artifact write)
- * would strand the deferred parent hash — the shared fact-hash index on disk
- * would be missing the parent until the next corpus rebuild, letting a peer
- * re-extract a duplicate. Flush the batch save before the error propagates so
- * the durable-hash invariant holds on every path. No-op when dedup is off
- * (`deferred=false` → the write already flushed and the batch saver is a no-op).
- * Best-effort: a flush failure is logged and never masks the original error.
+ * Batch-end finalization for facts already durable in this persist pass:
+ * content-hash save, behavior signals, harmonic construction, temporal/tag
+ * indexes. Shared by the success tail and every rethrow path so a partial
+ * batch (e.g. fact wrote, entity failed) still lands deferred side effects
+ * before the original error propagates (#3228 / #3231). Best-effort: each
+ * step logs and never masks `originalError` at the call site.
+ *
+ * `scheduleQmd` is failure-only. Success still schedules QMD from
+ * extraction-run after persist returns, so success passes false.
  */
-export async function flushDeferredFactHashOnFailure(
-  saveContentHashIndexes: () => Promise<void>,
-  deferred: boolean,
-): Promise<void> {
-  if (!deferred) return;
-  await saveContentHashIndexes().catch((err) =>
-    log.warn(`content-hash flush after post-write failure failed: ${err}`),
+export async function finalizeExtractionCommittedWrites(options: {
+  saveContentHashIndexes: () => Promise<void>;
+  behaviorSignalsByStorage: Iterable<{
+    storage: StorageManager;
+    events: BehaviorSignalEvent[];
+  }>;
+  harmonic?: {
+    enabled: boolean;
+    entries: Iterable<{
+      storage: StorageManager;
+      facts: HarmonicConstructionInput["persistedFacts"];
+    }>;
+    baseStorageDir: string;
+    abstractionNodeStoreDir?: string;
+    sessionKey?: string;
+    validAt?: string;
+    episodeTitle?: string;
+    anchorsEnabled: boolean;
+    entityMentions: ExtractionResult["entities"];
+  };
+  updateTemporalTagIndexes: (
+    storage: StorageManager,
+    persistedIds: string[],
+  ) => Promise<void>;
+  fallbackStorage: StorageManager;
+  persistedIdsByStorage: Map<string, { storage: StorageManager; ids: string[] }>;
+  requestQmdMaintenance?: () => void;
+  scheduleQmd: boolean;
+}): Promise<void> {
+  await options.saveContentHashIndexes().catch((err) => {
+    log.warn(`content-hash index save failed: ${err}`);
+  });
+
+  // Snapshot once — Map iterators are single-pass.
+  const behaviorEntries = [...options.behaviorSignalsByStorage];
+  for (const { storage: targetStorage, events } of behaviorEntries) {
+    const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
+    if (dedupedSignals.length === 0) continue;
+    await targetStorage
+      .appendBehaviorSignals(dedupedSignals)
+      .catch((err) =>
+        log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`),
+      );
+  }
+
+  const harmonic = options.harmonic;
+  let harmonicEntryCount = 0;
+  if (harmonic?.enabled) {
+    const entries = [...harmonic.entries];
+    harmonicEntryCount = entries.length;
+    if (entries.length > 0) {
+      await persistConstructedHarmonicRecords({
+        entries,
+        baseStorageDir: harmonic.baseStorageDir,
+        abstractionNodeStoreDir: harmonic.abstractionNodeStoreDir,
+        sessionKey: harmonic.sessionKey,
+        validAt: harmonic.validAt,
+        episodeTitle: harmonic.episodeTitle,
+        anchorsEnabled: harmonic.anchorsEnabled,
+        entityMentions: harmonic.entityMentions,
+      });
+    }
+  }
+
+  void (async () => {
+    if (options.persistedIdsByStorage.size === 0) {
+      await options.updateTemporalTagIndexes(options.fallbackStorage, []);
+      return;
+    }
+    for (const entry of options.persistedIdsByStorage.values()) {
+      await options.updateTemporalTagIndexes(entry.storage, entry.ids);
+    }
+  })().catch((err) =>
+    log.debug(`temporal-index update error (non-fatal): ${err}`),
   );
+
+  if (!options.scheduleQmd || !options.requestQmdMaintenance) return;
+  const hasCommitted =
+    options.persistedIdsByStorage.size > 0 ||
+    behaviorEntries.length > 0 ||
+    harmonicEntryCount > 0;
+  if (!hasCommitted) return;
+  try {
+    options.requestQmdMaintenance();
+  } catch (err) {
+    log.warn(
+      `QMD maintenance schedule after partial persist failed (non-fatal): ${err}`,
+    );
+  }
 }
 
+
 /**
  * Merged-target promotion scope gate (PR #2771 finding A). A committed
  * record stamped `toolScoped: true` must keep its promoted copy withheld