@remnic/cli 1.0.24 → 9.3.515

package/dist/index.js

@@ -5,6 +5,7 @@ import path11 from "path";
 import { createDecipheriv, createHash } from "crypto";
 import * as childProcess2 from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
+import { gzipSync } from "zlib";
 import {
   parseConfig,
   isOpenaiApiKeyDisabled,
@@ -850,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)) {
@@ -1973,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;
@@ -2431,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:
@@ -2522,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) {
@@ -2574,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;
@@ -3836,7 +3918,8 @@ var __benchDatasetTestHooks = {
       seed,
       benchmarkOptions
     );
-  }
+  },
+  printBenchStatusLineForTest: printBenchStatusLine
 };
 function printBenchPackageSummary(result, outputPath, outputLabel = "Results saved") {
   console.log(`Benchmark: ${result.meta.benchmark}`);
@@ -3851,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}`);
@@ -4671,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)`
           );
         }
@@ -6648,6 +6739,7 @@ function offlineEndpoint(remoteUrl, pathname, params = {}) {
   return url.toString();
 }
 var OFFLINE_SYNC_REQUEST_TIMEOUT_DEFAULT_MS = 15 * 6e4;
+var OFFLINE_SYNC_SNAPSHOT_BASE_POST_PREFERRED_MAX_BODY_BYTES = 16 * 1024 * 1024;
 function parseOfflineSyncRequestTimeoutMs(raw, fallback = OFFLINE_SYNC_REQUEST_TIMEOUT_DEFAULT_MS) {
   if (raw === void 0 || raw.trim().length === 0) return fallback;
   const parsed = Number(raw);
@@ -6746,29 +6838,130 @@ async function fetchOfflineJson(url, token, init = {}) {
     }
   );
 }
+async function parseOfflineSnapshotStreamResponse(response) {
+  if (!response.body) {
+    throw new Error("offline sync snapshot stream response omitted body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  let header = null;
+  const files = [];
+  const handleLine = (line) => {
+    if (line.trim().length === 0) return;
+    const parsed = JSON.parse(line);
+    if (parsed.type === "snapshot") {
+      if (header) throw new Error("offline sync snapshot stream repeated header");
+      header = {
+        ...typeof parsed.namespace === "string" && parsed.namespace.length > 0 ? { namespace: parsed.namespace } : {},
+        format: parsed.format,
+        schemaVersion: parsed.schemaVersion,
+        createdAt: parsed.createdAt,
+        sourceId: parsed.sourceId,
+        includeTranscripts: parsed.includeTranscripts
+      };
+      return;
+    }
+    if (parsed.type === "file") {
+      if (!header) throw new Error("offline sync snapshot stream file arrived before header");
+      files.push(parsed.file);
+      return;
+    }
+    throw new Error("offline sync snapshot stream contained unknown event");
+  };
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffered += decoder.decode(value, { stream: true });
+    for (; ; ) {
+      const newline = buffered.indexOf("\n");
+      if (newline < 0) break;
+      const line = buffered.slice(0, newline);
+      buffered = buffered.slice(newline + 1);
+      handleLine(line);
+    }
+  }
+  buffered += decoder.decode();
+  handleLine(buffered);
+  const finalHeader = header;
+  if (!finalHeader) throw new Error("offline sync snapshot stream omitted header");
+  const snapshot = normalizeOfflineSyncSnapshot({
+    format: finalHeader.format,
+    schemaVersion: finalHeader.schemaVersion,
+    createdAt: finalHeader.createdAt,
+    sourceId: finalHeader.sourceId,
+    includeTranscripts: finalHeader.includeTranscripts,
+    files
+  });
+  return {
+    ...finalHeader.namespace ? { namespace: finalHeader.namespace } : {},
+    ...snapshot
+  };
+}
+async function fetchOfflineSnapshotStream(args) {
+  const url = offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot-stream", {
+    namespace: args.namespace,
+    include_transcripts: args.includeTranscripts ? "true" : "false",
+    content: "false"
+  });
+  return fetchOfflineWithResponse(
+    url,
+    args.token,
+    {},
+    {},
+    async (response) => {
+      if (!response.ok) {
+        await throwOfflineResponseError(response, url, {}, "offline sync snapshot-stream request");
+      }
+      return parseOfflineSnapshotStreamResponse(response);
+    }
+  );
+}
 async function fetchOfflineSnapshot(args) {
+  let tryStreamSnapshot = false;
   if (args.includeContent === false && args.baseFiles && args.baseFiles.length > 0) {
-    const postBody = offlineSnapshotBasePostBody({
-      namespace: args.namespace,
-      includeTranscripts: args.includeTranscripts,
-      baseFiles: args.baseFiles,
-      baseCapturedAt: args.baseCapturedAt
-    });
-    if (offlineSnapshotBasePostBodyFits(postBody)) {
-      try {
-        return await fetchOfflineJson(
-          offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot"),
-          args.token,
-          {
-            method: "POST",
-            body: postBody
-          }
-        );
-      } catch (error) {
-        if (!isOfflineSnapshotPostFallbackError(error)) throw error;
+    if (args.baseFiles.length > OFFLINE_SYNC_SNAPSHOT_BASE_POST_MAX_FILES) {
+      tryStreamSnapshot = true;
+    } else {
+      const postBody = offlineSnapshotBasePostBody({
+        namespace: args.namespace,
+        includeTranscripts: args.includeTranscripts,
+        baseFiles: args.baseFiles,
+        baseCapturedAt: args.baseCapturedAt
+      });
+      const postRequest = offlineSnapshotBasePostRequest(postBody);
+      if (postRequest) {
+        const postRequestUsesGzip = new Headers(postRequest.headers).get("content-encoding")?.toLowerCase() === "gzip";
+        try {
+          return await fetchOfflineJson(
+            offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot"),
+            args.token,
+            {
+              method: "POST",
+              ...postRequest
+            }
+          );
+        } catch (error) {
+          if (!isOfflineSnapshotPostFallbackError(error, { compressed: postRequestUsesGzip })) throw error;
+          tryStreamSnapshot = true;
+        }
+      } else {
+        tryStreamSnapshot = true;
       }
     }
   }
+  if (tryStreamSnapshot) {
+    try {
+      return await fetchOfflineSnapshotStream({
+        remoteUrl: args.remoteUrl,
+        token: args.token,
+        namespace: args.namespace,
+        includeTranscripts: args.includeTranscripts
+      });
+    } catch (error) {
+      if (!isOfflineSnapshotStreamFallbackError(error)) throw error;
+    }
+  }
   return fetchOfflineJson(
     offlineEndpoint(args.remoteUrl, "/remnic/v1/offline-sync/snapshot", {
       namespace: args.namespace,
@@ -6788,11 +6981,36 @@ function offlineSnapshotBasePostBody(args) {
   });
 }
 function offlineSnapshotBasePostBodyFits(body) {
-  return Buffer.byteLength(body, "utf-8") <= OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES;
+  const bytes = Buffer.byteLength(body, "utf-8");
+  return bytes <= OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES && bytes <= OFFLINE_SYNC_SNAPSHOT_BASE_POST_PREFERRED_MAX_BODY_BYTES;
+}
+var OFFLINE_SYNC_SNAPSHOT_BASE_POST_MAX_FILES = 5e4;
+function offlineSnapshotBasePostRequest(body) {
+  const bytes = Buffer.byteLength(body, "utf-8");
+  if (bytes > OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES) return null;
+  if (bytes <= OFFLINE_SYNC_SNAPSHOT_BASE_POST_PREFERRED_MAX_BODY_BYTES) {
+    return { body };
+  }
+  const compressed = gzipSync(body);
+  if (compressed.byteLength > OFFLINE_SYNC_SNAPSHOT_BASE_POST_PREFERRED_MAX_BODY_BYTES) {
+    return null;
+  }
+  return {
+    body: compressed,
+    headers: {
+      "content-encoding": "gzip"
+    }
+  };
+}
+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 (!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);
 }
-function isOfflineSnapshotPostFallbackError(error) {
+function isOfflineSnapshotStreamFallbackError(error) {
   const message = error instanceof Error ? error.message : String(error);
-  return /offline-sync\/snapshot\b.* returned (404|405|413)\b/.test(message);
+  return /offline-sync\/snapshot-stream\b.* returned (404|405)\b/.test(message);
 }
 async function fetchOfflineFiles(args) {
   return fetchOfflineJson(
@@ -8681,109 +8899,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]");
@@ -9091,7 +9313,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));
     }
@@ -9218,9 +9440,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(
@@ -9229,7 +9451,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,
@@ -9237,13 +9459,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."
         );
       }
@@ -9289,6 +9512,7 @@ async function cmdBench(rest) {
           }
         } else {
           const fallbackResultPath = await runBenchViaFallback(parsed, benchmarkId, runtimeProfile);
+          writtenPaths.push(fallbackResultPath);
           try {
             await updateBenchmarkCompleted(benchStatusPath, statusId, fallbackResultPath);
           } catch {
@@ -9404,13 +9628,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 {
@@ -9442,6 +9663,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;
@@ -9489,7 +9740,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}`);
@@ -9503,9 +9760,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`);
@@ -11273,6 +11542,8 @@ export {
   OFFLINE_SYNC_DIRECT_PUSH_MIN_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES,
   OFFLINE_SYNC_REQUEST_TIMEOUT_DEFAULT_MS,
+  OFFLINE_SYNC_SNAPSHOT_BASE_POST_MAX_FILES,
+  OFFLINE_SYNC_SNAPSHOT_BASE_POST_PREFERRED_MAX_BODY_BYTES,
   TAXONOMY_RESOLVE_BOOLEAN_FLAGS,
   TAXONOMY_RESOLVE_VALUE_FLAGS,
   __benchDatasetTestHooks,
@@ -11284,6 +11555,7 @@ export {
   chunkOfflineFileContentBatches,
   directHydrateLargeOfflineFiles,
   extractXrayRawArgs,
+  fetchOfflineSnapshot,
   formatOfflineLargeFilePushFailureMessage,
   formatOfflineRequestForError,
   getBenchUsageText,
@@ -11293,6 +11565,7 @@ export {
   offlinePartialHydrationForPaths,
   offlineSnapshotBasePostBody,
   offlineSnapshotBasePostBodyFits,
+  offlineSnapshotBasePostRequest,
   offlineSnapshotContentFilesForApply,
   parseBenchArgs,
   parseCapsuleForkArgs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/cli",
-  "version": "1.0.24",
+  "version": "9.3.515",
   "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/server": "^1.0.5",
-    "@remnic/plugin-pi": "^1.0.10",
-    "@remnic/core": "^1.1.30"
+    "@remnic/plugin-pi": "^9.3.515",
+    "@remnic/server": "^9.3.515",
+    "@remnic/core": "^9.3.515"
   },
   "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.515",
+    "@remnic/export-weclone": "^9.3.515",
+    "@remnic/import-weclone": "^9.3.515",
+    "@remnic/import-chatgpt": "^9.3.515",
+    "@remnic/import-claude": "^9.3.515",
+    "@remnic/import-gemini": "^9.3.515",
+    "@remnic/import-lossless-claw": "^9.3.515",
+    "@remnic/import-mem0": "^9.3.515",
+    "@remnic/import-supermemory": "^9.3.515"
   },
   "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-mem0": "0.1.0",
-    "@remnic/import-supermemory": "0.1.2"
+    "@remnic/bench": "9.3.515",
+    "@remnic/export-weclone": "9.3.515",
+    "@remnic/import-weclone": "9.3.515",
+    "@remnic/import-claude": "9.3.515",
+    "@remnic/import-gemini": "9.3.515",
+    "@remnic/import-mem0": "9.3.515",
+    "@remnic/import-lossless-claw": "9.3.515",
+    "@remnic/import-chatgpt": "9.3.515",
+    "@remnic/import-supermemory": "9.3.515"
   },
   "license": "MIT",
   "repository": {