@remnic/cli 10.0.8 → 10.0.10

package/dist/index.js

@@ -2365,9 +2365,7 @@ import {
   readConvergeCursor,
   writeConvergeCursor
 } from "@remnic/core/reconcile/cursor.js";
-import {
-  collapseActiveFactDuplicates
-} from "@remnic/core/reconcile/manifest.js";
+import { collapseActiveFactDuplicates } from "@remnic/core/reconcile/manifest.js";
 import {
   planReconciliation
 } from "@remnic/core/reconcile/plan.js";
@@ -3364,6 +3362,133 @@ async function planLocalNamespaceCensus(args) {
   return { files, manifest, tombstones: tombstonedFileDigests(evidence, manifest) };
 }
 
+// src/converge-namespace-exclusions.ts
+var TRANSPORT_MARKERS = [
+  "aborted due to timeout",
+  "operation was aborted",
+  "fetch failed",
+  "econnrefused",
+  "econnreset",
+  "enotfound",
+  "etimedout",
+  "eai_again",
+  "socket hang up",
+  "und_err_"
+];
+function hasHttpStatus(message) {
+  let from = 0;
+  while (from < message.length) {
+    const at = message.indexOf("HTTP ", from);
+    if (at < 0) return false;
+    const start = at + 5;
+    if (start + 2 < message.length && message.charCodeAt(start) >= 48 && message.charCodeAt(start) <= 57 && message.charCodeAt(start + 1) >= 48 && message.charCodeAt(start + 1) <= 57 && message.charCodeAt(start + 2) >= 48 && message.charCodeAt(start + 2) <= 57) {
+      return true;
+    }
+    from = start;
+  }
+  return false;
+}
+function hasTransportMarker(message) {
+  const lower = message.toLowerCase();
+  for (const marker of TRANSPORT_MARKERS) {
+    if (lower.includes(marker)) return true;
+  }
+  return false;
+}
+var PEER_PATH_ERROR_PREFIXES = [
+  "failed to read peer reconciliation manifest file:",
+  "failed to read peer tombstone evidence:",
+  "offline file content response changed during transfer:"
+];
+function errorEmbedsPeerPath(message) {
+  for (const prefix of PEER_PATH_ERROR_PREFIXES) {
+    if (message.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function isPeerTransportCensusFailure(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== void 0 && current !== null && !seen.has(current)) {
+    seen.add(current);
+    if (!(current instanceof Error)) return false;
+    if (hasHttpStatus(current.message)) return false;
+    if (current.name === "TimeoutError") return true;
+    if (!errorEmbedsPeerPath(current.message) && hasTransportMarker(current.message)) return true;
+    current = "cause" in current ? current.cause : void 0;
+  }
+  return false;
+}
+function recordNamespaceCensusFailure(excluded, namespace, side, error, signal) {
+  if (signal?.aborted) throw error;
+  if (side === "peer" && isPeerTransportCensusFailure(error)) throw error;
+  const message = error instanceof Error && error.message.length > 0 ? error.message : String(error);
+  excluded.set(namespace, { namespace, side, error: message, cause: error });
+}
+function excludeNamespaceGroup(excluded, namespaces, side, error, signal, drop) {
+  for (const namespace of namespaces) {
+    recordNamespaceCensusFailure(excluded, namespace, side, error, signal);
+    drop(namespace);
+  }
+}
+function singleLine(value) {
+  let out = "";
+  let pendingSpace = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index] ?? "";
+    const code = char.charCodeAt(0);
+    const isSpace = code === 32 || code === 9 || code === 10 || code === 13;
+    if (isSpace) {
+      pendingSpace = out.length > 0;
+      continue;
+    }
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) continue;
+    if (pendingSpace) {
+      out += " ";
+      pendingSpace = false;
+    }
+    out += char;
+  }
+  return out;
+}
+function loggedCensusFailure(failure) {
+  const message = failure.error.length > 0 ? failure.error : String(failure.cause);
+  const cleaned = singleLine(message);
+  return `${singleLine(failure.namespace)} (${failure.side}): ${cleaned.length > 0 ? cleaned : "namespace census failed"}`;
+}
+function compareNamespaceSide(left, right) {
+  if (left.namespace < right.namespace) return -1;
+  if (left.namespace > right.namespace) return 1;
+  if (left.side < right.side) return -1;
+  if (left.side > right.side) return 1;
+  return 0;
+}
+function listNamespaceExclusions(excluded) {
+  return [...excluded.values()].map(({ namespace, side, error }) => ({ namespace, side, error })).sort(compareNamespaceSide);
+}
+function finishConvergeApplyResult(result, excludedNamespaces) {
+  if (excludedNamespaces.length === 0) return result;
+  const failedTransfers = result.status === "applied" && result.transfers.failed > 0;
+  const keepStatus = result.status === "stopped_unresolved_conflicts" || result.status === "dry_run" || failedTransfers;
+  return {
+    ...result,
+    excludedNamespaces,
+    converged: false,
+    status: keepStatus ? result.status : "partial"
+  };
+}
+function throwIfEveryNamespaceCensusFailed(plannedNamespaces, excluded) {
+  if (plannedNamespaces > 0 || excluded.size === 0) return;
+  const failures = [...excluded.values()].sort(compareNamespaceSide);
+  const only = failures[0];
+  if (failures.length === 1 && only) {
+    const message = only.error.length > 0 ? only.error : String(only.cause);
+    const cleaned = singleLine(message);
+    throw new Error(cleaned.length > 0 ? cleaned : "namespace census failed", { cause: only.cause });
+  }
+  throw new Error(`converge: every namespace census failed: ${failures.map(loggedCensusFailure).join("; ")}`);
+}
+
 // src/converge-peer-census.ts
 import { createHash as createHash4 } from "crypto";
 import { parseFrontmatter as parseFrontmatter2 } from "@remnic/core/storage.js";
@@ -3376,10 +3501,10 @@ import {
 // src/converge-peer-transport.ts
 import { createHash as createHash3 } from "crypto";
 import {
-  isInternalRemnicStatePath as isInternalRemnicStatePath3,
   OFFLINE_SYNC_CHANGESET_FORMAT,
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
-  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2
+  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2,
+  isInternalRemnicStatePath as isInternalRemnicStatePath3
 } from "@remnic/core";
 import { normalizeConvergePeerUrl as normalizeConvergePeerUrl2 } from "@remnic/core/reconcile/cursor.js";
 
@@ -3609,6 +3734,73 @@ async function fetchPeerManifestStream(peerUrl, namespace, token, fetchImpl = gl
   }
   return null;
 }
+var SNAPSHOT_ERROR_BODY_CAP_BYTES = 512;
+function collapseWhitespace(value, max) {
+  let out = "";
+  let pendingSpace = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index] ?? "";
+    const code = char.charCodeAt(0);
+    const isSpace = code === 32 || code === 9 || code === 10 || code === 13;
+    if (isSpace) {
+      pendingSpace = out.length > 0;
+      continue;
+    }
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) continue;
+    if (pendingSpace) {
+      if (out.length + 1 >= max) break;
+      out += " ";
+      pendingSpace = false;
+    }
+    if (out.length >= max) break;
+    out += char;
+  }
+  return out;
+}
+async function readBoundedBody(response, maxBytes) {
+  const body = response.body;
+  if (!body) return "";
+  const reader = body.getReader();
+  const chunks = [];
+  let received = 0;
+  try {
+    while (received < maxBytes) {
+      const { done, value } = await reader.read();
+      if (done || !value || value.byteLength === 0) break;
+      const remaining = maxBytes - received;
+      if (value.byteLength > remaining) {
+        chunks.push(value.subarray(0, remaining));
+        received += remaining;
+        break;
+      }
+      chunks.push(value);
+      received += value.byteLength;
+    }
+  } catch (error) {
+    if (isPeerTransportCensusFailure(error)) throw error;
+    return "";
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function readSnapshotErrorDetail(response) {
+  const raw = await readBoundedBody(response, SNAPSHOT_ERROR_BODY_CAP_BYTES);
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return "";
+  let detail = trimmed;
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed !== null && typeof parsed === "object" && "error" in parsed) {
+        const error = parsed.error;
+        if (typeof error === "string" && error.trim().length > 0) detail = error.trim();
+      }
+    } catch {
+    }
+  }
+  return collapseWhitespace(detail, 160);
+}
 async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS, signal) {
   const base = normalizePeerBaseUrl(peerUrl);
   const routes = [
@@ -3622,6 +3814,15 @@ async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalTh
   ];
   const headers = token ? { authorization: `Bearer ${token}` } : {};
   let lastFailure = "no snapshot route responded";
+  let transportFailure;
+  const noteTransportFailure = (error) => {
+    if (transportFailure === void 0 && isPeerTransportCensusFailure(error)) transportFailure = error;
+    lastFailure = error instanceof Error && error.message.length > 0 ? error.message : String(error);
+  };
+  const invalidSnapshot = (detail) => {
+    if (transportFailure) throw transportFailure;
+    return new Error(`invalid peer snapshot for namespace ${namespace}: ${detail}`);
+  };
   for (const route of routes) {
     let response;
     try {
@@ -3633,25 +3834,38 @@ async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalTh
       );
     } catch (error) {
       if (signal?.aborted) throw error;
-      lastFailure = error instanceof Error ? error.message : String(error);
+      noteTransportFailure(error);
       continue;
     }
     if (!response.ok) {
-      lastFailure = `HTTP ${response.status}`;
+      let detail = "";
+      try {
+        detail = await readSnapshotErrorDetail(response);
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        noteTransportFailure(error);
+        continue;
+      }
+      lastFailure = detail.length > 0 ? `HTTP ${response.status} ${detail}` : `HTTP ${response.status}`;
       continue;
     }
     let data;
     try {
       data = await response.json();
-    } catch {
-      throw new Error(`invalid peer snapshot for namespace ${namespace}: response was not JSON`);
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      if (isPeerTransportCensusFailure(error)) {
+        noteTransportFailure(error);
+        continue;
+      }
+      throw invalidSnapshot("response was not JSON");
     }
     if (!data || typeof data !== "object" || !("files" in data) || !Array.isArray(data.files)) {
-      throw new Error(`invalid peer snapshot for namespace ${namespace}: files must be an array`);
+      throw invalidSnapshot("files must be an array");
     }
     const files = data.files.map((item, index) => {
       if (!item || typeof item !== "object" || !("path" in item) || typeof item.path !== "string" || !("sha256" in item) || typeof item.sha256 !== "string") {
-        throw new Error(`invalid peer snapshot for namespace ${namespace}: malformed file at index ${index}`);
+        throw invalidSnapshot(`malformed file at index ${index}`);
       }
       return {
         path: item.path,
@@ -3662,17 +3876,18 @@ async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalTh
     }).filter((file) => !isInternalRemnicStatePath3(file.path));
     const rawTombstones = "tombstones" in data ? data.tombstones : void 0;
     if (rawTombstones !== void 0 && !Array.isArray(rawTombstones)) {
-      throw new Error(`invalid peer snapshot for namespace ${namespace}: tombstones must be an array`);
+      throw invalidSnapshot("tombstones must be an array");
     }
     const tombstones = /* @__PURE__ */ new Set();
     for (const tombstone of rawTombstones ?? []) {
       if (typeof tombstone !== "string" || !/^[0-9a-f]{64}$/i.test(tombstone)) {
-        throw new Error(`invalid peer snapshot for namespace ${namespace}: malformed tombstone`);
+        throw invalidSnapshot("malformed tombstone");
       }
       tombstones.add(tombstone.toLowerCase());
     }
     return { files, tombstones };
   }
+  if (transportFailure) throw transportFailure;
   throw new Error(`failed to fetch peer snapshot for namespace ${namespace}: ${lastFailure}`);
 }
 function requiredResponseNumber(response, name) {
@@ -3683,7 +3898,7 @@ function requiredResponseNumber(response, name) {
   }
   return value;
 }
-async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS, signal) {
+async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS, signal, propagateTransportErrors = false) {
   assertTransferablePeerPath(filePath);
   const base = normalizePeerBaseUrl(peerUrl);
   const routes = ["/remnic/v1/offline-sync/file-content", "/engram/v1/offline-sync/file-content"];
@@ -3696,6 +3911,7 @@ async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, toke
   let expectedBytes;
   let expectedSha256;
   let mtimeMs;
+  let transportFailure;
   for (const route of routes) {
     let routeFailed = false;
     do {
@@ -3719,7 +3935,9 @@ async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, toke
           timeoutMs
         );
         if (!response.ok) throw new Error(`offline file content request failed: ${response.status}`);
-      } catch {
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        if (propagateTransportErrors && isPeerTransportCensusFailure(error)) transportFailure = error;
         routeFailed = true;
         break;
       }
@@ -3738,7 +3956,9 @@ async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, toke
         if (!sha256 || chunkOffset !== offset || chunkBytes !== content.length || encodedPath !== null && decodeURIComponent(encodedPath) !== filePath || expectedBytes !== void 0 && expectedBytes !== totalBytes || expectedSha256 !== void 0 && expectedSha256 !== sha256 || content.length === 0 && offset < totalBytes) {
           throw new Error(`offline file content response changed during transfer: ${filePath}`);
         }
-      } catch {
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        if (propagateTransportErrors && isPeerTransportCensusFailure(error)) transportFailure = error;
         routeFailed = true;
         break;
       }
@@ -3757,12 +3977,13 @@ async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, toke
     } while (expectedBytes === void 0 || offset < expectedBytes);
     if (!routeFailed && expectedBytes !== void 0 && offset === expectedBytes) break;
   }
-  if (expectedBytes === void 0 || expectedSha256 === void 0 || mtimeMs === void 0 || offset !== expectedBytes || hash.digest("hex") !== expectedSha256) {
-    return null;
+  if (expectedBytes !== void 0 && expectedSha256 !== void 0 && mtimeMs !== void 0 && offset === expectedBytes && hash.digest("hex") === expectedSha256) {
+    return { sha256: expectedSha256, bytes: expectedBytes, mtimeMs };
   }
-  return { sha256: expectedSha256, bytes: expectedBytes, mtimeMs };
+  if (transportFailure) throw transportFailure;
+  return null;
 }
-async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS, signal) {
+async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS, signal, propagateTransportErrors = false) {
   const chunks = [];
   const metadata = await streamPeerFileContent(
     peerUrl,
@@ -3774,7 +3995,8 @@ async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchIm
     token,
     fetchImpl,
     timeoutMs,
-    signal
+    signal,
+    propagateTransportErrors
   );
   if (!metadata) return null;
   return {
@@ -3973,6 +4195,7 @@ async function planPeerNamespaceCensus(args) {
     } else {
       clientBuilt = true;
       let readFailure;
+      let transportFailure;
       peerManifest = await buildReconcileManifest2({
         files: peerData.files,
         parseMemory: parseFrontmatter2,
@@ -3982,6 +4205,7 @@ async function planPeerNamespaceCensus(args) {
         // rows (sha-keyed) skip the ones already fetched.
         cachedFiles: priorPeerFiles ?? args.localManifestFiles,
         readFile: async (file) => {
+          if (transportFailure) throw transportFailure;
           let remote;
           try {
             remote = await fetchPeerFileContent(
@@ -3991,19 +4215,24 @@ async function planPeerNamespaceCensus(args) {
               args.resolvedToken,
               args.fetchFn,
               args.timeoutMs,
-              args.signal
+              args.signal,
+              true
             );
           } catch (error) {
-            readFailure = error instanceof Error ? error : new Error(String(error));
-            throw readFailure;
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (isPeerTransportCensusFailure(error)) transportFailure = transportFailure ?? error;
+            if (!transportFailure) readFailure = failure;
+            throw failure;
           }
           if (!remote || remote.sha256 !== file.sha256) {
-            readFailure = new Error(`failed to read peer reconciliation manifest file: ${file.path}`);
-            throw readFailure;
+            const failure = new Error(`failed to read peer reconciliation manifest file: ${file.path}`);
+            if (!transportFailure) readFailure = failure;
+            throw failure;
           }
           return remote.content;
         }
       });
+      if (transportFailure) throw transportFailure;
       if (readFailure) throw readFailure;
     }
   }
@@ -4012,15 +4241,21 @@ async function planPeerNamespaceCensus(args) {
   for (const tombstonePath of TOMBSTONE_PATHS) {
     const state = peerData.files.find((file) => file.path === tombstonePath);
     if (!state) continue;
-    const remote = await fetchPeerFileContent(
-      peerUrl,
-      ns,
-      tombstonePath,
-      args.resolvedToken,
-      args.fetchFn,
-      args.timeoutMs,
-      args.signal
-    );
+    let remote;
+    try {
+      remote = await fetchPeerFileContent(
+        peerUrl,
+        ns,
+        tombstonePath,
+        args.resolvedToken,
+        args.fetchFn,
+        args.timeoutMs,
+        args.signal,
+        true
+      );
+    } catch (error) {
+      throw new Error(`failed to read peer tombstone evidence: ${tombstonePath}`, { cause: error });
+    }
     if (!remote) {
       throw new Error(`failed to read peer tombstone evidence: ${tombstonePath}`);
     }
@@ -4072,8 +4307,10 @@ async function planPeerNamespaceCensus(args) {
 
 // src/converge-report.ts
 function formatConvergeReport(plan) {
+  const excluded = plan.excludedNamespaces ?? [];
   const lines = [];
-  lines.push(`Convergence Status: ${plan.converged ? "CONVERGED" : "DIVERGED"}`);
+  const status = excluded.length > 0 ? "PARTIAL" : plan.converged ? "CONVERGED" : "DIVERGED";
+  lines.push(`Convergence Status: ${status}`);
   lines.push("");
   lines.push("Per-Namespace Summary:");
   if (plan.byNamespace.length === 0) {
@@ -4089,8 +4326,24 @@ function formatConvergeReport(plan) {
       lines.push(`    unresolved: ${report.unresolved}`);
     }
   }
+  if (excluded.length > 0) {
+    lines.push("");
+    lines.push("Excluded namespaces (census failed; no pushes, no deletes):");
+    for (const exclusion of excluded) {
+      lines.push(`  [${singleLine(exclusion.namespace)}] side=${exclusion.side} ${singleLine(exclusion.error)}`);
+    }
+  }
   return lines.join("\n");
 }
+function formatConvergeWatchCycleLine(cycle, result) {
+  const transfers = result.transfers;
+  const excluded = result.excludedNamespaces?.length ?? 0;
+  return `converge watch: cycle ${cycle} status=${result.status} pulled=${transfers.pulled} pushed=${transfers.pushed} conflicts=${transfers.conflictsResolved} failed=${transfers.failed} excluded=${excluded}`;
+}
+function formatConvergeExclusionLine(cycle, exclusion) {
+  const prefix = cycle === void 0 ? "converge:" : `converge watch: cycle ${cycle}`;
+  return `${prefix} excluded namespace=${singleLine(exclusion.namespace)} side=${exclusion.side}: ${singleLine(exclusion.error)}`;
+}
 function formatConvergeApplyReport(result) {
   const lines = [];
   lines.push(`Convergence Execution Status: ${result.status.toUpperCase()}`);
@@ -4107,6 +4360,68 @@ function formatConvergeApplyReport(result) {
   return lines.join("\n");
 }
 
+// src/converge-watch.ts
+var CONVERGE_WATCH_MIN_INTERVAL_MS = 1e3;
+var CONVERGE_WATCH_DEFAULT_INTERVAL_MS = 3e5;
+var CONVERGE_WATCH_MAX_INTERVAL_MS = 2147483647;
+function sleepAborted(ms, signal) {
+  return new Promise((resolve3) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve3(true);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve3(false);
+    };
+    if (signal.aborted) {
+      clearTimeout(timer);
+      resolve3(false);
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function convergeWatch(options) {
+  const intervalMs = Math.min(
+    CONVERGE_WATCH_MAX_INTERVAL_MS,
+    Math.max(CONVERGE_WATCH_MIN_INTERVAL_MS, options.intervalMs ?? CONVERGE_WATCH_DEFAULT_INTERVAL_MS)
+  );
+  const { apply, intervalMs: _intervalMs, maxCycles, onCycle, signal, ...applyOptions } = options;
+  const outcome = {
+    cycles: 0,
+    convergedCycles: 0,
+    appliedCycles: 0,
+    failedCycles: 0,
+    lastStatus: "aborted",
+    lastExcludedNamespaces: []
+  };
+  while (maxCycles === void 0 || outcome.cycles < maxCycles) {
+    if (signal?.aborted) break;
+    try {
+      const result = await apply(applyOptions);
+      outcome.cycles += 1;
+      if (result.status === "converged") outcome.convergedCycles += 1;
+      else if (result.status === "stopped_unresolved_conflicts" || result.status === "applied" && result.transfers.failed > 0) {
+        outcome.failedCycles += 1;
+      } else outcome.appliedCycles += 1;
+      outcome.lastStatus = result.status;
+      outcome.lastExcludedNamespaces = result.excludedNamespaces ? [...result.excludedNamespaces] : [];
+      onCycle?.(outcome.cycles, { result });
+    } catch (err) {
+      outcome.cycles += 1;
+      outcome.failedCycles += 1;
+      outcome.lastStatus = "error";
+      outcome.lastExcludedNamespaces = [];
+      onCycle?.(outcome.cycles, { error: err });
+    }
+    if (maxCycles !== void 0 && outcome.cycles >= maxCycles) break;
+    const slept = await sleepAborted(intervalMs, signal ?? new AbortController().signal);
+    if (!slept) break;
+  }
+  return outcome;
+}
+
 // src/credential-channel.ts
 import * as fs20 from "fs";
 function parseTokenFileFlag(raw) {
@@ -4203,65 +4518,6 @@ function resolveCredentialChannel(input, env, hooks) {
   return { ok: true, token: void 0, tokenFromArgv: false };
 }
 
-// src/converge-watch.ts
-var CONVERGE_WATCH_MIN_INTERVAL_MS = 1e3;
-var CONVERGE_WATCH_DEFAULT_INTERVAL_MS = 3e5;
-var CONVERGE_WATCH_MAX_INTERVAL_MS = 2147483647;
-function sleepAborted(ms, signal) {
-  return new Promise((resolve3) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve3(true);
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve3(false);
-    };
-    if (signal.aborted) {
-      clearTimeout(timer);
-      resolve3(false);
-      return;
-    }
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function convergeWatch(options) {
-  const intervalMs = Math.min(
-    CONVERGE_WATCH_MAX_INTERVAL_MS,
-    Math.max(CONVERGE_WATCH_MIN_INTERVAL_MS, options.intervalMs ?? CONVERGE_WATCH_DEFAULT_INTERVAL_MS)
-  );
-  const { apply, intervalMs: _intervalMs, maxCycles, onCycle, signal, ...applyOptions } = options;
-  const outcome = {
-    cycles: 0,
-    convergedCycles: 0,
-    appliedCycles: 0,
-    failedCycles: 0,
-    lastStatus: "aborted"
-  };
-  while (maxCycles === void 0 || outcome.cycles < maxCycles) {
-    if (signal?.aborted) break;
-    try {
-      const result = await apply(applyOptions);
-      outcome.cycles += 1;
-      if (result.status === "converged") outcome.convergedCycles += 1;
-      else if (result.status === "stopped_unresolved_conflicts" || result.status === "applied" && result.transfers.failed > 0) {
-        outcome.failedCycles += 1;
-      } else outcome.appliedCycles += 1;
-      outcome.lastStatus = result.status;
-      onCycle?.(outcome.cycles, { result });
-    } catch (err) {
-      outcome.cycles += 1;
-      outcome.failedCycles += 1;
-      outcome.lastStatus = "error";
-      onCycle?.(outcome.cycles, { error: err });
-    }
-    if (maxCycles !== void 0 && outcome.cycles >= maxCycles) break;
-    const slept = await sleepAborted(intervalMs, signal ?? new AbortController().signal);
-    if (!slept) break;
-  }
-  return outcome;
-}
-
 // src/converge.ts
 async function discoverCursorNamespaces(memoryDir, peerUrl) {
   const cursorDir = path7.join(path7.resolve(memoryDir), ".remnic", "state", "converge-cursors");
@@ -4302,7 +4558,22 @@ async function computeConvergePlan(options = {}) {
   const peerDeletionMtimeMs = /* @__PURE__ */ new Map();
   const localManifests = /* @__PURE__ */ new Map();
   const peerManifests = /* @__PURE__ */ new Map();
+  const excluded = /* @__PURE__ */ new Map();
+  const sharedRootAliases = /* @__PURE__ */ new Map();
   let peerPlatform;
+  const dropPlannedNamespace = (namespace) => {
+    namespacesToPlan.delete(namespace);
+    baseMap.delete(namespace);
+    semanticAgreementMap.delete(namespace);
+    localMap.delete(namespace);
+    localTombstones.delete(namespace);
+    localDeletionMtimeMs.delete(namespace);
+    localManifests.delete(namespace);
+    peerMap.delete(namespace);
+    peerTombstones.delete(namespace);
+    peerDeletionMtimeMs.delete(namespace);
+    peerManifests.delete(namespace);
+  };
   if (options.baseFilesByNamespace) {
     for (const [ns, files] of options.baseFilesByNamespace) {
       namespacesToPlan.add(ns);
@@ -4382,27 +4653,32 @@ async function computeConvergePlan(options = {}) {
       }
       for (const [rootIndex, rootInfo] of roots.entries()) {
         namespacesToPlan.add(rootInfo.namespace);
-        const census = await planLocalNamespaceCensus({
-          rootDir: rootInfo.rootDir,
-          namespace: rootInfo.namespace,
-          index: rootIndex + 1,
-          total: roots.length,
-          citationTemplate: config.inlineSourceAttributionFormat,
-          cache,
-          signal: options.signal,
-          onProgress: options.onProgress,
-          memoryDir,
-          peerUrl: options.peerUrl,
-          userExcludeRegexps
-        });
-        localMap.set(rootInfo.namespace, census.files);
-        localManifests.set(rootInfo.namespace, census.manifest);
-        localTombstones.set(rootInfo.namespace, census.tombstones);
+        for (const alias of rootInfo.namespaces) sharedRootAliases.set(alias, rootInfo.namespaces);
+        try {
+          const census = await planLocalNamespaceCensus({
+            rootDir: rootInfo.rootDir,
+            namespace: rootInfo.namespace,
+            index: rootIndex + 1,
+            total: roots.length,
+            citationTemplate: config.inlineSourceAttributionFormat,
+            cache,
+            signal: options.signal,
+            onProgress: options.onProgress,
+            memoryDir,
+            peerUrl: options.peerUrl,
+            userExcludeRegexps
+          });
+          localMap.set(rootInfo.namespace, census.files);
+          localManifests.set(rootInfo.namespace, census.manifest);
+          localTombstones.set(rootInfo.namespace, census.tombstones);
+        } catch (error) {
+          excludeNamespaceGroup(excluded, rootInfo.namespaces, "local", error, options.signal, dropPlannedNamespace);
+        }
       }
     }
     if (memoryDir && peerUrl) {
       for (const namespace of await discoverCursorNamespaces(memoryDir, peerUrl)) {
-        namespacesToPlan.add(namespace);
+        if (!excluded.has(namespace)) namespacesToPlan.add(namespace);
       }
     }
     if (!options.peerFilesByNamespace && peerUrl) {
@@ -4422,27 +4698,34 @@ async function computeConvergePlan(options = {}) {
       peerPlatform = capabilities?.platform;
       const sortedNamespaces = [...namespacesToPlan].sort();
       for (const [nsIndex, ns] of sortedNamespaces.entries()) {
-        const census = await planPeerNamespaceCensus({
-          peerUrl,
-          namespace: ns,
-          index: nsIndex + 1,
-          total: sortedNamespaces.length,
-          resolvedToken,
-          fetchFn,
-          timeoutMs,
-          manifestStream: capabilities?.manifestStream === true,
-          peerManifestRevision: capabilities?.manifestRevision,
-          citationTemplate: config?.inlineSourceAttributionFormat,
-          localManifestFiles: localManifests.get(ns)?.files,
-          cache,
-          signal: options.signal,
-          onProgress: options.onProgress
-        });
-        peerMap.set(ns, census.manifest.files);
-        peerManifests.set(ns, census.manifest);
-        peerTombstones.set(ns, census.tombstones);
+        if (excluded.has(ns)) continue;
+        try {
+          const census = await planPeerNamespaceCensus({
+            peerUrl,
+            namespace: ns,
+            index: nsIndex + 1,
+            total: sortedNamespaces.length,
+            resolvedToken,
+            fetchFn,
+            timeoutMs,
+            manifestStream: capabilities?.manifestStream === true,
+            peerManifestRevision: capabilities?.manifestRevision,
+            citationTemplate: config?.inlineSourceAttributionFormat,
+            localManifestFiles: localManifests.get(ns)?.files,
+            cache,
+            signal: options.signal,
+            onProgress: options.onProgress
+          });
+          peerMap.set(ns, census.manifest.files);
+          peerManifests.set(ns, census.manifest);
+          peerTombstones.set(ns, census.tombstones);
+        } catch (error) {
+          const aliases = sharedRootAliases.get(ns) ?? [ns];
+          excludeNamespaceGroup(excluded, aliases, "peer", error, options.signal, dropPlannedNamespace);
+        }
       }
     }
+    throwIfEveryNamespaceCensusFailed(namespacesToPlan.size, excluded);
     if (memoryDir && options.peerUrl && (!options.baseFilesByNamespace || !options.semanticAgreementsByNamespace)) {
       for (const ns of namespacesToPlan) {
         const cursorPath = defaultConvergeCursorPath(memoryDir, options.peerUrl, ns);
@@ -4465,6 +4748,7 @@ async function computeConvergePlan(options = {}) {
     }
     const inputs = [];
     for (const ns of [...namespacesToPlan].sort()) {
+      if (excluded.has(ns)) continue;
       const baseFiles = baseMap.get(ns);
       const localFiles = localMap.get(ns) ?? [];
       const peerFiles = peerMap.get(ns) ?? [];
@@ -4482,8 +4766,11 @@ async function computeConvergePlan(options = {}) {
       });
     }
     const conflictPolicy = options.conflictPolicy ?? config?.converge.conflictPolicy ?? DEFAULT_CONVERGE_CONFLICT_POLICY;
-    const plan = planReconciliation(inputs, { conflictPolicy, peerPlatform });
-    return collapseActiveFactDuplicates(plan, localManifests, peerManifests, semanticAgreementMap);
+    const planned = planReconciliation(inputs, { conflictPolicy, peerPlatform });
+    const plan = collapseActiveFactDuplicates(planned, localManifests, peerManifests, semanticAgreementMap);
+    const excludedNamespaces = listNamespaceExclusions(excluded);
+    if (excludedNamespaces.length === 0) return plan;
+    return { ...plan, excludedNamespaces, converged: false };
   } finally {
     await cache?.close();
   }
@@ -4495,25 +4782,27 @@ async function executeConvergeApply(options = {}) {
   }
   const conflictPolicy = options.conflictPolicy ?? options.config?.converge.conflictPolicy ?? DEFAULT_CONVERGE_CONFLICT_POLICY;
   const plan = await computeConvergePlan({ ...options, conflictPolicy });
+  const excludedNamespaces = plan.excludedNamespaces ?? [];
+  const finish = (result) => finishConvergeApplyResult(result, excludedNamespaces);
   if (plan.converged && !options.dryRun) {
     await updateCursorsForPlan(plan, options);
-    return {
+    return finish({
       converged: true,
       status: "converged",
       plan,
       transfers: { pulled: 0, pushed: 0, conflictsResolved: 0, suppressed: 0, failed: 0 },
       cursorUpdated: true
-    };
+    });
   }
   const unresolvedCount = plan.byNamespace.reduce((acc, report) => acc + report.unresolved, 0);
   if (unresolvedCount > 0) {
-    return {
+    return finish({
       converged: false,
       status: "stopped_unresolved_conflicts",
       plan,
       transfers: { pulled: 0, pushed: 0, conflictsResolved: 0, suppressed: 0, failed: 0 },
       cursorUpdated: false
-    };
+    });
   }
   const plannedTransfers = {
     pulled: 0,
@@ -4529,13 +4818,13 @@ async function executeConvergeApply(options = {}) {
     else if (entry.action === "suppress") plannedTransfers.suppressed += 1;
   }
   if (options.dryRun) {
-    return {
+    return finish({
       converged: plan.converged,
       status: "dry_run",
       plan,
       transfers: plannedTransfers,
       cursorUpdated: false
-    };
+    });
   }
   const actualTransfers = {
     pulled: 0,
@@ -4930,7 +5219,14 @@ async function executeConvergeApply(options = {}) {
   options.signal?.throwIfAborted();
   if (options.peerUrl && peerMutatedNamespaces.size > 0) {
     const namespaces = [...peerMutatedNamespaces].sort();
-    if (!await postPeerConvergenceComplete(options.peerUrl, namespaces, resolvedToken, fetchFn, timeoutMs, options.signal)) {
+    if (!await postPeerConvergenceComplete(
+      options.peerUrl,
+      namespaces,
+      resolvedToken,
+      fetchFn,
+      timeoutMs,
+      options.signal
+    )) {
       actualTransfers.failed += 1;
     }
   }
@@ -4940,13 +5236,13 @@ async function executeConvergeApply(options = {}) {
     await updateCursorsForPlan(plan, options);
     cursorUpdated = true;
   }
-  return {
+  return finish({
     converged: actualTransfers.failed === 0,
     status: "applied",
     plan,
     transfers: actualTransfers,
     cursorUpdated
-  };
+  });
 }
 async function updateCursorsForPlan(plan, options) {
   const peerUrl = normalizeConvergePeerUrl3(options.peerUrl ?? "local");
@@ -5095,24 +5391,25 @@ Subcommands:
         intervalMs: intervalSeconds !== void 0 ? intervalSeconds * 1e3 : void 0,
         ...timeoutMsFlag !== void 0 ? { peerRequestTimeoutMs: timeoutMsFlag } : {},
         signal: controller2.signal,
-        onCycle: json ? void 0 : (cycle, event) => {
+        onCycle: (cycle, event) => {
           if (event.error !== void 0) {
             console.error(`converge watch: cycle ${cycle} failed: ${String(event.error)}`);
             return;
           }
           const result = event.result;
           if (!result) return;
-          const transfers = result.transfers;
-          console.log(
-            `converge watch: cycle ${cycle} status=${result.status} pulled=${transfers.pulled} pushed=${transfers.pushed} conflicts=${transfers.conflictsResolved} failed=${transfers.failed}`
-          );
+          for (const exclusion of result.excludedNamespaces ?? []) {
+            console.error(formatConvergeExclusionLine(cycle, exclusion));
+          }
+          if (json) return;
+          console.log(formatConvergeWatchCycleLine(cycle, result));
         }
       });
       if (json) {
         console.log(JSON.stringify(outcome, null, 2));
       } else {
         console.log(
-          `converge watch stopped after ${outcome.cycles} cycle(s): ${outcome.convergedCycles} converged, ${outcome.appliedCycles} applied, ${outcome.failedCycles} failed (last: ${outcome.lastStatus}).`
+          `converge watch stopped after ${outcome.cycles} cycle(s): ${outcome.convergedCycles} converged, ${outcome.appliedCycles} applied, ${outcome.failedCycles} failed (last: ${outcome.lastStatus}, excluded: ${outcome.lastExcludedNamespaces.length}).`
         );
       }
     } finally {
@@ -5145,6 +5442,10 @@ Subcommands:
         signal: controller.signal,
         onProgress
       });
+      for (const exclusion of plan.excludedNamespaces ?? []) {
+        process.stderr.write(`${formatConvergeExclusionLine(void 0, exclusion)}
+`);
+      }
       if (json) {
         console.log(JSON.stringify(plan, null, 2));
       } else {
@@ -5162,6 +5463,10 @@ Subcommands:
       signal: controller.signal,
       onProgress
     });
+    for (const exclusion of result.excludedNamespaces ?? []) {
+      process.stderr.write(`${formatConvergeExclusionLine(void 0, exclusion)}
+`);
+    }
     if (json) {
       console.log(JSON.stringify(result, null, 2));
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/cli",
-  "version": "10.0.8",
+  "version": "10.0.10",
   "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": "^10.0.8",
-    "@remnic/core": "^10.0.8",
-    "@remnic/server": "^10.0.8"
+    "@remnic/plugin-pi": "^10.0.10",
+    "@remnic/server": "^10.0.10",
+    "@remnic/core": "^10.0.10"
   },
   "peerDependencies": {
-    "@remnic/bench": "^10.0.8",
-    "@remnic/plugin-openclaw": "^10.0.8",
-    "@remnic/export-weclone": "^10.0.8",
-    "@remnic/import-weclone": "^10.0.8",
-    "@remnic/import-chatgpt": "^10.0.8",
-    "@remnic/import-claude": "^10.0.8",
-    "@remnic/import-gemini": "^10.0.8",
-    "@remnic/import-lossless-claw": "^10.0.8",
-    "@remnic/import-mem0": "^10.0.8",
-    "@remnic/import-supermemory": "^10.0.8",
-    "@remnic/import-okf": "^10.0.8",
-    "@remnic/connector-limitless": "^10.0.8",
-    "@remnic/connector-bee": "^10.0.8",
-    "@remnic/connector-omi": "^10.0.8",
-    "@remnic/capture-audio": "^10.0.8"
+    "@remnic/bench": "^10.0.10",
+    "@remnic/plugin-openclaw": "^10.0.10",
+    "@remnic/export-weclone": "^10.0.10",
+    "@remnic/import-weclone": "^10.0.10",
+    "@remnic/import-chatgpt": "^10.0.10",
+    "@remnic/import-claude": "^10.0.10",
+    "@remnic/import-gemini": "^10.0.10",
+    "@remnic/import-lossless-claw": "^10.0.10",
+    "@remnic/import-mem0": "^10.0.10",
+    "@remnic/import-supermemory": "^10.0.10",
+    "@remnic/import-okf": "^10.0.10",
+    "@remnic/connector-limitless": "^10.0.10",
+    "@remnic/connector-bee": "^10.0.10",
+    "@remnic/connector-omi": "^10.0.10",
+    "@remnic/capture-audio": "^10.0.10"
   },
   "peerDependenciesMeta": {
     "@remnic/bench": {
@@ -97,19 +97,19 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@remnic/plugin-openclaw": "10.0.8",
-    "@remnic/bench": "10.0.8",
-    "@remnic/import-weclone": "10.0.8",
-    "@remnic/export-weclone": "10.0.8",
-    "@remnic/import-chatgpt": "10.0.8",
-    "@remnic/import-claude": "10.0.8",
-    "@remnic/import-gemini": "10.0.8",
-    "@remnic/import-lossless-claw": "10.0.8",
-    "@remnic/import-mem0": "10.0.8",
-    "@remnic/import-supermemory": "10.0.8",
-    "@remnic/connector-bee": "10.0.8",
-    "@remnic/connector-limitless": "10.0.8",
-    "@remnic/connector-omi": "10.0.8"
+    "@remnic/bench": "10.0.10",
+    "@remnic/plugin-openclaw": "10.0.10",
+    "@remnic/export-weclone": "10.0.10",
+    "@remnic/import-weclone": "10.0.10",
+    "@remnic/import-chatgpt": "10.0.10",
+    "@remnic/import-claude": "10.0.10",
+    "@remnic/import-gemini": "10.0.10",
+    "@remnic/import-lossless-claw": "10.0.10",
+    "@remnic/import-mem0": "10.0.10",
+    "@remnic/import-supermemory": "10.0.10",
+    "@remnic/connector-limitless": "10.0.10",
+    "@remnic/connector-bee": "10.0.10",
+    "@remnic/connector-omi": "10.0.10"
   },
   "license": "MIT",
   "repository": {