@remnic/cli 1.0.25 → 9.3.517

package/dist/index.js

@@ -851,7 +851,12 @@ function validateBenchFlags(action, args) {
     if (!arg.startsWith("-")) {
       continue;
     }
-    if (allowed.legacyEqualsPrefixes?.some((prefix) => arg.startsWith(prefix))) {
+    const legacyEqualsPrefix = allowed.legacyEqualsPrefixes?.find((prefix) => arg.startsWith(prefix));
+    if (legacyEqualsPrefix) {
+      const value = arg.slice(legacyEqualsPrefix.length);
+      if (value.trim().length === 0) {
+        throw new Error(`ERROR: ${legacyEqualsPrefix.slice(0, -1)} requires a value.`);
+      }
       continue;
     }
     if (isBenchValueFlag(arg)) {
@@ -1974,6 +1979,66 @@ function isCandidateReady(candidate, existsSync3) {
 function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
+function readVerifiedDaemonPid(options) {
+  const readFileSync3 = options.readFileSync ?? fs4.readFileSync;
+  const unlinkSync = options.unlinkSync ?? fs4.unlinkSync;
+  const processKill = options.processKill ?? process.kill;
+  const execFileSync3 = options.execFileSync ?? ((command, args, execOptions) => childProcess.execFileSync(command, args, execOptions));
+  for (const file of options.pidFiles) {
+    let pid;
+    try {
+      pid = parseDaemonPid(readFileSync3(file, "utf8"));
+    } catch {
+      continue;
+    }
+    if (pid === void 0) {
+      removePidFileBestEffort(file, unlinkSync);
+      continue;
+    }
+    try {
+      processKill(pid, 0);
+    } catch {
+      removePidFileBestEffort(file, unlinkSync);
+      continue;
+    }
+    const command = readProcessCommand(pid, execFileSync3);
+    if (command === void 0) {
+      return pid;
+    }
+    if (doesProcessCommandLookLikeRemnicDaemon(command, options.expectedServerBin)) {
+      return pid;
+    }
+    removePidFileBestEffort(file, unlinkSync);
+  }
+  return void 0;
+}
+function doesProcessCommandLookLikeRemnicDaemon(command, expectedServerBin) {
+  const normalizedCommand = command.trim();
+  const normalizedExpected = path8.resolve(expandTilde(expectedServerBin));
+  return normalizedCommand.includes(normalizedExpected) || /(?:^|\s|[/\\])(?:remnic-server|engram-server)(?:\.js)?(?:\s|$)/.test(normalizedCommand) || /@remnic[/\\]server[/\\]/.test(normalizedCommand) || /packages[/\\]remnic-server[/\\](?:bin[/\\]remnic-server\.js|dist[/\\]index\.js|src[/\\]index\.ts)/.test(normalizedCommand);
+}
+function parseDaemonPid(raw) {
+  const trimmed = raw.trim();
+  if (!/^\d+$/.test(trimmed)) return void 0;
+  const pid = Number(trimmed);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+function readProcessCommand(pid, execFileSync3) {
+  try {
+    return execFileSync3("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+  } catch {
+    return void 0;
+  }
+}
+function removePidFileBestEffort(file, unlinkSync) {
+  try {
+    unlinkSync(file);
+  } catch {
+  }
+}
 function inspectLaunchdPlist(plistPath, options = {}) {
   const existsSync3 = options.existsSync ?? fs4.existsSync;
   const readFileSync3 = options.readFileSync ?? fs4.readFileSync;
@@ -2432,7 +2497,8 @@ Usage:
 
 Required:
   --adapter <name>            One of: ${SUPPORTED_IMPORTERS.join(" | ")}
-  --file <path>               Path to the source export (JSON or ZIP). May be
+  --file <path>               Path to a text/JSON source export. ZIP archives
+                              are not accepted by this single-file path yet. May be
                               omitted for API-only adapters (mem0).
 
 Options:
@@ -2523,6 +2589,11 @@ function rejectLeftoverImportArgs(args, command) {
   }
 }
 async function runImportCommand(args, io) {
+  if (args.file && isZipFilePath(args.file)) {
+    throw new Error(
+      `ZIP imports are not supported by --file yet: '${args.file}'. Extract the archive first or use --all-from-bundle for supported bundle layouts.`
+    );
+  }
   const adapter = await io.loadAdapter(args.adapter);
   let input;
   if (args.file) {
@@ -2575,6 +2646,16 @@ async function runImportCommand(args, io) {
   }
   return result;
 }
+function isZipFilePath(filePath) {
+  return pathExtension(filePath) === ".zip";
+}
+function pathExtension(filePath) {
+  const normalized = filePath.trim().toLowerCase();
+  const lastSlash = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf("\\"));
+  const base = normalized.slice(lastSlash + 1);
+  const dot = base.lastIndexOf(".");
+  return dot >= 0 ? base.slice(dot) : "";
+}
 function parseImportBundleArgs(rest) {
   const args = [...rest];
   if (!args.includes("--all-from-bundle")) return void 0;
@@ -3837,7 +3918,8 @@ var __benchDatasetTestHooks = {
       seed,
       benchmarkOptions
     );
-  }
+  },
+  printBenchStatusLineForTest: printBenchStatusLine
 };
 function printBenchPackageSummary(result, outputPath, outputLabel = "Results saved") {
   console.log(`Benchmark: ${result.meta.benchmark}`);
@@ -3852,6 +3934,13 @@ function printBenchPackageSummary(result, outputPath, outputLabel = "Results sav
   }
   console.log(`${outputLabel}: ${outputPath}`);
 }
+function printBenchStatusLine(jsonMode, message) {
+  if (jsonMode) {
+    console.error(message);
+  } else {
+    console.log(message);
+  }
+}
 function printStoredBenchResultSummary(result, summary) {
   printBenchPackageSummary(result, summary.path, "Stored result");
   console.log(`Run id: ${summary.id}`);
@@ -4672,7 +4761,8 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
         if (completed % 50 === 0 || completed === total) {
           const elapsed = Math.round((Date.now() - benchStartTime) / 1e3);
           const remaining = total && elapsed > 0 ? Math.round((total - completed) / (completed / elapsed)) : "?";
-          console.log(
+          printBenchStatusLine(
+            parsed.json,
             `  [${benchmarkId}] ${completed}/${total ?? "?"} tasks (${elapsed}s elapsed, ~${remaining}s remaining)`
           );
         }
@@ -6614,7 +6704,7 @@ function normalizeOfflineRemoteUrl(raw) {
   return parsed.toString().replace(/\/$/, "");
 }
 function resolveOptionalOfflineRemoteUrl(args) {
-  const raw = resolveRequiredValueFlag(args, "--remote-url") ?? process.env.REMNIC_OFFLINE_REMOTE_URL ?? process.env.ENGRAM_OFFLINE_REMOTE_URL;
+  const raw = resolveRequiredValueFlag(args, "--remote-url") ?? resolveRequiredValueFlag(args, "--remote") ?? process.env.REMNIC_OFFLINE_REMOTE_URL ?? process.env.ENGRAM_OFFLINE_REMOTE_URL;
   if (!raw || raw.trim().length === 0) return void 0;
   return normalizeOfflineRemoteUrl(raw);
 }
@@ -6672,6 +6762,12 @@ function offlineRequestTimeoutMs() {
     process.env.REMNIC_OFFLINE_REQUEST_TIMEOUT_MS ?? process.env.ENGRAM_OFFLINE_REQUEST_TIMEOUT_MS
   );
 }
+function offlineSnapshotPostTimeoutMs() {
+  return parseOfflineSyncRequestTimeoutMs(
+    process.env.REMNIC_OFFLINE_SNAPSHOT_POST_TIMEOUT_MS ?? process.env.ENGRAM_OFFLINE_SNAPSHOT_POST_TIMEOUT_MS,
+    Math.min(offlineRequestTimeoutMs(), 6e4)
+  );
+}
 function offlineFetchHeaders(token, initHeaders, defaultContentType) {
   const headers = new Headers(initHeaders);
   headers.set("authorization", `Bearer ${token}`);
@@ -6842,18 +6938,23 @@ async function fetchOfflineSnapshot(args) {
       const postRequest = offlineSnapshotBasePostRequest(postBody);
       if (postRequest) {
         const postRequestUsesGzip = new Headers(postRequest.headers).get("content-encoding")?.toLowerCase() === "gzip";
+        const postAbort = new AbortController();
+        const postTimeout = setTimeout(() => postAbort.abort(), offlineSnapshotPostTimeoutMs());
         try {
           return await fetchOfflineJson(
             offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot"),
             args.token,
             {
               method: "POST",
+              signal: postAbort.signal,
               ...postRequest
             }
           );
         } catch (error) {
           if (!isOfflineSnapshotPostFallbackError(error, { compressed: postRequestUsesGzip })) throw error;
           tryStreamSnapshot = true;
+        } finally {
+          clearTimeout(postTimeout);
         }
       } else {
         tryStreamSnapshot = true;
@@ -6915,6 +7016,9 @@ function offlineSnapshotBasePostRequest(body) {
 function isOfflineSnapshotPostFallbackError(error, options = {}) {
   const message = error instanceof Error ? error.message : String(error);
   if (/offline-sync\/snapshot\b.* returned (404|405|413)\b/.test(message)) return true;
+  if (/^offline sync request timed out after \d+ms: POST .*\/offline-sync\/snapshot\b/.test(message) || /^offline sync request failed before response: POST .*\/offline-sync\/snapshot\b/.test(message) || /^(This operation was aborted|The operation was aborted|AbortError)/i.test(message)) {
+    return true;
+  }
   if (!options.compressed) return false;
   return /offline-sync\/snapshot\b.* returned (400|415)\b/.test(message) && /\b(unsupported_content_encoding|invalid_gzip_body|invalid_json)\b/.test(message);
 }
@@ -6950,6 +7054,8 @@ var OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES = Math.min(
 );
 var OFFLINE_SYNC_DIRECT_HYDRATE_MIN_BYTES = OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES;
 var OFFLINE_SYNC_CHANGESET_RETRY_MAX = 1024;
+var OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX = 3;
+var OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS = 250;
 var OfflineRemoteFileChangedError = class extends Error {
   path;
   constructor(path12) {
@@ -7431,10 +7537,53 @@ function isOfflineFilesUnsupportedError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /offline sync request failed: .* returned 404\b/.test(message);
 }
+var OfflineMissingContentError = class extends Error {
+  missing;
+  constructor(missing) {
+    const preview = missing.slice(0, 8).map((file) => file.path).join(", ");
+    const suffix = missing.length > 8 ? `, ... +${missing.length - 8} more` : "";
+    super(
+      `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}: ${preview}${suffix}; retry sync`
+    );
+    this.name = "OfflineMissingContentError";
+    this.missing = missing;
+  }
+};
 function isMissingOfflineContentError(error) {
+  if (error instanceof OfflineMissingContentError) return true;
   const message = error instanceof Error ? error.message : String(error);
   return /^missing decoded content for /.test(message);
 }
+function formatMissingOfflineContentError(missing) {
+  return new OfflineMissingContentError(missing);
+}
+function isOfflineMissingContentDeferrablePath(relPath) {
+  const parts = relPath.split("/");
+  return parts[0] === "profiling" || parts[0] === "namespaces" && parts[2] === "profiling";
+}
+function deferMissingOfflineContent(missing, deferredPaths) {
+  if (!deferredPaths) return [...missing];
+  const stillMissing = [];
+  for (const file of missing) {
+    if (isOfflineMissingContentDeferrablePath(file.path)) {
+      deferredPaths.add(file.path);
+    } else {
+      stillMissing.push(file);
+    }
+  }
+  return stillMissing;
+}
+function formatMissingDecodedContentError(missing) {
+  const preview = missing.slice(0, 8).map((file) => file.path).join(", ");
+  const suffix = missing.length > 8 ? `, ... +${missing.length - 8} more` : "";
+  return new Error(
+    `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}: ${preview}${suffix}; retry sync`
+  );
+}
+async function waitForMissingOfflineContentRetry(delayMs) {
+  if (delayMs <= 0) return;
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
 async function hydrateOfflineSnapshotContent(args) {
   const snapshot = normalizeOfflineSyncSnapshot(args.snapshot);
   const neededFiles = offlineSnapshotContentFilesForApply({
@@ -7448,26 +7597,47 @@ async function hydrateOfflineSnapshotContent(args) {
   const expectedByPath = new Map(snapshot.files.map((file) => [file.path, file]));
   const contentByPath = /* @__PURE__ */ new Map();
   const updatedByPath = /* @__PURE__ */ new Map();
+  const fetchFiles = args.fetchFiles ?? fetchOfflineFiles;
+  const retryMax = args.missingContentRetryMax ?? OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX;
+  const retryDelayMs = args.missingContentRetryDelayMs ?? OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS;
+  if (!Number.isInteger(retryMax) || retryMax < 0) {
+    throw new Error("offline sync missing content retry max must be an integer >= 0");
+  }
+  if (!Number.isInteger(retryDelayMs) || retryDelayMs < 0) {
+    throw new Error("offline sync missing content retry delay must be an integer >= 0");
+  }
   try {
-    for (const batch of chunkOfflineFileContentBatches(neededFiles)) {
-      const partial = await fetchOfflineFiles({
-        remoteUrl: args.remoteUrl,
-        token: args.token,
-        namespace: args.namespace,
-        includeTranscripts: args.includeTranscripts,
-        paths: batch.map((file) => file.path)
-      });
-      for (const file of partial.files) {
-        const expected = expectedByPath.get(file.path);
-        if (!expected) continue;
-        if (typeof file.contentBase64 !== "string") {
-          throw new Error(`remote offline content response omitted contentBase64 for ${file.path}`);
-        }
-        if (file.sha256 !== expected.sha256 || file.bytes !== expected.bytes || file.mtimeMs !== expected.mtimeMs) {
-          updatedByPath.set(file.path, file);
+    let pendingFiles = neededFiles;
+    for (let attempt = 0; ; attempt += 1) {
+      for (const batch of chunkOfflineFileContentBatches(pendingFiles)) {
+        const partial = await fetchFiles({
+          remoteUrl: args.remoteUrl,
+          token: args.token,
+          namespace: args.namespace,
+          includeTranscripts: args.includeTranscripts,
+          paths: batch.map((file) => file.path)
+        });
+        for (const file of partial.files) {
+          const expected = expectedByPath.get(file.path);
+          if (!expected) continue;
+          if (typeof file.contentBase64 !== "string") {
+            throw new Error(`remote offline content response omitted contentBase64 for ${file.path}`);
+          }
+          if (file.sha256 !== expected.sha256 || file.bytes !== expected.bytes || file.mtimeMs !== expected.mtimeMs) {
+            updatedByPath.set(file.path, file);
+          }
+          contentByPath.set(file.path, file.contentBase64);
         }
-        contentByPath.set(file.path, file.contentBase64);
       }
+      const missing2 = pendingFiles.filter((file) => !contentByPath.has(file.path));
+      if (missing2.length === 0) break;
+      if (attempt >= retryMax) {
+        const stillMissing = deferMissingOfflineContent(missing2, args.missingContentDeferredPaths);
+        if (stillMissing.length > 0) throw formatMissingOfflineContentError(stillMissing);
+        break;
+      }
+      pendingFiles = missing2;
+      await waitForMissingOfflineContentRetry(retryDelayMs);
     }
   } catch (error) {
     if (!isOfflineFilesUnsupportedError(error)) throw error;
@@ -7479,10 +7649,10 @@ async function hydrateOfflineSnapshotContent(args) {
       includeContent: true
     });
   }
-  const missing = neededFiles.map((file) => file.path).filter((relPath) => !contentByPath.has(relPath));
+  const missing = neededFiles.map((file) => file.path).filter((relPath) => !contentByPath.has(relPath) && !args.missingContentDeferredPaths?.has(relPath));
   if (missing.length > 0) {
-    throw new Error(
-      `remote offline content response omitted ${missing.length} changed file${missing.length === 1 ? "" : "s"}; retry sync`
+    throw formatMissingDecodedContentError(
+      neededFiles.filter((file) => missing.includes(file.path))
     );
   }
   return {
@@ -8141,7 +8311,8 @@ async function runOfflineSyncOnce(options) {
       snapshot: remoteSnapshotMetadata,
       baseFiles,
       currentFiles: applyCurrentSnapshot.files,
-      deferredPaths: [...remoteDeferredPaths]
+      deferredPaths: [...remoteDeferredPaths],
+      missingContentDeferredPaths: remoteDeferredPaths
     });
   } catch (error) {
     if (pushed || partialHydration.hydratedFiles.length > 0) {
@@ -8185,7 +8356,8 @@ async function runOfflineSyncOnce(options) {
         snapshot: remoteSnapshotMetadata,
         baseFiles,
         currentFiles: applyCurrentSnapshot.files,
-        deferredPaths: [...remoteDeferredPaths]
+        deferredPaths: [...remoteDeferredPaths],
+        missingContentDeferredPaths: remoteDeferredPaths
       });
     } catch (retryError) {
       if (pushed || partialHydration.hydratedFiles.length > 0) {
@@ -8307,7 +8479,7 @@ async function cmdOffline(action, rest, json) {
     console.log(`Usage: remnic offline <prepare|sync|status|watch> [options]
 
 Options:
-  --remote-url <url>       Remote Remnic server URL, e.g. http://home:4242
+  --remote-url <url>       Remote Remnic server URL, e.g. http://home:4242 (--remote alias accepted)
   --token <token>          Bearer token for the remote server
   --namespace <name>       Namespace to sync
   --memory-dir <dir>       Local memory dir (defaults to resolved memoryDir)
@@ -8809,109 +8981,113 @@ async function cmdConnectors(action, rest, json) {
     const remnicCfg = raw.remnic ?? raw.engram ?? raw;
     const config = parseConfig(remnicCfg);
     const orchestrator = new Orchestrator(config);
-    await orchestrator.initialize();
-    await orchestrator.deferredReady;
-    const cfg = config.connectors;
-    const sharedIngestFn = async (docs) => {
-      const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const turns = docs.map((doc) => ({
-        role: "assistant",
-        content: doc.title ? `# ${doc.title}
+    try {
+      await orchestrator.initialize();
+      await orchestrator.deferredReady;
+      const cfg = config.connectors;
+      const sharedIngestFn = async (docs) => {
+        const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const turns = docs.map((doc) => ({
+          role: "assistant",
+          content: doc.title ? `# ${doc.title}
 
 ${doc.content}` : doc.content,
-        timestamp: fetchedAt
-      }));
-      await orchestrator.ingestBulkImportBatch(turns);
-    };
-    const makeWriteCursorFn = (id) => async (state) => {
-      await writeLiveConnectorState(config.memoryDir, id, {
-        id,
-        cursor: state.cursor,
-        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
-        lastSyncStatus: state.lastSyncStatus,
-        ...state.lastSyncError !== void 0 ? { lastSyncError: state.lastSyncError } : {},
-        totalDocsImported: state.totalDocsImported
-      });
-    };
-    let runResult;
-    if (connectorName === GDRIVE_ID) {
-      if (!cfg?.googleDrive?.enabled) {
-        process.stderr.write(
-          `connectors run: connector "${connectorName}" is disabled. Set connectors.googleDrive.enabled=true in config.
+          timestamp: fetchedAt
+        }));
+        await orchestrator.ingestBulkImportBatch(turns);
+      };
+      const makeWriteCursorFn = (id) => async (state) => {
+        await writeLiveConnectorState(config.memoryDir, id, {
+          id,
+          cursor: state.cursor,
+          lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastSyncStatus: state.lastSyncStatus,
+          ...state.lastSyncError !== void 0 ? { lastSyncError: state.lastSyncError } : {},
+          totalDocsImported: state.totalDocsImported
+        });
+      };
+      let runResult;
+      if (connectorName === GDRIVE_ID) {
+        if (!cfg?.googleDrive?.enabled) {
+          process.stderr.write(
+            `connectors run: connector "${connectorName}" is disabled. Set connectors.googleDrive.enabled=true in config.
 `
-        );
-        process.exitCode = 1;
-        return;
-      }
-      let validatedCfg;
-      try {
-        validatedCfg = validateGDriveCfg(cfg.googleDrive);
-      } catch (err) {
-        process.stderr.write(
-          `connectors run: invalid config for "${connectorName}": ${err instanceof Error ? err.message : String(err)}
+          );
+          process.exitCode = 1;
+          return;
+        }
+        let validatedCfg;
+        try {
+          validatedCfg = validateGDriveCfg(cfg.googleDrive);
+        } catch (err) {
+          process.stderr.write(
+            `connectors run: invalid config for "${connectorName}": ${err instanceof Error ? err.message : String(err)}
 `
-        );
-        process.exitCode = 1;
-        return;
-      }
-      const connector = makeGDriveConnector();
-      const state = await readLiveConnectorState(config.memoryDir, connectorName);
-      runResult = await pollOnce({
-        connectorId: connectorName,
-        priorState: state,
-        syncFn: (cursor) => connector.syncIncremental({
-          cursor,
-          config: validatedCfg
-        }),
-        ingestFn: sharedIngestFn,
-        writeCursorFn: makeWriteCursorFn(connectorName)
-      });
-    } else if (connectorName === NOTION_ID) {
-      if (!cfg?.notion?.enabled) {
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const connector = makeGDriveConnector();
+        const state = await readLiveConnectorState(config.memoryDir, connectorName);
+        runResult = await pollOnce({
+          connectorId: connectorName,
+          priorState: state,
+          syncFn: (cursor) => connector.syncIncremental({
+            cursor,
+            config: validatedCfg
+          }),
+          ingestFn: sharedIngestFn,
+          writeCursorFn: makeWriteCursorFn(connectorName)
+        });
+      } else if (connectorName === NOTION_ID) {
+        if (!cfg?.notion?.enabled) {
+          process.stderr.write(
+            `connectors run: connector "${connectorName}" is disabled. Set connectors.notion.enabled=true in config.
+`
+          );
+          process.exitCode = 1;
+          return;
+        }
+        let validatedCfg;
+        try {
+          validatedCfg = validateNotionCfg(cfg.notion);
+        } catch (err) {
+          process.stderr.write(
+            `connectors run: invalid config for "${connectorName}": ${err instanceof Error ? err.message : String(err)}
+`
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const connector = makeNotionConnector();
+        const state = await readLiveConnectorState(config.memoryDir, connectorName);
+        runResult = await pollOnce({
+          connectorId: connectorName,
+          priorState: state,
+          syncFn: (cursor) => connector.syncIncremental({
+            cursor,
+            config: validatedCfg
+          }),
+          ingestFn: sharedIngestFn,
+          writeCursorFn: makeWriteCursorFn(connectorName)
+        });
+      } else {
         process.stderr.write(
-          `connectors run: connector "${connectorName}" is disabled. Set connectors.notion.enabled=true in config.
+          `connectors run: unknown connector "${connectorName}". Known connectors: ${GDRIVE_ID}, ${NOTION_ID}.
 `
         );
         process.exitCode = 1;
         return;
       }
-      let validatedCfg;
-      try {
-        validatedCfg = validateNotionCfg(cfg.notion);
-      } catch (err) {
-        process.stderr.write(
-          `connectors run: invalid config for "${connectorName}": ${err instanceof Error ? err.message : String(err)}
-`
-        );
+      const output = renderRunResult(connectorName, runResult, format);
+      if (runResult.error !== void 0 || runResult.stateWriteError !== void 0) {
+        process.stderr.write(output + "\n");
         process.exitCode = 1;
-        return;
+      } else {
+        console.log(output);
       }
-      const connector = makeNotionConnector();
-      const state = await readLiveConnectorState(config.memoryDir, connectorName);
-      runResult = await pollOnce({
-        connectorId: connectorName,
-        priorState: state,
-        syncFn: (cursor) => connector.syncIncremental({
-          cursor,
-          config: validatedCfg
-        }),
-        ingestFn: sharedIngestFn,
-        writeCursorFn: makeWriteCursorFn(connectorName)
-      });
-    } else {
-      process.stderr.write(
-        `connectors run: unknown connector "${connectorName}". Known connectors: ${GDRIVE_ID}, ${NOTION_ID}.
-`
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const output = renderRunResult(connectorName, runResult, format);
-    if (runResult.error !== void 0 || runResult.stateWriteError !== void 0) {
-      process.stderr.write(output + "\n");
-      process.exitCode = 1;
-    } else {
-      console.log(output);
+    } finally {
+      await orchestrator.destroy();
     }
   } else {
     console.log("Usage: remnic connectors <list|install|remove|doctor|marketplace|status|run> [id]");
@@ -9219,7 +9395,7 @@ async function cmdLegacyBenchmark(action, rest, json) {
   } else if (action === "report") {
     const reportPath = benchConfig.reportPath;
     const suite = await runBenchSuite(service, { ...benchConfig, reportPath });
-    console.log(`Report saved to ${reportPath ?? "benchmarks/report.json"}`);
+    printBenchStatusLine(json, `Report saved to ${reportPath ?? "benchmarks/report.json"}`);
     if (json) {
       console.log(JSON.stringify(suite.report, null, 2));
     }
@@ -9346,9 +9522,9 @@ async function cmdBench(rest) {
     }
     const completeCount = prevStatus.benchmarks.filter((b) => b.status === "complete").length;
     const failedCount = prevStatus.benchmarks.filter((b) => b.status === "failed").length;
-    console.log(`Resuming from: ${path11.basename(latestStatusPath)}`);
-    console.log(`  Previous run: ${prevStatus.startedAt}`);
-    console.log(`  Benchmarks: ${prevStatus.benchmarks.length} total, ${completeCount} complete, ${failedCount} failed`);
+    printBenchStatusLine(parsed.json, `Resuming from: ${path11.basename(latestStatusPath)}`);
+    printBenchStatusLine(parsed.json, `  Previous run: ${prevStatus.startedAt}`);
+    printBenchStatusLine(parsed.json, `  Benchmarks: ${prevStatus.benchmarks.length} total, ${completeCount} complete, ${failedCount} failed`);
     const before = selectedBenchmarks.length;
     if (parsed.resume) {
       selectedWorkItems = filterBenchWorkItemsForPreviousStatus(
@@ -9357,7 +9533,7 @@ async function cmdBench(rest) {
         "resume"
       );
       selectedBenchmarks = [...new Set(selectedWorkItems.map((item) => item.benchmarkId))];
-      console.log(`  Resuming: ${selectedBenchmarks.length} of ${before} benchmarks to re-run`);
+      printBenchStatusLine(parsed.json, `  Resuming: ${selectedBenchmarks.length} of ${before} benchmarks to re-run`);
     } else {
       selectedWorkItems = filterBenchWorkItemsForPreviousStatus(
         selectedWorkItems,
@@ -9365,13 +9541,14 @@ async function cmdBench(rest) {
         "retry-failed"
       );
       selectedBenchmarks = [...new Set(selectedWorkItems.map((item) => item.benchmarkId))];
-      console.log(`  Retrying: ${selectedBenchmarks.length} of ${before} selected benchmarks had failures`);
+      printBenchStatusLine(parsed.json, `  Retrying: ${selectedBenchmarks.length} of ${before} selected benchmarks had failures`);
     }
     if (selectedWorkItems.length === 0) {
       if (parsed.retryFailed) {
-        console.log("Nothing to re-run \u2014 no selected benchmarks had failures.");
+        printBenchStatusLine(parsed.json, "Nothing to re-run \u2014 no selected benchmarks had failures.");
       } else {
-        console.log(
+        printBenchStatusLine(
+          parsed.json,
           "Nothing to re-run \u2014 all selected benchmarks completed successfully in the previous run."
         );
       }
@@ -9417,6 +9594,7 @@ async function cmdBench(rest) {
           }
         } else {
           const fallbackResultPath = await runBenchViaFallback(parsed, benchmarkId, runtimeProfile);
+          writtenPaths.push(fallbackResultPath);
           try {
             await updateBenchmarkCompleted(benchStatusPath, statusId, fallbackResultPath);
           } catch {
@@ -9532,13 +9710,10 @@ var [LAUNCHD_PLIST_PATH] = LAUNCHD_PLIST_PATHS;
 var SYSTEMD_UNIT_PATHS = systemdUnitPaths(resolveHomeDir());
 var [SYSTEMD_UNIT_PATH] = SYSTEMD_UNIT_PATHS;
 function readPid() {
-  for (const file of [PID_FILE, LEGACY_PID_FILE]) {
-    try {
-      return parseInt(fs7.readFileSync(file, "utf8").trim(), 10);
-    } catch {
-    }
-  }
-  return void 0;
+  return readVerifiedDaemonPid({
+    pidFiles: [PID_FILE, LEGACY_PID_FILE],
+    expectedServerBin: resolveServerBin()
+  });
 }
 function inferPort() {
   try {
@@ -9570,6 +9745,36 @@ function isStandaloneServiceInstalled() {
   if (isLinux()) return anyFileExists(SYSTEMD_UNIT_PATHS);
   return false;
 }
+function commandFailureDetail(error) {
+  if (error && typeof error === "object") {
+    const maybe = error;
+    const stderr = maybe.stderr ? String(maybe.stderr).trim() : "";
+    if (stderr) return stderr;
+    const stdout = maybe.stdout ? String(maybe.stdout).trim() : "";
+    if (stdout) return stdout;
+    if (maybe.message) return maybe.message;
+  }
+  return String(error);
+}
+function failDaemonInstall(command, error) {
+  console.error(`Error: daemon install failed while running ${command}.`);
+  console.error(`  ${commandFailureDetail(error)}`);
+  process.exit(1);
+}
+function isLaunchdLabelLoaded(label) {
+  return firstSuccessfulResult([label], (candidate) => {
+    childProcess2.execSync(`launchctl list ${candidate} 2>/dev/null`, { stdio: "pipe" });
+    return true;
+  }) === true;
+}
+function isSystemdServiceActive() {
+  return firstSuccessfulResult(SYSTEMD_SERVICE_CANDIDATES, (serviceName) => {
+    const out = childProcess2.execSync(`systemctl --user is-active ${serviceName} 2>/dev/null`, {
+      encoding: "utf8"
+    }).trim();
+    return out === "active" ? true : void 0;
+  }) === true;
+}
 function selectLaunchdInspection(openclawPluginModeConfigured) {
   const canonical = inspectLaunchdPlist(LAUNCHD_PLIST_PATH);
   if (canonical.installed) return canonical;
@@ -9617,7 +9822,13 @@ function daemonInstall() {
     fs7.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
-    } catch {
+    } catch (err) {
+      if (!isLaunchdLabelLoaded(LAUNCHD_LABEL)) {
+        failDaemonInstall(`launchctl load -w ${LAUNCHD_PLIST_PATH}`, err);
+      }
+    }
+    if (!isLaunchdLabelLoaded(LAUNCHD_LABEL)) {
+      failDaemonInstall(`launchctl list ${LAUNCHD_LABEL}`, new Error("service was not loaded after install"));
     }
     console.log(`Installed launchd service: ${LAUNCHD_PLIST_PATH}`);
     console.log(`  Label: ${LAUNCHD_LABEL}`);
@@ -9631,9 +9842,21 @@ function daemonInstall() {
     fs7.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+    } catch (err) {
+      failDaemonInstall("systemctl --user daemon-reload", err);
+    }
+    try {
       childProcess2.execSync(`systemctl --user enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+    } catch (err) {
+      failDaemonInstall(`systemctl --user enable ${SYSTEMD_SERVICE}`, err);
+    }
+    try {
       childProcess2.execSync(`systemctl --user start ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-    } catch {
+    } catch (err) {
+      failDaemonInstall(`systemctl --user start ${SYSTEMD_SERVICE}`, err);
+    }
+    if (!isSystemdServiceActive()) {
+      failDaemonInstall(`systemctl --user is-active ${SYSTEMD_SERVICE}`, new Error("service is not active after install"));
     }
     console.log(`Installed systemd user service: ${SYSTEMD_UNIT_PATH}`);
     console.log(`  Restart: on-failure, WantedBy: default.target`);
@@ -11397,6 +11620,8 @@ export {
   BENCHMARK_CATALOG,
   OFFLINE_SYNC_APPLY_MAX_REQUEST_BYTES,
   OFFLINE_SYNC_CHANGESET_RETRY_MAX,
+  OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS,
+  OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX,
   OFFLINE_SYNC_DIRECT_HYDRATE_MIN_BYTES,
   OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES,
@@ -11419,6 +11644,8 @@ export {
   formatOfflineRequestForError,
   getBenchUsageText,
   hasFlag,
+  hydrateOfflineSnapshotContent,
+  isOfflineMissingContentDeferrablePath,
   isOfflineSnapshotPostFallbackError,
   main,
   offlinePartialHydrationForPaths,
@@ -11438,6 +11665,7 @@ export {
   resolveConfigPath,
   resolveFlag,
   resolveMemoryDir,
+  resolveOptionalOfflineRemoteUrl,
   resolveSyncSourceDir,
   runOfflineSyncOnce,
   runTrainingExport,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/cli",
-  "version": "1.0.25",
+  "version": "9.3.517",
   "description": "CLI for Remnic memory — init, query, doctor, daemon management",
   "type": "module",
   "main": "dist/index.js",
@@ -26,20 +26,20 @@
   },
   "dependencies": {
     "yaml": "^2.4.2",
-    "@remnic/plugin-pi": "^1.0.9",
-    "@remnic/server": "^1.0.5",
-    "@remnic/core": "^1.1.31"
+    "@remnic/plugin-pi": "^9.3.517",
+    "@remnic/server": "^9.3.517",
+    "@remnic/core": "^9.3.517"
   },
   "peerDependencies": {
-    "@remnic/bench": "^1.0.0",
-    "@remnic/export-weclone": "^1.0.0",
-    "@remnic/import-weclone": "^1.0.0",
-    "@remnic/import-chatgpt": "^0.1.0",
-    "@remnic/import-claude": "^0.1.0",
-    "@remnic/import-gemini": "^0.1.0",
-    "@remnic/import-lossless-claw": "^0.1.1",
-    "@remnic/import-mem0": "^0.1.0",
-    "@remnic/import-supermemory": "^0.1.1"
+    "@remnic/bench": "^9.3.517",
+    "@remnic/export-weclone": "^9.3.517",
+    "@remnic/import-weclone": "^9.3.517",
+    "@remnic/import-chatgpt": "^9.3.517",
+    "@remnic/import-claude": "^9.3.517",
+    "@remnic/import-gemini": "^9.3.517",
+    "@remnic/import-lossless-claw": "^9.3.517",
+    "@remnic/import-mem0": "^9.3.517",
+    "@remnic/import-supermemory": "^9.3.517"
   },
   "peerDependenciesMeta": {
     "@remnic/bench": {
@@ -73,15 +73,15 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@remnic/export-weclone": "1.0.1",
-    "@remnic/bench": "1.0.1",
-    "@remnic/import-weclone": "1.0.1",
-    "@remnic/import-chatgpt": "0.1.0",
-    "@remnic/import-claude": "0.1.0",
-    "@remnic/import-gemini": "0.1.0",
-    "@remnic/import-lossless-claw": "0.1.1",
-    "@remnic/import-supermemory": "0.1.2",
-    "@remnic/import-mem0": "0.1.0"
+    "@remnic/export-weclone": "9.3.517",
+    "@remnic/bench": "9.3.517",
+    "@remnic/import-weclone": "9.3.517",
+    "@remnic/import-chatgpt": "9.3.517",
+    "@remnic/import-claude": "9.3.517",
+    "@remnic/import-gemini": "9.3.517",
+    "@remnic/import-lossless-claw": "9.3.517",
+    "@remnic/import-supermemory": "9.3.517",
+    "@remnic/import-mem0": "9.3.517"
   },
   "license": "MIT",
   "repository": {