@remnic/cli 9.21.0 → 9.22.1

package/dist/index.js

@@ -18,7 +18,7 @@ async function persistEnrichmentCandidate(storage, entityName, candidate) {
 }
 
 // src/index.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import os from "os";
 import path12 from "path";
 import { createHash as createHash2 } from "crypto";
@@ -26,11 +26,11 @@ import * as childProcess2 from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { gzipSync } from "zlib";
 import {
-  parseConfig as parseConfig3,
+  parseConfig as parseConfig4,
   isOpenaiApiKeyDisabled,
   resolveEnvVars,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord3,
-  Orchestrator as Orchestrator2,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord4,
+  Orchestrator as Orchestrator3,
   EngramAccessService as EngramAccessService2,
   initLogger as initLogger2,
   onboard,
@@ -139,6 +139,56 @@ import {
   validateCapabilitiesForMint
 } from "@remnic/core";
 
+// src/commands/meetings.ts
+import fs from "fs";
+import {
+  Orchestrator,
+  parseConfig,
+  resolveRemnicConfigRecord,
+  runMeetingsCliCommand
+} from "@remnic/core";
+async function runMeetingsBinaryCommand(rest) {
+  const meetingsArgs = rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" ? ["help"] : rest;
+  let meetingsOrchestrator;
+  try {
+    let meetingsService;
+    try {
+      const configPath = resolveConfigPath();
+      const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+      const config = parseConfig(resolveRemnicConfigRecord(raw));
+      meetingsOrchestrator = new Orchestrator(config);
+      await meetingsOrchestrator.initialize();
+      await meetingsOrchestrator.deferredReady;
+      meetingsService = await meetingsOrchestrator.getMeetingsService();
+    } catch {
+      console.error(
+        "meetings: failed to load the Remnic config or start the memory engine \u2014 run `remnic doctor` and check the config file for errors"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const code = await runMeetingsCliCommand(
+      { store: meetingsService.store, builder: meetingsService.builder, config: meetingsService.config },
+      meetingsArgs,
+      { stdout: process.stdout, stderr: process.stderr }
+    );
+    if (code !== 0) process.exitCode = code;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  } finally {
+    if (meetingsOrchestrator) {
+      const maybeShutdown = meetingsOrchestrator.shutdown;
+      if (typeof maybeShutdown === "function") {
+        try {
+          await maybeShutdown.call(meetingsOrchestrator);
+        } catch {
+        }
+      }
+    }
+  }
+}
+
 // src/optional-module-loader.ts
 function isSpecifierNotFoundError(err, specifier) {
   if (!err || typeof err !== "object") {
@@ -321,8 +371,8 @@ function renderReplayResult(result, targetNamespace, format) {
 }
 
 // src/quarantine-replay.ts
-import * as fs from "fs";
-import { EngramAccessService, Orchestrator, initLogger, parseConfig, resolveRemnicConfigRecord } from "@remnic/core";
+import * as fs2 from "fs";
+import { EngramAccessService, Orchestrator as Orchestrator2, initLogger, parseConfig as parseConfig2, resolveRemnicConfigRecord as resolveRemnicConfigRecord2 } from "@remnic/core";
 import { WriteQuarantineStore } from "@remnic/core/write-quarantine.js";
 function valueFlag(args, flag) {
   const occurrences = args.filter((a) => a === flag).length;
@@ -370,9 +420,9 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
   let orchestrator;
   try {
     const configPath = resolveConfigPath2();
-    const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig(resolveRemnicConfigRecord(raw));
-    orchestrator = new Orchestrator(config);
+    const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig2(resolveRemnicConfigRecord2(raw));
+    orchestrator = new Orchestrator2(config);
     await orchestrator.initialize();
     await orchestrator.deferredReady;
     const service = new EngramAccessService(orchestrator);
@@ -402,15 +452,15 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
 }
 
 // src/offline-impression-rotation.ts
-import fs2 from "fs";
-import { parseConfig as parseConfig2, resolveRemnicConfigRecord as resolveRemnicConfigRecord2, drainPendingImpressionsForOfflineSync } from "@remnic/core";
+import fs3 from "fs";
+import { parseConfig as parseConfig3, resolveRemnicConfigRecord as resolveRemnicConfigRecord3, drainPendingImpressionsForOfflineSync } from "@remnic/core";
 import { LastRecallStore } from "@remnic/core/recall-state";
 function parseConfigQuietly(raw) {
   const originalWarn = console.warn;
   console.warn = () => {
   };
   try {
-    return parseConfig2(resolveRemnicConfigRecord2(raw));
+    return parseConfig3(resolveRemnicConfigRecord3(raw));
   } finally {
     console.warn = originalWarn;
   }
@@ -424,7 +474,7 @@ var OFFLINE_CONFIG_KEYS = [
 function pickOfflineConfigRecord(raw) {
   let resolved;
   try {
-    resolved = resolveRemnicConfigRecord2(raw);
+    resolved = resolveRemnicConfigRecord3(raw);
   } catch {
     resolved = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   }
@@ -437,7 +487,7 @@ function pickOfflineConfigRecord(raw) {
 function resolveOfflineImpressionRotation(configPath) {
   let raw;
   try {
-    raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+    raw = fs3.existsSync(configPath) ? JSON.parse(fs3.readFileSync(configPath, "utf8")) : {};
   } catch {
     throw new Error(
       `cannot read recall-impression rotation from ${configPath}: config file could not be read as JSON`
@@ -467,7 +517,7 @@ async function drainOfflineSyncImpressions(memoryDir, rotation) {
 
 // src/offline-storage-io.ts
 import { mkdtemp, readdir, lstat, rm } from "fs/promises";
-import fs3 from "fs";
+import fs4 from "fs";
 import path from "path";
 import { createHash, createDecipheriv } from "crypto";
 import {
@@ -603,7 +653,7 @@ async function* readOfflineSyncFileChunks(options) {
   });
 }
 async function readFilePrefix(filePath, length) {
-  const handle = await fs3.promises.open(filePath, "r");
+  const handle = await fs4.promises.open(filePath, "r");
   try {
     const out = Buffer.alloc(length);
     const { bytesRead } = await handle.read(out, 0, length, 0);
@@ -613,7 +663,7 @@ async function readFilePrefix(filePath, length) {
   }
 }
 async function* readPlainOfflineFileChunks(filePath, chunkSize) {
-  const stream = fs3.createReadStream(filePath, { highWaterMark: chunkSize });
+  const stream = fs4.createReadStream(filePath, { highWaterMark: chunkSize });
   for await (const chunk of stream) {
     yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
   }
@@ -656,9 +706,9 @@ async function* readEncryptedOfflineFileChunks(options) {
       });
       decipher.setAuthTag(authTag);
       decipher.setAAD(Buffer.concat([secureStoreEnvelopeHeaderAad(salt), aad]));
-      const output = fs3.createWriteStream(tempPath, { mode: 384 });
+      const output = fs4.createWriteStream(tempPath, { mode: 384 });
       try {
-        const stream = fs3.createReadStream(options.filePath, {
+        const stream = fs4.createReadStream(options.filePath, {
           start: MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE,
           highWaterMark: options.chunkSize
         });
@@ -954,7 +1004,7 @@ function assertBenchModuleFreshForDevelopment() {
 }
 
 // src/daemon-service-candidates.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 var LAUNCHD_LABEL = "ai.remnic.daemon";
 var LEGACY_REMNIC_SERVER_LAUNCHD_LABEL = "ai.remnic.server";
@@ -976,7 +1026,7 @@ function systemdUnitPaths(homeDir) {
 function anyFileExists(paths) {
   return paths.some((candidate) => {
     try {
-      return fs4.statSync(candidate).isFile();
+      return fs5.statSync(candidate).isFile();
     } catch {
       return false;
     }
@@ -988,7 +1038,7 @@ function commandNames(command) {
 }
 function isRunnableNodeScript(filePath) {
   try {
-    const text = fs4.readFileSync(filePath, "utf8").slice(0, 4096);
+    const text = fs5.readFileSync(filePath, "utf8").slice(0, 4096);
     const firstLine = text.split(/\r?\n/, 1)[0] ?? "";
     if (/^#!.*\bnode\b/.test(firstLine)) return true;
     if (firstLine.startsWith("#!")) return false;
@@ -1001,7 +1051,7 @@ function isRunnableNodeScript(filePath) {
 function resolveShimNodeScript(filePath) {
   let text;
   try {
-    text = fs4.readFileSync(filePath, "utf8").slice(0, 16384);
+    text = fs5.readFileSync(filePath, "utf8").slice(0, 16384);
   } catch {
     return void 0;
   }
@@ -1013,8 +1063,8 @@ function resolveShimNodeScript(filePath) {
     const candidate = raw.replaceAll("${basedir}", basedir).replaceAll("$basedir", basedir).replaceAll("\\ ", " ");
     const resolved = path4.isAbsolute(candidate) ? candidate : path4.resolve(basedir, candidate);
     try {
-      if (fs4.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
-        return fs4.realpathSync(resolved);
+      if (fs5.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
+        return fs5.realpathSync(resolved);
       }
     } catch {
     }
@@ -1022,7 +1072,7 @@ function resolveShimNodeScript(filePath) {
   return void 0;
 }
 function resolveRunnableNodeScript(filePath) {
-  const realPath = fs4.realpathSync(filePath);
+  const realPath = fs5.realpathSync(filePath);
   if (isRunnableNodeScript(realPath)) return realPath;
   return resolveShimNodeScript(realPath);
 }
@@ -1032,9 +1082,9 @@ function findCommandOnPath(command, pathEnv = process.env.PATH ?? "") {
     for (const name of commandNames(command)) {
       const candidate = path4.join(dir, name);
       try {
-        const stat = fs4.statSync(candidate);
+        const stat = fs5.statSync(candidate);
         if (!stat.isFile()) continue;
-        if (process.platform !== "win32") fs4.accessSync(candidate, fs4.constants.X_OK);
+        if (process.platform !== "win32") fs5.accessSync(candidate, fs5.constants.X_OK);
         const runnable = resolveRunnableNodeScript(candidate);
         if (runnable) return runnable;
       } catch {
@@ -2389,7 +2439,7 @@ function finalizeBenchStatus(filePath) {
 }
 
 // src/bench-fallback.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path7 from "path";
 var FALLBACK_RESULTS_DIRNAME = "fallback-runs";
 function buildBenchRunnerArgs(parsed, benchmarkId, outputDir) {
@@ -2461,7 +2511,7 @@ function createFallbackBenchOutputDir(resultsDir, benchmarkId, pid, startedAtMs
   );
 }
 function resolveFallbackBenchResultPath(outputDir) {
-  const entries = fs5.readdirSync(outputDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+  const entries = fs6.readdirSync(outputDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
   if (entries.length === 0) {
     throw new Error(`Fallback benchmark runner did not write a JSON result artifact in ${outputDir}`);
   }
@@ -2469,7 +2519,7 @@ function resolveFallbackBenchResultPath(outputDir) {
 }
 
 // src/openclaw-upgrade-swap.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path8 from "path";
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -2481,7 +2531,7 @@ function createSiblingTempFilePath(targetPath, label) {
 function resolveAtomicWriteMode(targetPath, explicitMode) {
   if (explicitMode !== void 0) return explicitMode;
   try {
-    return fs6.statSync(targetPath).mode & 4095;
+    return fs7.statSync(targetPath).mode & 4095;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return 384;
@@ -2491,8 +2541,8 @@ function resolveAtomicWriteMode(targetPath, explicitMode) {
 }
 function resolveAtomicReplacementPath(targetPath) {
   try {
-    if (fs6.lstatSync(targetPath).isSymbolicLink()) {
-      return fs6.realpathSync(targetPath);
+    if (fs7.lstatSync(targetPath).isSymbolicLink()) {
+      return fs7.realpathSync(targetPath);
     }
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -2509,7 +2559,7 @@ function createSiblingSwapPath(targetDir, label) {
 function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
   if (!displacedDir) return void 0;
   try {
-    fs6.rmSync(displacedDir, { recursive: true, force: true });
+    fs7.rmSync(displacedDir, { recursive: true, force: true });
     return void 0;
   } catch (error) {
     return `Warning: ${context}, but failed to remove the displaced plugin copy at ${displacedDir}: ${describeError(error)}`;
@@ -2517,55 +2567,55 @@ function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
 }
 function atomicWriteFileSync(targetPath, data, options = {}) {
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs6.mkdirSync(path8.dirname(resolvedTargetPath), { recursive: true });
+  fs7.mkdirSync(path8.dirname(resolvedTargetPath), { recursive: true });
   const tempPath = createSiblingTempFilePath(resolvedTargetPath, "write");
   const mode = resolveAtomicWriteMode(resolvedTargetPath, options.mode);
   try {
     if (options.hooks?.writeTempFileSync) {
       options.hooks.writeTempFileSync(tempPath);
     } else {
-      fs6.writeFileSync(tempPath, data, { mode });
+      fs7.writeFileSync(tempPath, data, { mode });
     }
-    fs6.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs6.renameSync;
+    fs7.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs7.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs6.rmSync(tempPath, { force: true });
+    fs7.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function atomicCopyFileSync(sourcePath, targetPath, options = {}) {
-  if (!fs6.existsSync(sourcePath)) return;
+  if (!fs7.existsSync(sourcePath)) return;
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs6.mkdirSync(path8.dirname(resolvedTargetPath), { recursive: true });
+  fs7.mkdirSync(path8.dirname(resolvedTargetPath), { recursive: true });
   const tempPath = createSiblingTempFilePath(resolvedTargetPath, "copy");
-  const mode = fs6.statSync(sourcePath).mode & 4095;
+  const mode = fs7.statSync(sourcePath).mode & 4095;
   try {
-    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs6.copyFileSync;
+    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs7.copyFileSync;
     copyTempFileSync(sourcePath, tempPath);
-    fs6.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs6.renameSync;
+    fs7.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs7.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs6.rmSync(tempPath, { force: true });
+    fs7.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function swapDirectoryWithRollback(stagedDir, targetDir, rollbackDir) {
   let hasRollbackCopy = false;
-  fs6.mkdirSync(path8.dirname(targetDir), { recursive: true });
-  fs6.rmSync(rollbackDir, { recursive: true, force: true });
-  if (fs6.existsSync(targetDir)) {
-    fs6.renameSync(targetDir, rollbackDir);
+  fs7.mkdirSync(path8.dirname(targetDir), { recursive: true });
+  fs7.rmSync(rollbackDir, { recursive: true, force: true });
+  if (fs7.existsSync(targetDir)) {
+    fs7.renameSync(targetDir, rollbackDir);
     hasRollbackCopy = true;
   }
   try {
-    fs6.renameSync(stagedDir, targetDir);
+    fs7.renameSync(stagedDir, targetDir);
   } catch (swapError) {
-    fs6.rmSync(targetDir, { recursive: true, force: true });
-    if (hasRollbackCopy && fs6.existsSync(rollbackDir)) {
+    fs7.rmSync(targetDir, { recursive: true, force: true });
+    if (hasRollbackCopy && fs7.existsSync(rollbackDir)) {
       try {
-        fs6.renameSync(rollbackDir, targetDir);
+        fs7.renameSync(rollbackDir, targetDir);
         hasRollbackCopy = false;
       } catch (restoreError) {
         throw new AggregateError(
@@ -2580,7 +2630,7 @@ function swapDirectoryWithRollback(stagedDir, targetDir, rollbackDir) {
 }
 function cleanupRollbackDirectory(rollbackDir) {
   if (!rollbackDir) return;
-  fs6.rmSync(rollbackDir, { recursive: true, force: true });
+  fs7.rmSync(rollbackDir, { recursive: true, force: true });
 }
 function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   if (!rollbackDir) return void 0;
@@ -2592,20 +2642,20 @@ function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   }
 }
 function restoreDirectoryFromRollback(targetDir, rollbackDir) {
-  if (!fs6.existsSync(rollbackDir)) {
+  if (!fs7.existsSync(rollbackDir)) {
     throw new Error(`Rollback directory is missing: ${rollbackDir}`);
   }
-  fs6.mkdirSync(path8.dirname(targetDir), { recursive: true });
-  const displacedDir = fs6.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
+  fs7.mkdirSync(path8.dirname(targetDir), { recursive: true });
+  const displacedDir = fs7.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
   if (displacedDir) {
-    fs6.renameSync(targetDir, displacedDir);
+    fs7.renameSync(targetDir, displacedDir);
   }
   try {
-    fs6.renameSync(rollbackDir, targetDir);
+    fs7.renameSync(rollbackDir, targetDir);
   } catch (restoreError) {
-    if (displacedDir && fs6.existsSync(displacedDir)) {
+    if (displacedDir && fs7.existsSync(displacedDir)) {
       try {
-        fs6.renameSync(displacedDir, targetDir);
+        fs7.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -2624,23 +2674,23 @@ function restoreDirectoryFromRollback(targetDir, rollbackDir) {
   );
 }
 function restoreDirectoryFromBackup(targetDir, backupDir) {
-  if (!fs6.existsSync(backupDir)) {
+  if (!fs7.existsSync(backupDir)) {
     throw new Error(`Plugin backup directory is missing: ${backupDir}`);
   }
-  fs6.mkdirSync(path8.dirname(targetDir), { recursive: true });
+  fs7.mkdirSync(path8.dirname(targetDir), { recursive: true });
   const stagedDir = createSiblingSwapPath(targetDir, "backup-restore");
-  const displacedDir = fs6.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
-  fs6.cpSync(backupDir, stagedDir, { recursive: true });
+  const displacedDir = fs7.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
+  fs7.cpSync(backupDir, stagedDir, { recursive: true });
   if (displacedDir) {
-    fs6.renameSync(targetDir, displacedDir);
+    fs7.renameSync(targetDir, displacedDir);
   }
   try {
-    fs6.renameSync(stagedDir, targetDir);
+    fs7.renameSync(stagedDir, targetDir);
   } catch (restoreError) {
-    fs6.rmSync(targetDir, { recursive: true, force: true });
-    if (displacedDir && fs6.existsSync(displacedDir)) {
+    fs7.rmSync(targetDir, { recursive: true, force: true });
+    if (displacedDir && fs7.existsSync(displacedDir)) {
       try {
-        fs6.renameSync(displacedDir, targetDir);
+        fs7.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -2648,7 +2698,7 @@ function restoreDirectoryFromBackup(targetDir, backupDir) {
         );
       }
     }
-    fs6.rmSync(stagedDir, { recursive: true, force: true });
+    fs7.rmSync(stagedDir, { recursive: true, force: true });
     throw new Error(
       `Failed to restore the plugin backup into ${targetDir}. The durable backup remains preserved at ${backupDir}.`,
       { cause: restoreError }
@@ -2674,7 +2724,7 @@ function rollbackOpenclawUpgrade({
   let rollbackRestoreError;
   let pluginRestored = false;
   try {
-    if (rollbackDir && fs6.existsSync(rollbackDir)) {
+    if (rollbackDir && fs7.existsSync(rollbackDir)) {
       const cleanupWarning = restoreDirectoryFromRollback(pluginDir, rollbackDir);
       notes.push(`Restored previous plugin from rollback copy at ${rollbackDir}`);
       if (cleanupWarning) notes.push(cleanupWarning);
@@ -2684,7 +2734,7 @@ function rollbackOpenclawUpgrade({
     rollbackRestoreError = error instanceof Error ? error.message : String(error);
   }
   try {
-    if (!pluginRestored && pluginBackupDir && fs6.existsSync(pluginBackupDir)) {
+    if (!pluginRestored && pluginBackupDir && fs7.existsSync(pluginBackupDir)) {
       const cleanupWarning = restoreDirectoryFromBackup(pluginDir, pluginBackupDir);
       if (rollbackRestoreError) {
         notes.push(
@@ -2711,7 +2761,7 @@ function rollbackOpenclawUpgrade({
     notes.push("No previous plugin copy was available for automatic restore");
   }
   try {
-    if (configBackupPath && fs6.existsSync(configBackupPath)) {
+    if (configBackupPath && fs7.existsSync(configBackupPath)) {
       restoreFileFromBackup(configPath, configBackupPath);
       notes.push(`Restored OpenClaw config from backup at ${configBackupPath}`);
     }
@@ -2751,7 +2801,7 @@ Run this manually when you're ready:
 }
 
 // src/daemon-service.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path9 from "path";
 import * as childProcess from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -2763,7 +2813,7 @@ function launchdUnloadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
 }
 function resolveServerBinDetails(options = {}) {
-  const existsSync4 = options.existsSync ?? fs7.existsSync;
+  const existsSync4 = options.existsSync ?? fs8.existsSync;
   const findCommandOnPath2 = options.findCommandOnPath ?? findCommandOnPath;
   const moduleDir = options.moduleDir ?? thisModuleDir;
   const packageResolve = options.packageResolve ?? resolveImportSpecifier;
@@ -2822,8 +2872,8 @@ function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
 function readVerifiedDaemonPid(options) {
-  const readFileSync4 = options.readFileSync ?? fs7.readFileSync;
-  const unlinkSync = options.unlinkSync ?? fs7.unlinkSync;
+  const readFileSync4 = options.readFileSync ?? fs8.readFileSync;
+  const unlinkSync = options.unlinkSync ?? fs8.unlinkSync;
   const processKill = options.processKill ?? process.kill;
   const platform = options.platform ?? process.platform;
   const execFileSync3 = options.execFileSync ?? ((command, args, execOptions) => childProcess.execFileSync(command, args, execOptions));
@@ -2923,8 +2973,8 @@ function removePidFileBestEffort(file, unlinkSync) {
   }
 }
 function inspectLaunchdPlist(plistPath, options = {}) {
-  const existsSync4 = options.existsSync ?? fs7.existsSync;
-  const readFileSync4 = options.readFileSync ?? fs7.readFileSync;
+  const existsSync4 = options.existsSync ?? fs8.existsSync;
+  const readFileSync4 = options.readFileSync ?? fs8.readFileSync;
   if (!existsSync4(plistPath)) {
     return {
       installed: false,
@@ -3158,7 +3208,7 @@ function stripConfigArgv(args) {
 }
 
 // src/import-dispatch.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import {
   runImporter,
   validateImportBatchSize,
@@ -3672,7 +3722,7 @@ async function cmdImport(rest, targetFactory, disposeTarget, ioOverrides = {}) {
   let materializedTarget;
   let materializePromise;
   const io = {
-    readFile: ioOverrides.readFile ?? (async (p) => fs8.promises.readFile(p, "utf-8")),
+    readFile: ioOverrides.readFile ?? (async (p) => fs9.promises.readFile(p, "utf-8")),
     loadAdapter: ioOverrides.loadAdapter ?? (async (name) => (await loadImporterModule(name)).adapter),
     runImporter: ioOverrides.runImporter ?? runImporter,
     getWriteTarget: async () => {
@@ -3744,8 +3794,48 @@ function takeOptionalValue(args, flag) {
   return takeValue(args, flag);
 }
 
+// src/capture-dispatch.ts
+var SPECIFIER3 = "@remnic/capture-audio";
+var INSTALL_HINT = "`remnic capture audio` requires the optional @remnic/capture-audio package. Install it with: npm install @remnic/capture-audio";
+var USAGE = "usage: remnic capture audio <init|start|stop|status|devices|logs|download-model|janitor|enroll-self> [options]";
+function translateCaptureLoadError(err) {
+  if (isSpecifierNotFoundError(err, SPECIFIER3)) return new Error(INSTALL_HINT);
+  return err instanceof Error ? err : new Error(String(err));
+}
+async function defaultLoadCaptureAudio() {
+  try {
+    return await import(SPECIFIER3);
+  } catch (err) {
+    throw translateCaptureLoadError(err);
+  }
+}
+async function cmdCapture(rest, io) {
+  if (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h") {
+    io.stdout(USAGE);
+    return rest.length === 0 ? 2 : 0;
+  }
+  if (rest[0] !== "audio") {
+    io.stderr(`unknown capture subgroup '${rest[0]}'. ${USAGE}`);
+    return 2;
+  }
+  const forwarded = rest.slice(1);
+  let mod;
+  try {
+    mod = await (io.loadCaptureAudio ?? defaultLoadCaptureAudio)();
+  } catch (err) {
+    io.stderr(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+  return mod.runCapture({
+    argv: forwarded,
+    stdout: io.stdout,
+    stderr: io.stderr,
+    spawnArgvPrefix: [process.argv[1], "capture", "audio"]
+  });
+}
+
 // src/import-lossless-claw-cmd.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path11 from "path";
 import {
   applyLcmSchema,
@@ -3831,13 +3921,13 @@ function parseImportLosslessClawArgs(argv) {
 }
 
 // src/optional-import-lossless-claw.ts
-var SPECIFIER3 = "@remnic/import-lossless-claw";
+var SPECIFIER4 = "@remnic/import-lossless-claw";
 var cached4;
 async function tryImport() {
   try {
-    return await import(SPECIFIER3);
+    return await import(SPECIFIER4);
   } catch (err) {
-    if (isSpecifierNotFoundError(err, SPECIFIER3)) {
+    if (isSpecifierNotFoundError(err, SPECIFIER4)) {
       return null;
     }
     throw err;
@@ -3857,15 +3947,15 @@ async function loadImportLosslessClawModule() {
 
 // src/import-lossless-claw-cmd.ts
 function assertDirectoryOrAbsent(p, label) {
-  if (fs9.existsSync(p) && !fs9.statSync(p).isDirectory()) {
+  if (fs10.existsSync(p) && !fs10.statSync(p).isDirectory()) {
     throw new Error(`${label} is not a directory: ${p}`);
   }
 }
 function assertFile(p, label) {
-  if (!fs9.existsSync(p)) {
+  if (!fs10.existsSync(p)) {
     throw new Error(`${label} does not exist: ${p}`);
   }
-  if (!fs9.statSync(p).isFile()) {
+  if (!fs10.statSync(p).isFile()) {
     throw new Error(`${label} is not a file: ${p}`);
   }
 }
@@ -3897,7 +3987,7 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
     try {
       if (parsed.dryRun) {
         const lcmPath = path11.join(memoryDir, "state", "lcm.sqlite");
-        if (fs9.existsSync(lcmPath)) {
+        if (fs10.existsSync(lcmPath)) {
           destDb = mod.openExistingLcmDatabaseReadOnly(lcmPath);
         } else {
           destDb = mod.openInMemoryDestinationDatabase();
@@ -3946,6 +4036,74 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
   }
 }
 
+// src/bench-output-printer.ts
+function printStoredBenchResultSummary(result, summary) {
+  console.log(`Run id: ${summary.id}`);
+  printBenchPackageSummary(result, summary.path, "Stored result");
+}
+function printBenchStatusLine(jsonMode, message) {
+  if (jsonMode) {
+    console.error(message);
+  } else {
+    console.log(message);
+  }
+}
+function printBenchPackageSummary(result, outputPath, outputLabel = "Results saved") {
+  console.log(`Benchmark: ${result.meta.benchmark}`);
+  console.log(`Mode: ${result.meta.mode}`);
+  if (result.config.runtimeProfile) {
+    console.log(`Runtime profile: ${result.config.runtimeProfile}`);
+  }
+  console.log(`Tasks: ${result.results.tasks.length}`);
+  console.log(`Mean query latency: ${result.cost.meanQueryLatencyMs.toFixed(1)}ms`);
+  for (const [metric, aggregate] of Object.entries(result.results.aggregates).sort()) {
+    console.log(`  ${metric.padEnd(20)} ${aggregate.mean.toFixed(4)}`);
+  }
+  console.log(`${outputLabel}: ${outputPath}`);
+}
+function printStoredBenchResultDetails(result, summary) {
+  printStoredBenchResultSummary(result, summary);
+  if (result.results.tasks.length === 0) {
+    console.log("Tasks: none");
+    return;
+  }
+  console.log("Task breakdown:");
+  for (const task of result.results.tasks) {
+    const scores = Object.entries(task.scores ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([metric, value]) => `${metric}=${value.toFixed(4)}`).join(", ");
+    const taskLabel = task.taskId ?? "(unknown task)";
+    const taskLatency = typeof task.latencyMs === "number" ? task.latencyMs.toFixed(1) : "?";
+    console.log(
+      `  ${taskLabel}: ${taskLatency}ms${scores.length > 0 ? ` [${scores}]` : ""}`
+    );
+  }
+}
+function printBenchComparisonSummary(comparison, baseline, candidate) {
+  console.log(`Benchmark: ${comparison.benchmark}`);
+  console.log(`Baseline: ${baseline.id} (${baseline.path})`);
+  console.log(`Candidate: ${candidate.id} (${candidate.path})`);
+  console.log(`Verdict: ${comparison.verdict}`);
+  const metrics = Object.entries(comparison.metricDeltas).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  if (metrics.length === 0) {
+    console.log("No overlapping metrics were found between the two results.");
+    return;
+  }
+  console.log("Metrics:");
+  for (const [metric, delta] of metrics) {
+    const percent = Number.isFinite(delta.percentChange) ? `${(delta.percentChange * 100).toFixed(2)}%` : delta.percentChange > 0 ? "+Infinity%" : "-Infinity%";
+    const direction = delta.delta >= 0 ? "+" : "";
+    console.log(
+      `  ${metric.padEnd(18)} ${delta.baseline.toFixed(4)} -> ${delta.candidate.toFixed(4)} (${direction}${delta.delta.toFixed(4)}, ${percent}, d=${delta.effectSize.cohensD.toFixed(3)} ${delta.effectSize.interpretation})`
+    );
+    if (delta.ciOnDelta) {
+      console.log(
+        `    95% CI on delta: [${delta.ciOnDelta.lower.toFixed(4)}, ${delta.ciOnDelta.upper.toFixed(4)}]`
+      );
+    }
+  }
+}
+
 // src/index.ts
 var LazyPluginPiPublisher = class {
   constructor(hostId, select) {
@@ -4330,7 +4488,7 @@ async function resolveAllBenchmarks() {
   if (packageBenchmarks) {
     return packageBenchmarks.filter((entry) => entry.runnerAvailable).map((entry) => entry.id);
   }
-  if (!fs10.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs11.existsSync(EVAL_RUNNER_PATH)) {
     return [];
   }
   return BENCHMARK_CATALOG.filter((entry) => entry.category !== "ingestion").map((entry) => entry.id);
@@ -4378,7 +4536,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
       `Fallback benchmark runner does not support provider-backed, gateway, or thinking/timeout flags (${unsupportedOptions.join(", ")}). Build/install @remnic/bench to use those options.`
     );
   }
-  if (!fs10.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs11.existsSync(EVAL_RUNNER_PATH)) {
     console.error(
       "Benchmark runner not found. Expected eval runner at evals/run.ts or a phase-1 @remnic/bench runtime export."
     );
@@ -4388,7 +4546,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
     path12.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
     path12.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
   ];
-  const tsxCmd = tsxCandidates.find((candidate) => fs10.existsSync(candidate)) ?? "tsx";
+  const tsxCmd = tsxCandidates.find((candidate) => fs11.existsSync(candidate)) ?? "tsx";
   const fallbackOutputDir = createFallbackBenchOutputDir(
     parsed.resultsDir ?? resolveBenchOutputDir(),
     benchmarkId,
@@ -4533,9 +4691,9 @@ var PERSONAMEM_COMPLETION_MARKER = path12.join(
 );
 function resolveRealpathWithinDataset(datasetPath, relativePath) {
   try {
-    const datasetRoot = fs10.realpathSync(datasetPath);
+    const datasetRoot = fs11.realpathSync(datasetPath);
     const candidatePath = path12.resolve(datasetRoot, relativePath);
-    const candidateRealPath = fs10.realpathSync(candidatePath);
+    const candidateRealPath = fs11.realpathSync(candidatePath);
     const relativeToRoot = path12.relative(datasetRoot, candidateRealPath);
     if (relativeToRoot.startsWith("..") || path12.isAbsolute(relativeToRoot)) {
       return null;
@@ -4594,14 +4752,14 @@ function parseCsvRows(raw) {
 function isPersonaMemDatasetComplete(datasetPath) {
   try {
     const completionMarkerPath = path12.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
-    if (fs10.statSync(completionMarkerPath).isFile()) {
+    if (fs11.statSync(completionMarkerPath).isFile()) {
       return true;
     }
   } catch {
   }
   const datasetFile = PERSONAMEM_DATASET_FILE_CANDIDATES.find((candidate) => {
     try {
-      return fs10.statSync(path12.join(datasetPath, candidate)).isFile();
+      return fs11.statSync(path12.join(datasetPath, candidate)).isFile();
     } catch {
       return false;
     }
@@ -4610,7 +4768,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     return false;
   }
   try {
-    const rows = parseCsvRows(fs10.readFileSync(path12.join(datasetPath, datasetFile), "utf8"));
+    const rows = parseCsvRows(fs11.readFileSync(path12.join(datasetPath, datasetFile), "utf8"));
     if (rows.length < 2) {
       return false;
     }
@@ -4625,7 +4783,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     }
     return historyPaths.every((relativePath) => {
       const resolvedPath = resolveRealpathWithinDataset(datasetPath, relativePath);
-      return resolvedPath !== null && fs10.statSync(resolvedPath).isFile();
+      return resolvedPath !== null && fs11.statSync(resolvedPath).isFile();
     });
   } catch {
     return false;
@@ -4633,7 +4791,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
 }
 function hasDatasetFile(datasetPath, relativePath) {
   try {
-    return fs10.statSync(path12.join(datasetPath, relativePath)).isFile();
+    return fs11.statSync(path12.join(datasetPath, relativePath)).isFile();
   } catch {
     return false;
   }
@@ -4653,10 +4811,10 @@ function memoryAgentBenchDatasetHasRecSysSamples(datasetPath) {
   return candidateFilenames.some((filename) => {
     const filePath = path12.join(datasetPath, filename);
     try {
-      if (!fs10.statSync(filePath).isFile()) {
+      if (!fs11.statSync(filePath).isFile()) {
         return false;
       }
-      const raw = fs10.readFileSync(filePath, "utf8");
+      const raw = fs11.readFileSync(filePath, "utf8");
       return /"source"\s*:\s*"recsys[_-]/i.test(raw);
     } catch {
       return false;
@@ -4672,7 +4830,7 @@ function isMemoryAgentBenchDatasetComplete(datasetPath) {
 function isDatasetDownloaded(datasetPath, benchmarkId) {
   let stats;
   try {
-    stats = fs10.statSync(datasetPath);
+    stats = fs11.statSync(datasetPath);
   } catch {
     return false;
   }
@@ -4682,7 +4840,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   const marker = DOWNLOADED_DATASET_MARKERS[benchmarkId];
   if (!marker) {
     try {
-      return fs10.readdirSync(datasetPath).length > 0;
+      return fs11.readdirSync(datasetPath).length > 0;
     } catch {
       return false;
     }
@@ -4690,7 +4848,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.allOf) {
     const hasAllRequiredFiles = marker.allOf.every((name) => {
       try {
-        return fs10.statSync(path12.join(datasetPath, name)).isFile();
+        return fs11.statSync(path12.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -4702,7 +4860,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.anyOf) {
     const hasMarkerFile = marker.anyOf.some((name) => {
       try {
-        return fs10.statSync(path12.join(datasetPath, name)).isFile();
+        return fs11.statSync(path12.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -4720,7 +4878,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   }
   if (marker.ext) {
     try {
-      return fs10.readdirSync(datasetPath).some(
+      return fs11.readdirSync(datasetPath).some(
         (name) => name.endsWith(marker.ext) && !marker.exclude?.includes(name)
       );
     } catch {
@@ -4732,7 +4890,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
 async function launchBenchUi(resultsDir) {
   const benchUiDir = path12.join(CLI_REPO_ROOT, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs10.existsSync(path12.join(benchUiDir, "package.json"))) {
+  if (!fs11.existsSync(path12.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -4770,13 +4928,13 @@ function listDownloadableBenchmarks() {
 }
 function resolveDatasetDownloadScriptPath() {
   const bundled = path12.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
-  if (fs10.existsSync(bundled)) {
+  if (fs11.existsSync(bundled)) {
     return bundled;
   }
   return path12.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
 }
 function isRepoCheckout() {
-  return fs10.existsSync(path12.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs10.existsSync(path12.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+  return fs11.existsSync(path12.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs11.existsSync(path12.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
 }
 function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
   const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
@@ -4848,6 +5006,8 @@ var __benchDatasetTestHooks = {
   isDatasetDownloaded,
   resolveBenchDatasetDir,
   resolveDownloadedBenchDatasetDir,
+  pairedAnswerReplayCacheForBenchmark,
+  orderPairedLoCoMoWorkItemsForTest: orderPairedLoCoMoWorkItems,
   buildPublishedBenchmarkOptionsForTest(benchmarkId, args, taskSelector) {
     return buildPublishedBenchmarkOptions(benchmarkId, args, taskSelector);
   },
@@ -4876,72 +5036,9 @@ var __benchDatasetTestHooks = {
       taskSelector
     );
   },
-  printBenchStatusLineForTest: printBenchStatusLine
+  printBenchStatusLineForTest: printBenchStatusLine,
+  clearPairedAnswerReplayCacheOnFailureForTest: clearPairedAnswerReplayCacheOnFailure
 };
-function printBenchPackageSummary(result, outputPath, outputLabel = "Results saved") {
-  console.log(`Benchmark: ${result.meta.benchmark}`);
-  console.log(`Mode: ${result.meta.mode}`);
-  if (result.config.runtimeProfile) {
-    console.log(`Runtime profile: ${result.config.runtimeProfile}`);
-  }
-  console.log(`Tasks: ${result.results.tasks.length}`);
-  console.log(`Mean query latency: ${result.cost.meanQueryLatencyMs.toFixed(1)}ms`);
-  for (const [metric, aggregate] of Object.entries(result.results.aggregates).sort()) {
-    console.log(`  ${metric.padEnd(20)} ${aggregate.mean.toFixed(4)}`);
-  }
-  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}`);
-}
-function printStoredBenchResultDetails(result, summary) {
-  printStoredBenchResultSummary(result, summary);
-  if (result.results.tasks.length === 0) {
-    console.log("Tasks: none");
-    return;
-  }
-  console.log("Task breakdown:");
-  for (const task of result.results.tasks) {
-    const scores = Object.entries(task.scores).sort(([left], [right]) => left.localeCompare(right)).map(([metric, value]) => `${metric}=${value.toFixed(4)}`).join(", ");
-    console.log(
-      `  ${task.taskId}: ${task.latencyMs.toFixed(1)}ms${scores.length > 0 ? ` [${scores}]` : ""}`
-    );
-  }
-}
-function printBenchComparisonSummary(comparison, baseline, candidate) {
-  console.log(`Benchmark: ${comparison.benchmark}`);
-  console.log(`Baseline: ${baseline.id} (${baseline.path})`);
-  console.log(`Candidate: ${candidate.id} (${candidate.path})`);
-  console.log(`Verdict: ${comparison.verdict}`);
-  const metrics = Object.entries(comparison.metricDeltas).sort(
-    ([left], [right]) => left.localeCompare(right)
-  );
-  if (metrics.length === 0) {
-    console.log("No overlapping metrics were found between the two results.");
-    return;
-  }
-  console.log("Metrics:");
-  for (const [metric, delta] of metrics) {
-    const percent = Number.isFinite(delta.percentChange) ? `${(delta.percentChange * 100).toFixed(2)}%` : delta.percentChange > 0 ? "+Infinity%" : "-Infinity%";
-    const direction = delta.delta >= 0 ? "+" : "";
-    console.log(
-      `  ${metric.padEnd(18)} ${delta.baseline.toFixed(4)} -> ${delta.candidate.toFixed(4)} (${direction}${delta.delta.toFixed(4)}, ${percent}, d=${delta.effectSize.cohensD.toFixed(3)} ${delta.effectSize.interpretation})`
-    );
-    if (delta.ciOnDelta) {
-      console.log(
-        `    CI95 delta: [${delta.ciOnDelta.lower.toFixed(4)}, ${delta.ciOnDelta.upper.toFixed(4)}]`
-      );
-    }
-  }
-}
 async function compareBenchPackageResults(parsed) {
   const refs = parsed.benchmarks;
   if (refs.length !== 2) {
@@ -5150,8 +5247,8 @@ async function exportBenchPackageResult(parsed) {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs10.mkdirSync(path12.dirname(parsed.output), { recursive: true });
-    fs10.writeFileSync(parsed.output, rendered);
+    fs11.mkdirSync(path12.dirname(parsed.output), { recursive: true });
+    fs11.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
   }
@@ -5196,7 +5293,7 @@ async function manageBenchDatasets(parsed) {
     process.exit(1);
   }
   const scriptPath = resolveDatasetDownloadScriptPath();
-  if (!fs10.existsSync(scriptPath)) {
+  if (!fs11.existsSync(scriptPath)) {
     console.error(`ERROR: dataset download script not found: ${scriptPath}`);
     process.exit(1);
   }
@@ -5396,7 +5493,7 @@ async function calibrateBenchJudges(parsed, rawArgs) {
     );
     process.exit(1);
   }
-  const sourceResultSha256 = createHash2("sha256").update(fs10.readFileSync(latest.path)).digest("hex");
+  const sourceResultSha256 = createHash2("sha256").update(fs11.readFileSync(latest.path)).digest("hex");
   const expandedManifestPath = expandTilde(manifestPath);
   if (!bench.resolveLocalLabJudgeProviderConfig) {
     console.error(
@@ -5705,16 +5802,23 @@ async function runBenchPublished(parsed) {
     }
     return;
   }
-  const runtimeProfiles = resolveBenchRunProfiles(parsed);
   const benchmarkId = parsed.publishedName;
+  const runtimeProfiles = orderPairedLoCoMoWorkItems(
+    resolveBenchRunProfiles(parsed).map((runtimeProfile) => ({
+      benchmarkId,
+      runtimeProfile
+    }))
+  ).map((item) => item.runtimeProfile);
   const writtenPaths = [];
+  const pairedAnswerReplayCache = benchmarkId === "locomo" && runtimeProfiles.includes("baseline") && runtimeProfiles.includes("real") ? /* @__PURE__ */ new Map() : void 0;
   for (const runtimeProfile of runtimeProfiles) {
     const result = await runBenchViaPackage(
       parsed,
       benchmarkId,
       runtimeProfile,
       void 0,
-      taskSelector
+      taskSelector,
+      pairedAnswerReplayCache
     );
     if (!result.ok) {
       console.error(
@@ -5804,7 +5908,7 @@ function loadPinnedLoCoMoTaskSelector(parsed) {
   }
   let decoded;
   try {
-    decoded = JSON.parse(fs10.readFileSync(parsed.taskIdsFile, "utf8"));
+    decoded = JSON.parse(fs11.readFileSync(parsed.taskIdsFile, "utf8"));
   } catch (error) {
     throw new Error(
       `Unable to read --task-ids-file ${parsed.taskIdsFile}: ${error instanceof Error ? error.message : String(error)}`
@@ -5969,7 +6073,29 @@ async function preflightLocalLabEndpointsIfNeeded(benchModule, plan) {
     );
   }
 }
-async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStatusPath, taskSelector) {
+function pairedAnswerReplayCacheForBenchmark(benchmarkId, pairedAnswerReplayCache) {
+  return benchmarkId === "locomo" ? pairedAnswerReplayCache : void 0;
+}
+function clearPairedAnswerReplayCacheOnFailure(runtimeProfile, benchmarkId, pairedAnswerReplayCache) {
+  if (runtimeProfile !== "baseline" || benchmarkId !== "locomo") return;
+  pairedAnswerReplayCache?.clear();
+}
+function orderPairedLoCoMoWorkItems(workItems) {
+  const baselineIndex = workItems.findIndex(
+    (item) => item.benchmarkId === "locomo" && item.runtimeProfile === "baseline"
+  );
+  const realIndex = workItems.findIndex(
+    (item) => item.benchmarkId === "locomo" && item.runtimeProfile === "real"
+  );
+  if (baselineIndex < 0 || realIndex < 0 || baselineIndex < realIndex) {
+    return [...workItems];
+  }
+  const ordered = [...workItems];
+  const [baseline] = ordered.splice(baselineIndex, 1);
+  ordered.splice(realIndex, 0, baseline);
+  return ordered;
+}
+async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStatusPath, taskSelector, pairedAnswerReplayCache) {
   const loaded = await tryLoadBenchModule();
   if (!loaded) return { ok: false };
   assertBenchModuleFreshForDevelopment();
@@ -6039,6 +6165,10 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
     if (benchmarkId === "memcorrect-v1" && parsed.adapter === "mcp") {
       benchmarkOptions = { ...benchmarkOptions ?? {}, adapter: system };
     }
+    const locomoPairedAnswerReplayCache = pairedAnswerReplayCacheForBenchmark(
+      benchmarkId,
+      pairedAnswerReplayCache
+    );
     const result = await benchModule.runBenchmark(benchmarkId, {
       mode: parsed.quick ? "quick" : "full",
       datasetDir,
@@ -6055,6 +6185,7 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
       // Issue #1573 PR1: judge-result cache controls from the CLI flags.
       ...parsed.noJudgeCache ? { noJudgeCache: true } : {},
       ...parsed.judgeCacheDir ? { judgeCacheDir: parsed.judgeCacheDir } : {},
+      ...locomoPairedAnswerReplayCache ? { pairedAnswerReplayCache: locomoPairedAnswerReplayCache } : {},
       ...benchmarkOptions ? { benchmarkOptions } : {},
       ...amaBenchProtocol.judgeProtocol ? { amaBenchJudgeProtocol: amaBenchProtocol.judgeProtocol } : {},
       ...amaBenchProtocol.crossJudge ? { amaBenchCrossJudge: amaBenchProtocol.crossJudge } : {},
@@ -6092,6 +6223,11 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
     }
     return { ok: true, writtenPath };
   } catch (err) {
+    clearPairedAnswerReplayCacheOnFailure(
+      runtimeProfile,
+      benchmarkId,
+      pairedAnswerReplayCache
+    );
     if (partialTasks.length > 0) {
       const remnicVersion = await benchModule.getRemnicVersion?.() ?? "unknown";
       const partialResult = buildPartialBenchmarkResult(
@@ -6444,7 +6580,7 @@ function resolveBenchReproDatasetDir(datasetDir) {
     return void 0;
   }
   try {
-    return fs10.realpathSync(datasetDir);
+    return fs11.realpathSync(datasetDir);
   } catch {
     return datasetDir;
   }
@@ -6507,13 +6643,13 @@ function resolveConfigPath(cliPath) {
     path12.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
-    if (fs10.existsSync(candidate)) return candidate;
+    if (fs11.existsSync(candidate)) return candidate;
   }
   return path12.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
 function resolveExistingBenchRemnicConfigPath(cliPath) {
   const configPath = resolveConfigPath(cliPath);
-  if (fs10.existsSync(configPath)) {
+  if (fs11.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -6523,7 +6659,7 @@ function resolveExistingBenchRemnicConfigPath(cliPath) {
 }
 function resolveExistingBenchOpenclawConfigPath(cliPath) {
   const configPath = resolveOpenclawConfigPath(cliPath);
-  if (fs10.existsSync(configPath)) {
+  if (fs11.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -6630,8 +6766,8 @@ function resolveMemoryDir() {
     const envMemoryDir = readCompatEnv("REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR");
     if (envMemoryDir) return normalizeMemoryDirPath(envMemoryDir);
     const configPath = resolveConfigPath();
-    const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord3(raw);
+    const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord4(raw);
     if (typeof remnicCfg.memoryDir === "string" && remnicCfg.memoryDir.length > 0) {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
@@ -6639,18 +6775,18 @@ function resolveMemoryDir() {
     const standalonePath = path12.join(home, ".remnic", "memory");
     const legacyStandalonePath = path12.join(home, ".engram", "memory");
     const openclawPath = path12.join(home, ".openclaw", "workspace", "memory", "local");
-    if (fs10.existsSync(standalonePath)) return standalonePath;
-    if (fs10.existsSync(legacyStandalonePath)) return legacyStandalonePath;
+    if (fs11.existsSync(standalonePath)) return standalonePath;
+    if (fs11.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
   })();
   const manifestPath = getManifestPath();
-  if (fs10.existsSync(manifestPath)) {
+  if (fs11.existsSync(manifestPath)) {
     try {
       const active = getActiveSpace();
       if (active?.memoryDir) {
         const activeMemoryDir = normalizeMemoryDirPath(active.memoryDir);
-        if (!fs10.existsSync(activeMemoryDir)) {
-          fs10.mkdirSync(activeMemoryDir, { recursive: true });
+        if (!fs11.existsSync(activeMemoryDir)) {
+          fs11.mkdirSync(activeMemoryDir, { recursive: true });
         }
         return activeMemoryDir;
       }
@@ -6696,13 +6832,13 @@ function resolveOpenclawConfigPath(cliPath) {
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
   if (envPath) return path12.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
-    if (fs10.existsSync(candidate)) return candidate;
+    if (fs11.existsSync(candidate)) return candidate;
   }
   return path12.join(resolveHomeDir(), ".openclaw", "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
-  if (!fs10.existsSync(configPath)) return {};
-  const raw = fs10.readFileSync(configPath, "utf-8");
+  if (!fs11.existsSync(configPath)) return {};
+  const raw = fs11.readFileSync(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -6801,14 +6937,14 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   return `${yyyy}${mm}${dd}-${hh}${min}${ss}`;
 }
 function backupPathIfPresent(sourcePath, backupPath) {
-  if (!fs10.existsSync(sourcePath)) return false;
-  fs10.mkdirSync(path12.dirname(backupPath), { recursive: true });
-  fs10.cpSync(sourcePath, backupPath, { recursive: true });
+  if (!fs11.existsSync(sourcePath)) return false;
+  fs11.mkdirSync(path12.dirname(backupPath), { recursive: true });
+  fs11.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
 function assertDirectoryPathOrMissing(targetPath, label) {
-  if (!fs10.existsSync(targetPath)) return;
-  const stat = fs10.statSync(targetPath);
+  if (!fs11.existsSync(targetPath)) return;
+  const stat = fs11.statSync(targetPath);
   if (!stat.isDirectory()) {
     throw new Error(`${label} must be a directory when it already exists: ${targetPath}`);
   }
@@ -6833,7 +6969,7 @@ var PublishedOpenclawPluginInstallError = class extends Error {
   }
 };
 function installPublishedOpenclawPlugin(spec, pluginDir) {
-  const tempRoot = fs10.mkdtempSync(path12.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
+  const tempRoot = fs11.mkdtempSync(path12.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
   const stagedDir = `${pluginDir}.next-${process.pid}-${Date.now()}`;
   const rollbackDir = `${pluginDir}.rollback-${process.pid}-${Date.now()}`;
   let swapRollbackDir;
@@ -6849,16 +6985,16 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
       throw new Error(`npm pack ${spec} did not return a tarball name`);
     }
     const unpackDir = path12.join(tempRoot, "unpacked");
-    fs10.mkdirSync(unpackDir, { recursive: true });
+    fs11.mkdirSync(unpackDir, { recursive: true });
     childProcess2.execFileSync("tar", ["-xzf", path12.join(tempRoot, tarballName), "-C", unpackDir], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const packagedDir = path12.join(unpackDir, "package");
-    if (!fs10.existsSync(packagedDir)) {
+    if (!fs11.existsSync(packagedDir)) {
       throw new Error(`npm pack ${spec} did not contain a package/ directory`);
     }
-    fs10.rmSync(stagedDir, { recursive: true, force: true });
-    fs10.cpSync(packagedDir, stagedDir, { recursive: true });
+    fs11.rmSync(stagedDir, { recursive: true, force: true });
+    fs11.cpSync(packagedDir, stagedDir, { recursive: true });
     childProcess2.execFileSync("npm", ["install", "--omit=dev"], {
       cwd: stagedDir,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6874,7 +7010,7 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
     })();
     swapRollbackDir = swapResult.rollbackDir;
     const installedPackageJsonPath = path12.join(pluginDir, "package.json");
-    const installedPackage = fs10.existsSync(installedPackageJsonPath) ? JSON.parse(fs10.readFileSync(installedPackageJsonPath, "utf8")) : {};
+    const installedPackage = fs11.existsSync(installedPackageJsonPath) ? JSON.parse(fs11.readFileSync(installedPackageJsonPath, "utf8")) : {};
     return {
       rollbackDir: swapRollbackDir,
       version: typeof installedPackage.version === "string" ? installedPackage.version : void 0
@@ -6889,8 +7025,8 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
       }
     );
   } finally {
-    fs10.rmSync(stagedDir, { recursive: true, force: true });
-    fs10.rmSync(tempRoot, { recursive: true, force: true });
+    fs11.rmSync(stagedDir, { recursive: true, force: true });
+    fs11.rmSync(tempRoot, { recursive: true, force: true });
   }
 }
 function restartOpenclawGateway() {
@@ -6909,7 +7045,7 @@ function restartOpenclawGateway() {
 }
 function cmdInit() {
   const configPath = path12.join(process.cwd(), "remnic.config.json");
-  if (fs10.existsSync(configPath)) {
+  if (fs11.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
   }
@@ -6925,7 +7061,7 @@ function cmdInit() {
       authToken: "${REMNIC_AUTH_TOKEN}"
     }
   };
-  fs10.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
+  fs11.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
   console.log(`Created ${configPath}`);
   console.log("\nSet these environment variables:");
   console.log("  export OPENAI_API_KEY=sk-...");
@@ -6995,7 +7131,7 @@ async function cmdStatus(json) {
 }
 function oauthReadConfigRecord(configPath) {
   try {
-    const parsed = JSON.parse(fs10.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs11.readFileSync(configPath, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -7411,10 +7547,10 @@ async function cmdQuery(queryText, json, explain) {
   }
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
-  const orchestrator = new Orchestrator2(config);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
+  const orchestrator = new Orchestrator3(config);
   await orchestrator.initialize();
   const service = new EngramAccessService2(orchestrator);
   const recallRequest = buildQueryRecallRequest(queryText);
@@ -7582,10 +7718,10 @@ async function cmdXray(rest) {
   parseXrayCliOptions(rawQuery, options);
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
-  const orchestrator = new Orchestrator2(config);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
+  const orchestrator = new Orchestrator3(config);
   await orchestrator.initialize();
   await orchestrator.deferredReady;
   const service = new EngramAccessService2(orchestrator);
@@ -7605,9 +7741,9 @@ async function cmdXray(rest) {
 async function cmdVersions(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   if (!config.versioningEnabled) {
     console.error("Page versioning is disabled (versioningEnabled = false).");
     process.exit(1);
@@ -7721,9 +7857,9 @@ Options:
 async function cmdEnrich(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
@@ -7751,7 +7887,7 @@ async function cmdEnrich(rest) {
     pipelineConfig2.providers = [
       { id: "web-search", enabled: true, costTier: "cheap" }
     ];
-    const orchestrator2 = new Orchestrator2(config);
+    const orchestrator2 = new Orchestrator3(config);
     await orchestrator2.initialize();
     await orchestrator2.deferredReady;
     const searchBackend2 = orchestrator2.qmd;
@@ -7787,7 +7923,7 @@ Registered providers:`);
     console.error("Usage: remnic enrich <entity-name> | --all | --dry-run | audit | providers");
     process.exit(1);
   }
-  const orchestrator = new Orchestrator2(config);
+  const orchestrator = new Orchestrator3(config);
   await orchestrator.initialize();
   await orchestrator.deferredReady;
   const storage = await orchestrator.getStorage(config.defaultNamespace);
@@ -7966,9 +8102,9 @@ Shared with:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   const memoryDir = expandTilde(
     typeof memoryDirOverride === "string" && memoryDirOverride.length > 0 ? memoryDirOverride : config.memoryDir ?? resolveMemoryDir()
   );
@@ -7983,9 +8119,9 @@ Shared with:
 async function cmdExtensions(action, rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   const root = resolveExtensionsRoot(config);
   const noopLog = { warn: () => {
   }, debug: () => {
@@ -8034,7 +8170,7 @@ Root: ${root}`);
       const extensions = await discoverMemoryExtensions(root, warnLog);
       let entries = [];
       try {
-        entries = fs10.readdirSync(root);
+        entries = fs11.readdirSync(root);
       } catch {
         console.log(`Extensions root does not exist: ${root}`);
         process.exitCode = 0;
@@ -8045,7 +8181,7 @@ Root: ${root}`);
       for (const entry of entries) {
         const entryPath = path12.join(root, entry);
         try {
-          if (!fs10.statSync(entryPath).isDirectory()) continue;
+          if (!fs11.statSync(entryPath).isDirectory()) continue;
         } catch {
           continue;
         }
@@ -8077,9 +8213,9 @@ Root: ${root}`);
 async function cmdBriefing(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   if (!config.briefing.enabled) {
     console.error("Briefing is disabled in config (briefing.enabled = false).");
     process.exit(1);
@@ -8132,7 +8268,7 @@ async function cmdBriefing(rest) {
     process.exit(1);
   }
   const format = effectiveFormatFlag === "json" ? "json" : effectiveFormatFlag === "markdown" ? "markdown" : config.briefing.defaultFormat;
-  const orchestrator = new Orchestrator2(config);
+  const orchestrator = new Orchestrator3(config);
   await orchestrator.initialize();
   const storage = await orchestrator.getStorage(config.defaultNamespace);
   const calendarSource = config.briefing.calendarSource ? new FileCalendarSource(config.briefing.calendarSource) : void 0;
@@ -8157,10 +8293,10 @@ async function cmdBriefing(rest) {
   if (save) {
     try {
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
-      fs10.mkdirSync(saveDir, { recursive: true });
+      fs11.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
       const filePath = path12.join(saveDir, filename);
-      fs10.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
+      fs11.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
       console.error(`Saved briefing: ${filePath}`);
     } catch (err) {
       console.error(`Failed to save briefing: ${err instanceof Error ? err.message : String(err)}`);
@@ -8178,7 +8314,7 @@ async function cmdDoctor() {
     detail: `${nodeVersion} (requires >= 22.12.0)`
   });
   const configPath = resolveConfigPath();
-  const configExists = fs10.existsSync(configPath);
+  const configExists = fs11.existsSync(configPath);
   checks.push({ name: "Config file", ok: configExists, detail: configPath });
   let standaloneConfig;
   let standaloneConfigError;
@@ -8186,11 +8322,11 @@ async function cmdDoctor() {
   let configuredNs = { invalid: false };
   if (configExists) {
     try {
-      const raw = JSON.parse(fs10.readFileSync(configPath, "utf8"));
-      const remnicCfg = resolveRemnicConfigRecord3(raw);
+      const raw = JSON.parse(fs11.readFileSync(configPath, "utf8"));
+      const remnicCfg = resolveRemnicConfigRecord4(raw);
       standaloneOpenaiApiKeyExplicitlyFalse = isOpenaiApiKeyDisabled(remnicCfg.openaiApiKey);
       configuredNs = readConfiguredNamespace(remnicCfg);
-      standaloneConfig = parseConfig3(remnicCfg);
+      standaloneConfig = parseConfig4(remnicCfg);
     } catch (err) {
       standaloneConfigError = err instanceof Error ? err.message : String(err);
     }
@@ -8199,10 +8335,10 @@ async function cmdDoctor() {
   try {
     memoryDir = resolveMemoryDir();
   } catch {
-    memoryDir = parseConfig3({}).memoryDir;
+    memoryDir = parseConfig4({}).memoryDir;
   }
   try {
-    fs10.mkdirSync(memoryDir, { recursive: true });
+    fs11.mkdirSync(memoryDir, { recursive: true });
     checks.push({ name: "Memory directory", ok: true, detail: memoryDir });
   } catch {
     checks.push({ name: "Memory directory", ok: false, detail: `cannot create ${memoryDir}` });
@@ -8231,7 +8367,7 @@ async function cmdDoctor() {
   });
   if (nsPolicyCheck) checks.push(nsPolicyCheck);
   const openclawConfigPath = resolveOpenclawConfigPath();
-  const openclawConfigExists = fs10.existsSync(openclawConfigPath);
+  const openclawConfigExists = fs11.existsSync(openclawConfigPath);
   let openclawConfig = {};
   let openclawConfigValid = false;
   let openclawPluginModeConfigured = false;
@@ -8239,7 +8375,7 @@ async function cmdDoctor() {
   let activeOpenclawEntryConfig = null;
   if (openclawConfigExists) {
     try {
-      const parsed = JSON.parse(fs10.readFileSync(openclawConfigPath, "utf-8"));
+      const parsed = JSON.parse(fs11.readFileSync(openclawConfigPath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         openclawConfig = parsed;
         openclawConfigValid = true;
@@ -8319,9 +8455,9 @@ async function cmdDoctor() {
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
-        if (fs10.existsSync(resolvedMemDir)) {
+        if (fs11.existsSync(resolvedMemDir)) {
           try {
-            const stat = fs10.statSync(resolvedMemDir);
+            const stat = fs11.statSync(resolvedMemDir);
             if (stat.isDirectory()) {
               memDirOk = true;
               memDirDetail = resolvedMemDir;
@@ -8463,12 +8599,12 @@ async function cmdDoctor() {
 }
 function cmdConfig() {
   const configPath = resolveConfigPath();
-  if (!fs10.existsSync(configPath)) {
+  if (!fs11.existsSync(configPath)) {
     console.log("No config file found. Run `remnic init` to create one.");
     return;
   }
   console.log(`Config: ${configPath}`);
-  const rawConfig = fs10.readFileSync(configPath, "utf8");
+  const rawConfig = fs11.readFileSync(configPath, "utf8");
   const redacted = rawConfig.replace(
     /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
     "$1[REDACTED]$3"
@@ -8576,9 +8712,9 @@ async function cmdReview(action, rest) {
     const configPath = resolveConfigPath();
     let tombstonesConfig = null;
     try {
-      const rawCfg = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-      const remnicCfg = resolveRemnicConfigRecord3(rawCfg);
-      const config = parseConfig3(remnicCfg);
+      const rawCfg = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+      const remnicCfg = resolveRemnicConfigRecord4(rawCfg);
+      const config = parseConfig4(remnicCfg);
       tombstonesConfig = {
         enabled: config.tombstonesEnabled,
         semanticMatch: config.tombstonesSemanticMatch,
@@ -9329,7 +9465,7 @@ async function pushOfflineFileContent(args) {
 }
 async function pushOfflineFileContentFromChunkReader(args) {
   const filePath = resolveOfflineDirectHydrationPath(args.memoryDir, args.file.path);
-  const stat = fs10.statSync(filePath);
+  const stat = fs11.statSync(filePath);
   if (stat.mtimeMs !== args.file.mtimeMs) {
     throw new Error(`local file changed while pushing offline content: ${args.file.path}`);
   }
@@ -9820,7 +9956,7 @@ function advanceOfflineBaseFilesForSuccessfulPush(options) {
   return [...next.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function runOfflineSyncOnce(options) {
-  fs10.mkdirSync(options.memoryDir, { recursive: true });
+  fs11.mkdirSync(options.memoryDir, { recursive: true });
   let activeStatePath = options.statePath;
   let priorState = await readOfflineSyncState(activeStatePath);
   let syncNamespace = options.namespace ?? priorState?.namespace;
@@ -10446,7 +10582,7 @@ Environment fallbacks:
   const configPath = resolveConfigPath();
   let config;
   try {
-    const rawConfig = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
+    const rawConfig = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
     config = parseConfigQuietly(pickOfflineConfigRecord(rawConfig));
   } catch {
     throw new Error(
@@ -10461,7 +10597,7 @@ Environment fallbacks:
   const statePath = statePathExplicit ? path12.resolve(expandTilde(stateOverride)) : remoteUrl !== void 0 ? defaultOfflineSyncStatePath(memoryDir, remoteUrl, namespace) : void 0;
   if (action === "prepare") {
     if (!remoteUrl || !token || !statePath) throw new Error("offline prepare requires remote URL and token");
-    fs10.mkdirSync(memoryDir, { recursive: true });
+    fs11.mkdirSync(memoryDir, { recursive: true });
     const remoteSnapshot = await fetchOfflineSnapshot({
       remoteUrl,
       token,
@@ -10559,7 +10695,7 @@ Environment fallbacks:
     return;
   }
   if (action === "status") {
-    fs10.mkdirSync(memoryDir, { recursive: true });
+    fs11.mkdirSync(memoryDir, { recursive: true });
     const state = statePath ? await readOfflineSyncState(statePath) : null;
     if (state && remoteUrl && statePath) {
       assertOfflineStateMatches({
@@ -10697,7 +10833,7 @@ function cmdDedup(json) {
 function readInstalledConnectorConfig(configPath, fallback) {
   if (!configPath) return fallback;
   try {
-    const parsed = JSON.parse(fs10.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs11.readFileSync(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
     const { token: _token, ...config } = parsed;
     return config;
@@ -10875,7 +11011,7 @@ async function cmdConnectors(action, rest, json) {
           const pub = factory();
           const available = await pub.isHostAvailable();
           const extRoot = available ? await pub.resolveExtensionRoot() : "(host not installed)";
-          const extensionExists = available && extRoot ? fs10.existsSync(extRoot) : false;
+          const extensionExists = available && extRoot ? fs11.existsSync(extRoot) : false;
           publisherChecks.push({
             name: `Publisher: ${targetHostId}`,
             ok: !available || extensionExists,
@@ -10949,7 +11085,7 @@ async function cmdConnectors(action, rest, json) {
     let connectorsCfg;
     const configPath = resolveConfigPath();
     try {
-      const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
+      const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
       connectorsCfg = parseConfigQuietly(raw).connectors;
     } catch {
       process.stderr.write(
@@ -11025,10 +11161,10 @@ async function cmdConnectors(action, rest, json) {
     }
     initLogger2();
     const configPath = resolveConfigPath();
-    const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord3(raw);
-    const config = parseConfig3(remnicCfg);
-    const orchestrator = new Orchestrator2(config);
+    const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord4(raw);
+    const config = parseConfig4(remnicCfg);
+    const orchestrator = new Orchestrator3(config);
     try {
       await orchestrator.initialize();
       await orchestrator.deferredReady;
@@ -11150,9 +11286,9 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     console.error(`connectors marketplace: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
-  const rawConfig = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const pluginConfig = resolveRemnicConfigRecord3(rawConfig);
-  const config = parseConfig3(pluginConfig);
+  const rawConfig = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const pluginConfig = resolveRemnicConfigRecord4(rawConfig);
+  const config = parseConfig4(pluginConfig);
   if (subAction === "generate") {
     let outputDir;
     try {
@@ -11172,13 +11308,13 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
   } else if (subAction === "validate") {
     const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path12.join(process.cwd(), "marketplace.json");
     const resolved = path12.resolve(targetPath);
-    if (!fs10.existsSync(resolved)) {
+    if (!fs11.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs10.readFileSync(resolved, "utf8"));
+      parsed = JSON.parse(fs11.readFileSync(resolved, "utf8"));
     } catch {
       console.error(`Invalid JSON in ${resolved}`);
       process.exit(1);
@@ -11379,10 +11515,10 @@ async function cmdSpace(action, rest, json) {
 async function cmdLegacyBenchmark(action, rest, json) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
-  const orchestrator = new Orchestrator2(config);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
+  const orchestrator = new Orchestrator3(config);
   const service = new EngramAccessService2(orchestrator);
   const { runBenchSuite, loadBaseline, checkRegression } = await loadBenchModule();
   const benchConfig = {
@@ -11623,8 +11759,13 @@ async function cmdBench(rest) {
   } catch {
   }
   const writtenPaths = [];
+  const pairedAnswerReplayCache = selectedWorkItems.some(
+    (item) => item.benchmarkId === "locomo" && item.runtimeProfile === "baseline"
+  ) && selectedWorkItems.some(
+    (item) => item.benchmarkId === "locomo" && item.runtimeProfile === "real"
+  ) ? /* @__PURE__ */ new Map() : void 0;
   try {
-    for (const { benchmarkId, runtimeProfile } of selectedWorkItems) {
+    for (const { benchmarkId, runtimeProfile } of orderPairedLoCoMoWorkItems(selectedWorkItems)) {
       const statusId = runtimeProfiles.length > 1 ? `${benchmarkId} [${runtimeProfile}]` : benchmarkId;
       try {
         await updateBenchmarkStarted(benchStatusPath, statusId);
@@ -11636,7 +11777,8 @@ async function cmdBench(rest) {
           benchmarkId,
           runtimeProfile,
           benchStatusPath,
-          taskSelector
+          taskSelector,
+          pairedAnswerReplayCache
         );
         if (handledByPackage.ok) {
           if (handledByPackage.writtenPath) {
@@ -11772,7 +11914,7 @@ function readPid() {
 function inferPort() {
   try {
     const configPath = resolveConfigPath();
-    const raw = JSON.parse(fs10.readFileSync(configPath, "utf8"));
+    const raw = JSON.parse(fs11.readFileSync(configPath, "utf8"));
     return raw.server?.port ?? 4318;
   } catch {
     return 4318;
@@ -11867,13 +12009,13 @@ function daemonInstall() {
     process.exit(1);
   }
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
-  fs10.mkdirSync(LOGS_DIR, { recursive: true });
+  fs11.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
     const templatePath = path12.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
-    const template = fs10.readFileSync(templatePath, "utf8");
+    const template = fs11.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs10.mkdirSync(path12.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
-    fs10.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    fs11.mkdirSync(path12.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs11.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
     } catch (err) {
@@ -11890,10 +12032,10 @@ function daemonInstall() {
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
     const templatePath = path12.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
-    const template = fs10.readFileSync(templatePath, "utf8");
+    const template = fs11.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs10.mkdirSync(path12.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
-    fs10.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    fs11.mkdirSync(path12.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs11.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
     } catch (err) {
@@ -11929,7 +12071,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs10.unlinkSync(plistPath);
+        fs11.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -11949,7 +12091,7 @@ function daemonUninstall() {
     let removed = false;
     for (const unitPath of SYSTEMD_UNIT_PATHS) {
       try {
-        fs10.unlinkSync(unitPath);
+        fs11.unlinkSync(unitPath);
         removed = true;
         console.log(`Removed systemd service: ${unitPath}`);
       } catch {
@@ -12016,13 +12158,13 @@ async function daemonStatus() {
   console.log(`  Port:      ${port}`);
   console.log(`  Service:   ${serviceInstalled ? "installed" : "not installed"}`);
   console.log(`  Platform:  ${process.platform}`);
-  console.log(`  PID file:  ${fs10.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
-  console.log(`  Log file:  ${fs10.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  console.log(`  PID file:  ${fs11.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
+  console.log(`  Log file:  ${fs11.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
   try {
     const configPath = resolveConfigPath();
-    const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord3(raw);
-    const config = parseConfig3(remnicCfg);
+    const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord4(raw);
+    const config = parseConfig4(remnicCfg);
     const extRoot = resolveExtensionsRoot(config);
     const noopLog = { warn: () => {
     }, debug: () => {
@@ -12061,9 +12203,9 @@ function daemonStart() {
       return;
     }
   }
-  fs10.mkdirSync(PID_DIR, { recursive: true });
-  fs10.mkdirSync(LOGS_DIR, { recursive: true });
-  const logStream = fs10.openSync(LOG_FILE, "a");
+  fs11.mkdirSync(PID_DIR, { recursive: true });
+  fs11.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs11.openSync(LOG_FILE, "a");
   const serverBin = resolveServerBin();
   const isSource = serverBin.endsWith(".ts");
   let cmd;
@@ -12085,7 +12227,7 @@ function daemonStart() {
     }
   });
   child.unref();
-  fs10.writeFileSync(PID_FILE, String(child.pid));
+  fs11.writeFileSync(PID_FILE, String(child.pid));
   console.log(`Started remnic server (pid ${child.pid})`);
   console.log(`  Log: ${LOG_FILE}`);
 }
@@ -12119,11 +12261,11 @@ function daemonStop() {
     console.log("Process not found (cleaning up PID file)");
   }
   try {
-    fs10.unlinkSync(PID_FILE);
+    fs11.unlinkSync(PID_FILE);
   } catch {
   }
   try {
-    fs10.unlinkSync(LEGACY_PID_FILE);
+    fs11.unlinkSync(LEGACY_PID_FILE);
   } catch {
   }
 }
@@ -12251,9 +12393,9 @@ async function promptYesNo(question, defaultYes = true) {
 async function cmdBinary(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   const memoryDir = resolveMemoryDir();
   const blConfig = {
     enabled: config.binaryLifecycleEnabled,
@@ -12442,7 +12584,7 @@ async function cmdOpenclawInstall(opts) {
   } else if (slotIsActiveLegacy) {
     changes.push(`  Slot left as "${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}" \u2014 re-run with --yes to activate the new entry`);
   }
-  if (!fs10.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
+  if (!fs11.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
   if (hasLegacy && migrateLegacy) {
     changes.push(`~ Legacy '${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}' entry retained (safe to remove after verifying hooks fire)`);
   }
@@ -12462,8 +12604,8 @@ async function cmdOpenclawInstall(opts) {
 Resulting plugins.slots.memory: ${dryRunPlugins.slots?.memory ?? "(unset)"}`);
     return;
   }
-  if (fs10.existsSync(memoryDir)) {
-    const st = fs10.statSync(memoryDir);
+  if (fs11.existsSync(memoryDir)) {
+    const st = fs11.statSync(memoryDir);
     if (!st.isDirectory()) {
       throw new Error(
         `Cannot use ${memoryDir} as the memory directory \u2014 a file already exists at that path.
@@ -12471,12 +12613,12 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
       );
     }
   } else {
-    fs10.mkdirSync(memoryDir, { recursive: true });
+    fs11.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
   const configDir = path12.dirname(configPath);
-  if (!fs10.existsSync(configDir)) {
-    fs10.mkdirSync(configDir, { recursive: true });
+  if (!fs11.existsSync(configDir)) {
+    fs11.mkdirSync(configDir, { recursive: true });
   }
   atomicWriteFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
   console.log("\nDone! Summary of changes:");
@@ -12648,15 +12790,15 @@ async function cmdOpenclawMigrateEngram(opts) {
 }
 function createOpenclawUpgradeBackupDir() {
   const backupsRoot = path12.join(resolveHomeDir(), ".openclaw", "backups");
-  fs10.mkdirSync(backupsRoot, { recursive: true });
-  return fs10.mkdtempSync(path12.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  fs11.mkdirSync(backupsRoot, { recursive: true });
+  return fs11.mkdtempSync(path12.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord3(raw);
-  const config = parseConfig3(remnicCfg);
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord4(raw);
+  const config = parseConfig4(remnicCfg);
   if (!config.taxonomyEnabled) {
     console.error(
       "Taxonomy is disabled in config (taxonomyEnabled = false). Enable it to use taxonomy commands."
@@ -12692,8 +12834,8 @@ async function cmdTaxonomy(rest) {
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
         const resolverPath = path12.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs10.mkdirSync(path12.dirname(resolverPath), { recursive: true });
-        fs10.writeFileSync(resolverPath, doc);
+        fs11.mkdirSync(path12.dirname(resolverPath), { recursive: true });
+        fs11.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
       break;
@@ -12739,7 +12881,7 @@ async function cmdTaxonomy(rest) {
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
         const resolverPath = path12.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs10.writeFileSync(resolverPath, doc);
+        fs11.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -12770,7 +12912,7 @@ async function cmdTaxonomy(rest) {
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
         const resolverPath = path12.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs10.writeFileSync(resolverPath, doc);
+        fs11.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -12961,12 +13103,12 @@ async function runTrainingExport(args, stdout = process.stdout) {
       `Unknown training-export format "${args.format}". ${validList}`
     );
   }
-  if (!fs10.existsSync(args.memoryDir)) {
+  if (!fs11.existsSync(args.memoryDir)) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" does not exist. Provide the path to an existing memory directory.`
     );
   }
-  if (!fs10.statSync(args.memoryDir).isDirectory()) {
+  if (!fs11.statSync(args.memoryDir).isDirectory()) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" is not a directory. Provide the path to a memory directory, not a file.`
     );
@@ -13052,10 +13194,10 @@ async function runTrainingExport(args, stdout = process.stdout) {
   }
   const formatted = adapter.formatRecords(records);
   const outDir = path12.dirname(args.output);
-  fs10.mkdirSync(outDir, { recursive: true });
+  fs11.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
-  fs10.writeFileSync(tmpPath, formatted, "utf-8");
-  fs10.renameSync(tmpPath, args.output);
+  fs11.writeFileSync(tmpPath, formatted, "utf-8");
+  fs11.renameSync(tmpPath, args.output);
   stdout.write(
     `Exported ${records.length} records to ${args.output} (${adapter.name} format)
 `
@@ -13224,7 +13366,7 @@ async function main(argv = process.argv.slice(2)) {
             }
           }, 500);
         };
-        fs10.watch(memoryDir, { recursive: true }, (_event, filename) => {
+        fs11.watch(memoryDir, { recursive: true }, (_event, filename) => {
           if (filename && filename.startsWith(".")) return;
           rebuild();
         });
@@ -13232,12 +13374,12 @@ async function main(argv = process.argv.slice(2)) {
         });
       } else if (subAction === "validate") {
         const treeDir = outputDir;
-        if (!fs10.existsSync(treeDir)) {
+        if (!fs11.existsSync(treeDir)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
         const indexPath = path12.join(treeDir, "INDEX.md");
-        if (!fs10.existsSync(indexPath)) {
+        if (!fs11.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
         }
@@ -13407,10 +13549,10 @@ Other:
         let wearablesService;
         try {
           const configPath = resolveConfigPath();
-          const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-          const remnicCfg = resolveRemnicConfigRecord3(raw);
-          const config = parseConfig3(remnicCfg);
-          wearablesOrchestrator = new Orchestrator2(config);
+          const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+          const remnicCfg = resolveRemnicConfigRecord4(raw);
+          const config = parseConfig4(remnicCfg);
+          wearablesOrchestrator = new Orchestrator3(config);
           await wearablesOrchestrator.initialize();
           await wearablesOrchestrator.deferredReady;
           wearablesService = wearablesOrchestrator.getWearablesService();
@@ -13425,6 +13567,9 @@ Other:
           stdout: process.stdout,
           stderr: process.stderr
         });
+        if (wearablesArgs[0] === "sync" && code === 0 && wearablesOrchestrator.config.meetings.enabled) {
+          await (await wearablesOrchestrator.getMeetingsService()).flushBuilds();
+        }
         if (code !== 0) process.exitCode = code;
       } catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
@@ -13442,6 +13587,10 @@ Other:
       }
       break;
     }
+    case "meetings": {
+      await runMeetingsBinaryCommand(rest);
+      break;
+    }
     case "import": {
       if (rest.includes("--help") || rest.includes("-h") || rest.length === 0) {
         console.log(IMPORT_USAGE);
@@ -13451,10 +13600,10 @@ Other:
       const targetFactory = async () => {
         if (!orchestratorSingleton) {
           const configPath = resolveConfigPath();
-          const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-          const remnicCfg = resolveRemnicConfigRecord3(raw);
-          const config = parseConfig3(remnicCfg);
-          orchestratorSingleton = new Orchestrator2(config);
+          const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+          const remnicCfg = resolveRemnicConfigRecord4(raw);
+          const config = parseConfig4(remnicCfg);
+          orchestratorSingleton = new Orchestrator3(config);
           await orchestratorSingleton.initialize();
           await orchestratorSingleton.deferredReady;
         }
@@ -13482,6 +13631,14 @@ Other:
       if (exitCode !== 0) process.exit(exitCode);
       break;
     }
+    case "capture": {
+      const exitCode = await cmdCapture(rest, {
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line)
+      });
+      if (exitCode !== 0) process.exit(exitCode);
+      break;
+    }
     case "capsule": {
       const subAction = rest[0] ?? "help";
       const capsuleArgs = rest.slice(1);
@@ -13638,6 +13795,10 @@ Usage:
     store day transcripts, trust-gated memory creation, speaker labels,
     and per-user corrections. Run "remnic wearables help" for details.
     Connectors install \xE0 la carte: npm install @remnic/connector-limitless
+  remnic meetings <list|show|build>
+    Retrospective meetings: list stored records, show one by id, or build
+    (detect + fuse + store) a day's meetings from ingested audio + screen
+    activity. Run "remnic meetings help" for details.
 
   remnic doctor                Run diagnostics
   remnic config                Show current config