@remnic/cli 9.69.45 → 9.69.46

package/dist/index.js

@@ -2084,7 +2084,7 @@ import { buildReconcileManifest } from "@remnic/core/reconcile/manifest.js";
 import { convergeIdentityCachePath } from "@remnic/core/reconcile/cursor.js";
 
 // src/converge-plan-cache.ts
-import { createHash } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { readFileSync } from "fs";
 import * as fs16 from "fs/promises";
 import * as path2 from "path";
@@ -2099,6 +2099,15 @@ var CONVERGE_PLAN_CACHE_MAX_ENTRIES = 128;
 var CONVERGE_PLAN_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
 var CONVERGE_PLAN_CACHE_MAX_SCOPE_DIRS = 8;
 var SHA256_HEX = /^[0-9a-f]{64}$/i;
+var MEMORY_STATUSES = [
+  "active",
+  "pending_review",
+  "rejected",
+  "quarantined",
+  "superseded",
+  "archived",
+  "forgotten"
+];
 var ConvergePlanCacheBusyError = class extends Error {
   constructor(holderPid) {
     super(
@@ -2155,7 +2164,7 @@ function normalizeEntryFile(raw) {
     if (typeof candidate.id !== "string" || candidate.id.length === 0) return null;
     if (typeof candidate.contentHash !== "string" || !SHA256_HEX.test(candidate.contentHash)) return null;
     if (typeof candidate.category !== "string") return null;
-    if (typeof candidate.status !== "string") return null;
+    if (!MEMORY_STATUSES.includes(candidate.status)) return null;
     const normalizerVersion = typeof candidate.normalizerVersion === "number" ? candidate.normalizerVersion : void 0;
     const identityResolutionVersion = typeof candidate.identityResolutionVersion === "number" ? candidate.identityResolutionVersion : void 0;
     const contentHashAliases = Array.isArray(candidate.contentHashAliases) && candidate.contentHashAliases.every((alias) => typeof alias === "string") ? candidate.contentHashAliases : void 0;
@@ -2331,57 +2340,76 @@ async function pruneSiblingScopes(root, activeScope) {
     });
   }
 }
+var heldLockPaths = /* @__PURE__ */ new Set();
+var failedReleaseNonces = /* @__PURE__ */ new Map();
 var ConvergePlanCache = class _ConvergePlanCache {
   scope;
   scopeDir;
   lockPath;
+  nonce = randomUUID();
   closed = false;
   constructor(root, scope) {
     this.scope = scope;
     this.scopeDir = path2.join(root, scope);
     this.lockPath = path2.join(root, "lock.json");
   }
+  lockPayload() {
+    return `${JSON.stringify({
+      pid: process.pid,
+      startTicks: PROCESS_START_TICKS,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      nonce: this.nonce
+    })}
+`;
+  }
   /**
    * Open (and lock) the cache for one planning run. The lock is
    * cross-process: a second live planner fails fast with
    * {@link ConvergePlanCacheBusyError} instead of racing checkpoint writes.
-   * A lock left by a dead process is stolen; a lock file is only ever
-   * replaced atomically, so a steal racing the true owner at worst causes
-   * redundant recompute — entries themselves are content-addressed and
-   * written via rename, so concurrent identical writes cannot interleave.
+   * A lock left by a dead process — or by this process's own failed
+   * release — is stolen; a lock file is only ever replaced atomically, so
+   * a steal racing the true owner at worst causes redundant recompute —
+   * entries themselves are content-addressed and written via rename, so
+   * concurrent identical writes cannot interleave.
    */
   static async open(memoryDir, scope) {
     const root = convergePlanCacheRoot(memoryDir);
     const scopeDir = path2.join(root, scope);
     await ensureSafePlanCacheTree(memoryDir, scopeDir);
     const lockPath = path2.join(root, "lock.json");
-    const payload = `${JSON.stringify({
-      pid: process.pid,
-      startTicks: PROCESS_START_TICKS,
-      savedAt: (/* @__PURE__ */ new Date()).toISOString()
-    })}
-`;
+    if (heldLockPaths.has(lockPath)) throw new ConvergePlanCacheBusyError(process.pid);
+    heldLockPaths.add(lockPath);
+    const cache = new _ConvergePlanCache(root, scope);
     try {
-      await fs16.writeFile(lockPath, payload, { flag: "wx" });
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      let held = {};
+      const payload = cache.lockPayload();
       try {
-        held = JSON.parse(await fs16.readFile(lockPath, "utf8"));
+        await fs16.writeFile(lockPath, payload, { flag: "wx" });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        let held = {};
+        try {
+          held = JSON.parse(await fs16.readFile(lockPath, "utf8"));
+        } catch {
+          held = {};
+        }
+        const sameOwner = held.pid === process.pid && (typeof held.nonce === "string" && failedReleaseNonces.get(lockPath) === held.nonce || PROCESS_START_TICKS !== null && held.startTicks === PROCESS_START_TICKS);
+        if (!sameOwner) {
+          const owner = lockOwnerLive(held);
+          if (owner.live) throw new ConvergePlanCacheBusyError(owner.pid);
+        }
+        const tmp = `${lockPath}.${process.pid}.tmp`;
+        await fs16.writeFile(tmp, payload);
+        await fs16.rename(tmp, lockPath);
+      }
+      failedReleaseNonces.delete(lockPath);
+      try {
+        await pruneSiblingScopes(root, scope);
+        await pruneScopeDir(cache.scopeDir);
       } catch {
-        held = {};
       }
-      const owner = lockOwnerLive(held);
-      if (owner.live) throw new ConvergePlanCacheBusyError(owner.pid);
-      const tmp = `${lockPath}.${process.pid}.tmp`;
-      await fs16.writeFile(tmp, payload);
-      await fs16.rename(tmp, lockPath);
-    }
-    const cache = new _ConvergePlanCache(root, scope);
-    try {
-      await pruneSiblingScopes(root, scope);
-      await pruneScopeDir(cache.scopeDir);
-    } catch {
+    } catch (error) {
+      heldLockPaths.delete(lockPath);
+      throw error;
     }
     return cache;
   }
@@ -2417,6 +2445,7 @@ var ConvergePlanCache = class _ConvergePlanCache {
    */
   async writeEntry(entry) {
     if (this.closed) return;
+    await this.renewLease();
     const fileName = entryFileName(entry.side, entry.namespace, entry.watermark);
     const finalPath = path2.join(this.scopeDir, fileName);
     const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
@@ -2439,11 +2468,49 @@ var ConvergePlanCache = class _ConvergePlanCache {
     } catch {
     }
   }
-  /** Release the cross-process lock. Safe to call more than once. */
+  /**
+   * Refresh savedAt while the cache stays open (#2965): on hosts without
+   * readable /proc start ticks the 24h lease is the only steal guard, and a
+   * plan legitimately longer than that must not have its lock stolen
+   * mid-run. Renewal rides the per-namespace checkpoint cadence; it skips
+   * a lock that was stolen from us (nonce mismatch).
+   */
+  async renewLease() {
+    if (this.closed) return;
+    try {
+      const held = JSON.parse(await fs16.readFile(this.lockPath, "utf8"));
+      if (typeof held.nonce !== "string" || held.nonce !== this.nonce) return;
+      const tmp = `${this.lockPath}.${process.pid}.renew.tmp`;
+      await fs16.writeFile(tmp, this.lockPayload());
+      await fs16.rename(tmp, this.lockPath);
+    } catch {
+    }
+  }
+  /**
+   * Release the cross-process lock. Safe to call more than once. Only the
+   * lock instance this cache owns is unlinked (#2965): a lock stolen from
+   * us carries another owner's nonce and must survive this close. When our
+   * own unlink fails, the nonce is retained so a later open in this
+   * process reclaims the orphan instead of busy-failing on it.
+   */
   async close() {
     if (this.closed) return;
     this.closed = true;
-    await unlinkQuiet(this.lockPath);
+    heldLockPaths.delete(this.lockPath);
+    let owned = false;
+    try {
+      const held = JSON.parse(await fs16.readFile(this.lockPath, "utf8"));
+      owned = typeof held.nonce === "string" && held.nonce === this.nonce;
+    } catch {
+    }
+    if (!owned) return;
+    try {
+      await fs16.unlink(this.lockPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        failedReleaseNonces.set(this.lockPath, this.nonce);
+      }
+    }
   }
 };
 
@@ -2970,20 +3037,20 @@ async function planLocalNamespaceCensus(args) {
     identityCache,
     classificationUpdates
   );
+  const priorByPath = new Map((priorFiles ?? []).map((file) => [file.path, file.sha256.toLowerCase()]));
+  let reused = 0;
+  for (const file of files) {
+    if (priorByPath.get(file.path) === file.sha256.toLowerCase()) reused += 1;
+  }
+  args.onProgress?.({
+    side: "local",
+    namespace: ns,
+    index: args.index,
+    total: args.total,
+    reused,
+    computed: files.length - reused
+  });
   if (args.cache) {
-    const priorByPath = new Map((priorFiles ?? []).map((file) => [file.path, file.sha256.toLowerCase()]));
-    let reused = 0;
-    for (const file of files) {
-      if (priorByPath.get(file.path) === file.sha256.toLowerCase()) reused += 1;
-    }
-    args.onProgress?.({
-      side: "local",
-      namespace: ns,
-      index: args.index,
-      total: args.total,
-      reused,
-      computed: files.length - reused
-    });
     await args.cache.writeEntry({
       version: 1,
       scope: args.cache.scope,
@@ -3025,7 +3092,7 @@ import {
   RECONCILE_MANIFEST_SCHEMA_VERSION as RECONCILE_MANIFEST_SCHEMA_VERSION2
 } from "@remnic/core/reconcile/manifest.js";
 var SHA256_PATTERN = /^[a-f0-9]{64}$/i;
-var MEMORY_STATUSES = /* @__PURE__ */ new Set([
+var MEMORY_STATUSES2 = /* @__PURE__ */ new Set([
   "active",
   "pending_review",
   "rejected",
@@ -3062,7 +3129,7 @@ function parseMemory(value) {
   if (typeof memory.contentHash !== "string" || !SHA256_PATTERN.test(memory.contentHash)) {
     throw new Error("peer manifest memory metadata had invalid contentHash");
   }
-  if (typeof memory.status !== "string" || !MEMORY_STATUSES.has(memory.status)) {
+  if (typeof memory.status !== "string" || !MEMORY_STATUSES2.has(memory.status)) {
     throw new Error("peer manifest memory metadata had invalid status");
   }
   const contentHash = memory.contentHash.toLowerCase();
@@ -3561,7 +3628,11 @@ async function planPeerNamespaceCensus(args) {
   const watermark = censusWatermark(peerData.files);
   let peerManifest = null;
   let clientBuilt = clientBuiltPrior;
-  if (reusableEntry && reusableEntry.watermark === watermark && reusableEntry.fileCount === peerData.files.length) {
+  if (reusableEntry && reusableEntry.watermark === watermark && reusableEntry.fileCount === peerData.files.length && // A peer upgraded to manifest streaming must not keep serving this
+  // client's older parser semantics on an unchanged watermark (#2965):
+  // client-built rows stay a warm base only; the stream runs once and
+  // the checkpoint becomes a streamed entry.
+  !(args.manifestStream && clientBuiltPrior)) {
     const freshByPath = new Map(peerData.files.map((file) => [file.path, file]));
     peerManifest = {
       format: RECONCILE_MANIFEST_FORMAT2,
@@ -3640,33 +3711,35 @@ async function planPeerNamespaceCensus(args) {
   }
   const mapped = tombstonedFileDigests(evidence, peerManifests);
   for (const digest of peerData.tombstones) mapped.add(digest);
+  const priorByPath = new Map((priorPeerFiles ?? []).map((file) => [file.path, file.sha256.toLowerCase()]));
+  let reused = 0;
+  for (const file of peerManifests.files) {
+    if (priorByPath.get(file.path) === file.sha256.toLowerCase()) reused += 1;
+  }
+  args.onProgress?.({
+    side: "peer",
+    namespace: ns,
+    index: args.index,
+    total: args.total,
+    reused,
+    computed: peerManifests.files.length - reused
+  });
   if (args.cache) {
-    const priorByPath = new Map((priorPeerFiles ?? []).map((file) => [file.path, file.sha256.toLowerCase()]));
-    let reused = 0;
-    for (const file of peerManifests.files) {
-      if (priorByPath.get(file.path) === file.sha256.toLowerCase()) reused += 1;
+    if (censusWatermark(peerManifests.files) === watermark) {
+      await args.cache.writeEntry({
+        version: 1,
+        scope: args.cache.scope,
+        side: "peer",
+        namespace: ns,
+        watermark,
+        fileCount: peerManifests.files.length,
+        capturedAtMs: Date.now(),
+        savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...args.peerManifestRevision !== void 0 ? { peerManifestRevision: args.peerManifestRevision } : {},
+        ...clientBuilt ? { clientBuilt: true } : {},
+        files: peerManifests.files
+      });
     }
-    args.onProgress?.({
-      side: "peer",
-      namespace: ns,
-      index: args.index,
-      total: args.total,
-      reused,
-      computed: peerManifests.files.length - reused
-    });
-    await args.cache.writeEntry({
-      version: 1,
-      scope: args.cache.scope,
-      side: "peer",
-      namespace: ns,
-      watermark,
-      fileCount: peerManifests.files.length,
-      capturedAtMs: Date.now(),
-      savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...args.peerManifestRevision !== void 0 ? { peerManifestRevision: args.peerManifestRevision } : {},
-      ...clientBuilt ? { clientBuilt: true } : {},
-      files: peerManifests.files
-    });
   }
   return { manifest: peerManifests, tombstones: mapped };
 }
@@ -4560,6 +4633,7 @@ async function updateCursorsForPlan(plan, options) {
   if (!memoryDir) return;
   const namespaces = new Set(plan.byNamespace.map((n) => n.namespace));
   for (const ns of namespaces) {
+    options.signal?.throwIfAborted();
     const cursorPath = defaultConvergeCursorPath(memoryDir, peerUrl, ns);
     const priorSemanticAgreements = options.semanticAgreementsByNamespace?.get(ns) ?? (await readConvergeCursor(cursorPath))?.semanticAgreements ?? [];
     const { baseFiles, semanticAgreements } = deriveConvergeCursorBase(plan.entries, ns, priorSemanticAgreements);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/cli",
-  "version": "9.69.45",
+  "version": "9.69.46",
   "description": "CLI for Remnic memory — init, query, doctor, daemon management",
   "type": "module",
   "main": "dist/index.js",
@@ -26,26 +26,26 @@
   },
   "dependencies": {
     "yaml": "^2.4.2",
-    "@remnic/plugin-pi": "^9.69.45",
-    "@remnic/server": "^9.69.45",
-    "@remnic/core": "^9.69.45"
+    "@remnic/plugin-pi": "^9.69.46",
+    "@remnic/server": "^9.69.46",
+    "@remnic/core": "^9.69.46"
   },
   "peerDependencies": {
-    "@remnic/bench": "^9.69.45",
-    "@remnic/plugin-openclaw": "^9.69.45",
-    "@remnic/export-weclone": "^9.69.45",
-    "@remnic/import-weclone": "^9.69.45",
-    "@remnic/import-chatgpt": "^9.69.45",
-    "@remnic/import-claude": "^9.69.45",
-    "@remnic/import-gemini": "^9.69.45",
-    "@remnic/import-lossless-claw": "^9.69.45",
-    "@remnic/import-mem0": "^9.69.45",
-    "@remnic/import-supermemory": "^9.69.45",
-    "@remnic/import-okf": "^9.69.45",
-    "@remnic/connector-limitless": "^9.69.45",
-    "@remnic/connector-bee": "^9.69.45",
-    "@remnic/connector-omi": "^9.69.45",
-    "@remnic/capture-audio": "^9.69.45"
+    "@remnic/bench": "^9.69.46",
+    "@remnic/plugin-openclaw": "^9.69.46",
+    "@remnic/export-weclone": "^9.69.46",
+    "@remnic/import-weclone": "^9.69.46",
+    "@remnic/import-chatgpt": "^9.69.46",
+    "@remnic/import-claude": "^9.69.46",
+    "@remnic/import-gemini": "^9.69.46",
+    "@remnic/import-lossless-claw": "^9.69.46",
+    "@remnic/import-mem0": "^9.69.46",
+    "@remnic/import-supermemory": "^9.69.46",
+    "@remnic/import-okf": "^9.69.46",
+    "@remnic/connector-limitless": "^9.69.46",
+    "@remnic/connector-bee": "^9.69.46",
+    "@remnic/connector-omi": "^9.69.46",
+    "@remnic/capture-audio": "^9.69.46"
   },
   "peerDependenciesMeta": {
     "@remnic/bench": {
@@ -97,19 +97,19 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@remnic/plugin-openclaw": "9.69.45",
-    "@remnic/bench": "9.69.45",
-    "@remnic/import-weclone": "9.69.45",
-    "@remnic/export-weclone": "9.69.45",
-    "@remnic/import-claude": "9.69.45",
-    "@remnic/import-chatgpt": "9.69.45",
-    "@remnic/import-gemini": "9.69.45",
-    "@remnic/import-supermemory": "9.69.45",
-    "@remnic/import-mem0": "9.69.45",
-    "@remnic/connector-limitless": "9.69.45",
-    "@remnic/connector-bee": "9.69.45",
-    "@remnic/connector-omi": "9.69.45",
-    "@remnic/import-lossless-claw": "9.69.45"
+    "@remnic/bench": "9.69.46",
+    "@remnic/plugin-openclaw": "9.69.46",
+    "@remnic/export-weclone": "9.69.46",
+    "@remnic/import-weclone": "9.69.46",
+    "@remnic/import-chatgpt": "9.69.46",
+    "@remnic/import-claude": "9.69.46",
+    "@remnic/import-gemini": "9.69.46",
+    "@remnic/import-lossless-claw": "9.69.46",
+    "@remnic/import-mem0": "9.69.46",
+    "@remnic/connector-limitless": "9.69.46",
+    "@remnic/import-supermemory": "9.69.46",
+    "@remnic/connector-omi": "9.69.46",
+    "@remnic/connector-bee": "9.69.46"
   },
   "license": "MIT",
   "repository": {