@remnic/core 9.7.11 → 9.7.13

package/dist/{chunk-W6R43NLA.js → chunk-KQMKF4G2.js}

@@ -51,12 +51,12 @@ import {
 } from "./chunk-AJVLDJU6.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-SBFDL2EQ.js";
+} from "./chunk-UTZW3X2R.js";
 import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-MXRMNKSY.js";
+} from "./chunk-I3GKTDM2.js";
 import {
   rebuildObservations
 } from "./chunk-LZZNTPLR.js";
@@ -77,7 +77,7 @@ import {
 } from "./chunk-GQL52GQ5.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-YLTG6BO4.js";
+} from "./chunk-OIFZII6J.js";
 import {
   getUtilityLearningStatus,
   learnUtilityPromotionWeights
@@ -91,10 +91,10 @@ import {
 } from "./chunk-DBRYEIGY.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-WUDBMLC6.js";
+} from "./chunk-ZC3HG22I.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-EQF5763Z.js";
+} from "./chunk-IQULRIZM.js";
 import {
   resolveAgentAccessAuthToken
 } from "./chunk-TGQ2NTWH.js";
@@ -102,7 +102,7 @@ import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-DJCKXI4M.js";
+} from "./chunk-NVXQTRBL.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -113,7 +113,7 @@ import {
 } from "./chunk-5EZXHU36.js";
 import {
   parseXrayCliOptions
-} from "./chunk-YXOAQAH2.js";
+} from "./chunk-CLFY35ED.js";
 import {
   formatNamespaceMaintenanceHealthText,
   runBenchmarkRecall,
@@ -122,12 +122,12 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-XF4KOVDK.js";
+} from "./chunk-PA6DMYEK.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-VCEH5UYS.js";
+} from "./chunk-ZRXSHGXT.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -207,13 +207,13 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   parseConfig
-} from "./chunk-7LMEY5KZ.js";
+} from "./chunk-6N7R7TR2.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-OADWQ5CR.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-QHT4W3RU.js";
+} from "./chunk-2V5QI6NQ.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -226,10 +226,10 @@ import {
   createProductionChatLlmAdapter,
   loadChatSession,
   sessionBelongsToPrincipal
-} from "./chunk-GHVJASQ4.js";
+} from "./chunk-OCY3CRPG.js";
 import {
   EngramAccessService
-} from "./chunk-3OQ4IZJN.js";
+} from "./chunk-QPZCAVDC.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -246,13 +246,13 @@ import {
   parseRecallExplainFormat,
   renderRecallExplain,
   renderXray
-} from "./chunk-OVMS3DCB.js";
+} from "./chunk-675YU5IK.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-L4H6MQ7I.js";
+} from "./chunk-2RSL6YRA.js";
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-6HMYUWXR.js";
@@ -268,7 +268,7 @@ import {
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-3ZVFLMFQ.js";
+} from "./chunk-G5PVJJRA.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-OKUEZOGW.js";
@@ -7617,4 +7617,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-W6R43NLA.js.map
+//# sourceMappingURL=chunk-KQMKF4G2.js.map

package/dist/{chunk-DJCKXI4M.js → chunk-NVXQTRBL.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-LMDRGRJ2.js";
 import {
   parseConfig
-} from "./chunk-7LMEY5KZ.js";
+} from "./chunk-6N7R7TR2.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-DJCKXI4M.js.map
+//# sourceMappingURL=chunk-NVXQTRBL.js.map

package/dist/{chunk-GHVJASQ4.js → chunk-OCY3CRPG.js}

@@ -18,7 +18,7 @@ import {
 } from "./chunk-T4WDJPEZ.js";
 import {
   getOperation
-} from "./chunk-6LM6PPDX.js";
+} from "./chunk-CE3GMHT4.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -27,7 +27,7 @@ import {
 } from "./chunk-D7FOKIY5.js";
 import {
   EngramAccessInputError
-} from "./chunk-3OQ4IZJN.js";
+} from "./chunk-QPZCAVDC.js";
 import {
   readEnvVar
 } from "./chunk-JUC24CTX.js";
@@ -3789,4 +3789,4 @@ export {
   MCP_SUPPORTED_PROTOCOL_VERSIONS,
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-GHVJASQ4.js.map
+//# sourceMappingURL=chunk-OCY3CRPG.js.map

package/dist/{chunk-YLTG6BO4.js → chunk-OIFZII6J.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-ZBJMUXZH.js";
 import {
   StorageManager
-} from "./chunk-KXLRMM35.js";
+} from "./chunk-TRH533CA.js";
 import {
   getCachedEpisodeMap,
   setCachedEpisodeMap
@@ -109,4 +109,4 @@ export {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
 };
-//# sourceMappingURL=chunk-YLTG6BO4.js.map
+//# sourceMappingURL=chunk-OIFZII6J.js.map

package/dist/{chunk-XF4KOVDK.js → chunk-PA6DMYEK.js}

@@ -3,10 +3,10 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-JZM5QUTE.js";
+} from "./chunk-TMGK6YE7.js";
 import {
   listNamespaces
-} from "./chunk-VCEH5UYS.js";
+} from "./chunk-ZRXSHGXT.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -38,17 +38,17 @@ import {
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-7LMEY5KZ.js";
+} from "./chunk-6N7R7TR2.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-L4H6MQ7I.js";
+} from "./chunk-2RSL6YRA.js";
 import {
   analyzeGraphHealth
 } from "./chunk-OBMR4VIX.js";
 import {
   StorageManager
-} from "./chunk-KXLRMM35.js";
+} from "./chunk-TRH533CA.js";
 import {
   probeProjectionHealth
 } from "./chunk-RHOZ5LLO.js";
@@ -1671,4 +1671,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-XF4KOVDK.js.map
+//# sourceMappingURL=chunk-PA6DMYEK.js.map

package/dist/{chunk-3OQ4IZJN.js → chunk-QPZCAVDC.js}

@@ -34,10 +34,10 @@ import {
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-OVMS3DCB.js";
+} from "./chunk-675YU5IK.js";
 import {
   estimateRecallTokens
-} from "./chunk-HQ7QZJM5.js";
+} from "./chunk-D4TLWDYR.js";
 import {
   combineNamespaces,
   defaultGitInvoker,
@@ -64,7 +64,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-L4H6MQ7I.js";
+} from "./chunk-2RSL6YRA.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-ICP53SKG.js";
@@ -111,11 +111,11 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-UTDA43TB.js";
+} from "./chunk-TWGGNUWJ.js";
 import {
   parseEntityFile,
   selfDeps
-} from "./chunk-KXLRMM35.js";
+} from "./chunk-TRH533CA.js";
 import {
   serializeMutations
 } from "./chunk-LTJAMRGI.js";
@@ -128,7 +128,7 @@ import {
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-3ZVFLMFQ.js";
+} from "./chunk-G5PVJJRA.js";
 import {
   inferMemoryStatus,
   toMemoryPathRel
@@ -11250,4 +11250,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-3OQ4IZJN.js.map
+//# sourceMappingURL=chunk-QPZCAVDC.js.map

package/dist/{chunk-DLWYAN6A.js → chunk-T6U7HDIY.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-5CJVLG3H.js";
 import {
   StorageManager
-} from "./chunk-KXLRMM35.js";
+} from "./chunk-TRH533CA.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1282,4 +1282,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-DLWYAN6A.js.map
+//# sourceMappingURL=chunk-T6U7HDIY.js.map

package/dist/{chunk-JZM5QUTE.js → chunk-TMGK6YE7.js}

@@ -1,7 +1,7 @@
 import {
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
-} from "./chunk-U4KHQTJ6.js";
+} from "./chunk-2AL7N3BH.js";
 import {
   getConfiguredNamespaces
 } from "./chunk-7PND4PUC.js";
@@ -41,6 +41,7 @@ import {
   stat,
   writeFile
 } from "fs/promises";
+import { StringDecoder } from "string_decoder";
 var NAMESPACE_KINDS = [
   "default",
   "self",
@@ -241,6 +242,9 @@ var NamespaceCatalog = class {
     this.catalogPath = path.join(this.stateDir, CATALOG_FILE);
     this.rebuildLockPath = path.join(this.stateDir, REBUILD_LOCK_FILE);
     this.defaultNamespaceIdentity = normalizeNamespaceIdentity(config.defaultNamespace);
+    this.compactBytesLimit = config.namespacesCatalogCompactBytes ?? 16 * 1024 * 1024;
+    this.readCoalesceMs = config.namespacesCatalogReadTouchCoalesceMs ?? 6e4;
+    this.writeCoalesceMs = config.namespacesCatalogWriteTouchCoalesceMs ?? 1e3;
   }
   config;
   memoryDir;
@@ -299,6 +303,26 @@ var NamespaceCatalog = class {
   // misclassified, dropped at read time, or given the wrong storage root. Compare
   // against this normalized form everywhere instead.
   defaultNamespaceIdentity;
+  // Issue #1903 — touch-path performance knobs, resolved with the documented
+  // defaults when an externally-built PluginConfig omits them (so a partial
+  // config object still yields the production behavior). `0` is a real disable
+  // switch for each and is preserved by `??` (0 is not null/undefined).
+  compactBytesLimit;
+  readCoalesceMs;
+  writeCoalesceMs;
+  // Size after the most recent auto-compaction (0 = none yet). Hysteresis for
+  // maybeAutoCompact: a folded catalog that is itself above the limit (many
+  // distinct namespaces) would otherwise be re-folded + re-rewritten on every
+  // touch. We only compact again once the log has grown by >= one limit-worth
+  // since the last compaction (#1903, Codex).
+  lastCompactedSize = 0;
+  // Issue #1903 — per-(namespace, kind) coalescing buffer. Keyed `${kind}:${ns}`.
+  // Holds the latest buffered timestamp/metadata for a pure-timestamp touch on
+  // an already-known record; a `.unref()`'d timer flushes it once per window so
+  // the append-only log does not grow one line per repeat touch. Semantically
+  // observable touches (first sight, provenance/field change) bypass this buffer
+  // and flush immediately (see `coalesceTouch`).
+  pendingTouches = /* @__PURE__ */ new Map();
   /** Whether the catalog is active (namespaces enabled and catalog not opted out). */
   get enabled() {
     return isCatalogEnabled(this.config);
@@ -421,10 +445,102 @@ var NamespaceCatalog = class {
   }
   // ── Touch API (cheap, failure-tolerant) ─────────────────────────────────
   async markRead(namespace, metadata) {
-    await this.touch(namespace, "read", metadata);
+    await this.coalesceTouch(namespace, "read", metadata);
   }
   async markWrite(namespace, metadata) {
-    await this.touch(namespace, "write", metadata);
+    await this.coalesceTouch(namespace, "write", metadata);
+  }
+  /**
+   * Route a read/write touch through the per-(namespace, kind) coalescing buffer
+   * (issue #1903). A touch flushes IMMEDIATELY (bypassing the buffer) whenever it
+   * is semantically observable to an in-process reader — first sight of the
+   * namespace, a `config`→`write` provenance upgrade, the first time a touch
+   * field is set (so `listNamespaces({ writtenSince })` and record presence stay
+   * correct), or a change to `kind`/`principal`/`projectId`/`branch`/
+   * `parentNamespace`. A pure timestamp refresh on an already-known record is
+   * DEFERRED and coalesced: the newest buffered `at`/metadata wins and a single
+   * `touch` runs when the window elapses (or on `flushPendingTouches`). Window
+   * `0` skips the buffer entirely (the pre-#1903 immediate-append behavior).
+   * Best-effort: coalescing decisions read only the warm `compactedCache`, never
+   * forcing a disk parse; a cold cache flushes immediately (and re-warms it).
+   */
+  async coalesceTouch(namespace, kind, metadata) {
+    if (!this.enabled) return;
+    const window = kind === "read" ? this.readCoalesceMs : this.writeCoalesceMs;
+    if (window <= 0) {
+      await this.touch(namespace, kind, metadata);
+      return;
+    }
+    const ns = this.validateNamespace(namespace);
+    const cached = this.compactedCache?.records.get(ns);
+    if (cached === void 0 || this.touchMustFlushImmediately(kind, metadata, cached)) {
+      const stale = this.pendingTouches.get(`${kind}:${ns}`);
+      if (stale) {
+        clearTimeout(stale.timer);
+        this.pendingTouches.delete(`${kind}:${ns}`);
+      }
+      await this.touch(namespace, kind, metadata);
+      return;
+    }
+    const key = `${kind}:${ns}`;
+    const at = metadata?.at ?? /* @__PURE__ */ new Date();
+    const existing = this.pendingTouches.get(key);
+    if (existing) {
+      existing.metadata = metadata;
+      existing.at = at;
+      return;
+    }
+    const safeWindow = Math.min(window, 2147483647);
+    const timer = setTimeout(() => {
+      void this.flushPendingTouch(key);
+    }, safeWindow);
+    timer.unref();
+    this.pendingTouches.set(key, { namespace: ns, kind, metadata, at, timer });
+  }
+  /**
+   * Whether a read/write touch on an EXISTING cached record must flush
+   * immediately rather than coalesce. Only pure timestamp refreshes (the value
+   * returns false) are safe to defer.
+   */
+  touchMustFlushImmediately(kind, metadata, cached) {
+    if (kind === "write" && cached.discoveredBy === "config") return true;
+    if (kind === "write" && cached.lastWriteAt === void 0) return true;
+    if (kind === "read" && cached.lastReadAt === void 0) return true;
+    if (!metadata) return false;
+    if (metadata.kind !== void 0 && metadata.kind !== cached.kind) return true;
+    if (metadata.principal !== void 0 && metadata.principal !== cached.principal) return true;
+    if (metadata.projectId !== void 0 && metadata.projectId !== cached.projectId) return true;
+    if (metadata.branch !== void 0 && metadata.branch !== cached.branch) return true;
+    if (metadata.parentNamespace !== void 0 && metadata.parentNamespace !== cached.parentNamespace) {
+      return true;
+    }
+    if (metadata.storageDir !== void 0 && metadata.storageDir !== cached.storageDir) return true;
+    return false;
+  }
+  /** Fire a single buffered touch when its coalescing window elapses. */
+  async flushPendingTouch(key) {
+    const pending = this.pendingTouches.get(key);
+    if (!pending) return;
+    this.pendingTouches.delete(key);
+    clearTimeout(pending.timer);
+    await this.touch(pending.namespace, pending.kind, { ...pending.metadata, at: pending.at }).catch(
+      () => void 0
+    );
+  }
+  /**
+   * Flush every buffered coalesced touch now (issue #1903). Called from the
+   * router/orchestrator shutdown hook so a long-lived host does not drop
+   * buffered read/write timestamps on teardown, and by tests to make coalesced
+   * touches deterministically observable. Best-effort: a failed flush never
+   * throws (each touch is `.catch()`-guarded).
+   */
+  async flushPendingTouches() {
+    const pending = [...this.pendingTouches.values()];
+    this.pendingTouches.clear();
+    for (const p of pending) {
+      clearTimeout(p.timer);
+      await this.touch(p.namespace, p.kind, { ...p.metadata, at: p.at }).catch(() => void 0);
+    }
   }
   async markMaintenance(namespace, jobName, at) {
     if (typeof jobName !== "string" || jobName.trim().length === 0) {
@@ -830,10 +946,34 @@ var NamespaceCatalog = class {
           record.lastMaintenanceAt = { ...record.lastMaintenanceAt ?? {}, [jobName]: nowIso };
         }
         await this.appendUnchained(record);
+        await this.maybeAutoCompact();
         return true;
       })
     );
   }
+  /**
+   * Fold-and-rewrite the JSONL log when it exceeds `compactBytesLimit`
+   * (issue #1903). MUST be called only from inside `touch`'s held-lock +
+   * `queueCritical` critical section — it reuses `loadCompacted` (last-record-
+   * wins fold; every namespace row survives) and `rewriteUnchained` (atomic
+   * temp-file + rename), so the collapse is cross-process safe and never
+   * invokes the disk-scan purge in `finishRebuild`. Best-effort and fail-open
+   * (rule #40): the append already succeeded and is durable, so a failed
+   * compaction must not fail the touch — the next over-limit touch retries.
+   */
+  async maybeAutoCompact() {
+    try {
+      const limit = this.compactBytesLimit;
+      if (limit <= 0) return;
+      const size = this.compactedCache?.identity.size;
+      if (size === void 0 || size <= limit) return;
+      if (this.lastCompactedSize > 0 && size - this.lastCompactedSize < limit) return;
+      const folded = await this.loadCompacted();
+      await this.rewriteUnchained([...folded.values()]);
+      this.lastCompactedSize = this.compactedCache?.identity.size ?? size;
+    } catch {
+    }
+  }
   // ── Rebuild from disk ────────────────────────────────────────────────────
   async rebuildFromDisk(options) {
     const dryRun = options?.dryRun === true;
@@ -1204,21 +1344,43 @@ var NamespaceCatalog = class {
     }
     try {
       this.onCatalogReadForTest?.();
-      const raw = await handle.readFile("utf8");
-      for (const line of raw.split("\n")) {
+      const CHUNK_BYTES = 1 << 16;
+      const YIELD_EVERY_LINES = 5e3;
+      const chunk = Buffer.allocUnsafe(CHUNK_BYTES);
+      const decoder = new StringDecoder("utf8");
+      let leftover = "";
+      let linesSinceYield = 0;
+      const foldLine = (line) => {
         const trimmed = line.trim();
-        if (trimmed.length === 0) continue;
+        if (trimmed.length === 0) return;
         let parsed;
         try {
           parsed = JSON.parse(trimmed);
         } catch {
-          continue;
+          return;
         }
         const record = coerceRecord(parsed);
-        if (!record) continue;
+        if (!record) return;
         const prior = records.get(record.namespace);
         records.set(record.namespace, prior ? mergeNewerTouchFields(record, prior) : record);
+      };
+      for (; ; ) {
+        const { bytesRead } = await handle.read(chunk, 0, CHUNK_BYTES, null);
+        if (bytesRead === 0) break;
+        leftover += decoder.write(chunk.subarray(0, bytesRead));
+        let newlineIndex = leftover.indexOf("\n");
+        while (newlineIndex !== -1) {
+          foldLine(leftover.slice(0, newlineIndex));
+          leftover = leftover.slice(newlineIndex + 1);
+          if (++linesSinceYield >= YIELD_EVERY_LINES) {
+            linesSinceYield = 0;
+            await new Promise((resolve) => setImmediate(resolve));
+          }
+          newlineIndex = leftover.indexOf("\n");
+        }
       }
+      leftover += decoder.end();
+      foldLine(leftover);
     } catch {
       this.compactedCache = void 0;
       return /* @__PURE__ */ new Map();
@@ -2042,4 +2204,4 @@ export {
   runNamespaceMaintenancePlan,
   runNamespaceMaintenanceBatchPlan
 };
-//# sourceMappingURL=chunk-JZM5QUTE.js.map
+//# sourceMappingURL=chunk-TMGK6YE7.js.map