@remnic/cli 9.49.0 → 9.50.0

package/dist/index.js

@@ -19,8 +19,8 @@ async function persistEnrichmentCandidate(storage, entityName, candidate) {
 
 // src/index.ts
 import fs13 from "fs";
-import os from "os";
-import path15 from "path";
+import os2 from "os";
+import path16 from "path";
 import { createHash as createHash4 } from "crypto";
 import * as childProcess2 from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -1213,13 +1213,13 @@ async function computeConvergePlan(options = {}) {
         files,
         parseMemory: parseFrontmatter,
         readFile: async (file) => {
-          const readFile2 = io.readFile;
-          if (!readFile2) {
+          const readFile3 = io.readFile;
+          if (!readFile3) {
             manifestReadFailed = true;
             throw new Error("offline storage cannot read reconciliation manifest files");
           }
           try {
-            return await readFile2({
+            return await readFile3({
               root: rootInfo.rootDir,
               path: file.path,
               filePath: path2.join(rootInfo.rootDir, file.path)
@@ -1589,7 +1589,7 @@ async function executeConvergeApply(options = {}) {
             if (current.sha256 !== entry.localSha256) {
               throw new Error(`local file changed during push: ${localPath}`);
             }
-            const stat = await fs4.promises.stat(filePath);
+            const stat2 = await fs4.promises.stat(filePath);
             let chunks;
             let chunkOffset = 0;
             const resetChunks = async () => {
@@ -1608,7 +1608,7 @@ async function executeConvergeApply(options = {}) {
             source = {
               sha256: entry.localSha256,
               bytes: current.bytes,
-              mtimeMs: stat.mtimeMs,
+              mtimeMs: stat2.mtimeMs,
               ...expectedPeerSha256 ? { baseSha256: expectedPeerSha256 } : {},
               readChunk: async (offset, length) => {
                 if (!chunks || offset < chunkOffset) await resetChunks();
@@ -2309,21 +2309,21 @@ function newestMtime(roots) {
     if (!existsSync2(entryPath)) {
       return;
     }
-    const stat = lstatSync(entryPath);
-    if (stat.isSymbolicLink()) {
+    const stat2 = lstatSync(entryPath);
+    if (stat2.isSymbolicLink()) {
       return;
     }
-    if (stat.isDirectory()) {
+    if (stat2.isDirectory()) {
       for (const child of readdirSync(entryPath)) {
         visit(path3.join(entryPath, child));
       }
       return;
     }
-    if (!stat.isFile()) {
+    if (!stat2.isFile()) {
       return;
     }
-    if (!newest || stat.mtimeMs > newest.mtimeMs) {
-      newest = { path: entryPath, mtimeMs: stat.mtimeMs };
+    if (!newest || stat2.mtimeMs > newest.mtimeMs) {
+      newest = { path: entryPath, mtimeMs: stat2.mtimeMs };
     }
   };
   for (const root of roots) {
@@ -2524,8 +2524,8 @@ function findCommandOnPath(command, pathEnv = process.env.PATH ?? "") {
     for (const name of commandNames(command)) {
       const candidate = path5.join(dir, name);
       try {
-        const stat = fs7.statSync(candidate);
-        if (!stat.isFile()) continue;
+        const stat2 = fs7.statSync(candidate);
+        if (!stat2.isFile()) continue;
         if (process.platform !== "win32") fs7.accessSync(candidate, fs7.constants.X_OK);
         const runnable = resolveRunnableNodeScript(candidate);
         if (runnable) return runnable;
@@ -5660,8 +5660,630 @@ function printBenchComparisonSummary(comparison, baseline, candidate) {
   }
 }
 
-// src/bench-research-commands.ts
+// src/bench-coding-commands.ts
+import { lstat as lstat2, readFile as readFile2, realpath, stat } from "fs/promises";
+import os from "os";
 import path14 from "path";
+var UINT32_MAX = 4294967295;
+var FROZEN_GENERATOR_SEED = 81;
+var FROZEN_TASK_COUNT = 30;
+var FROZEN_SEED_COUNT = 5;
+var FROZEN_STATISTICS_DRAWS = 1e4;
+var FROZEN_MAX_STEPS = 12;
+var FROZEN_MAX_TOOL_CALLS = 8;
+var FROZEN_MAX_OUTPUT_CHARS = 16384;
+var MAX_OUTPUT_BYTES = 16384;
+var DEFAULT_REPEATED_FAILURE_OUTPUT_DIR = path14.join(
+  resolveHomeDir(),
+  ".remnic",
+  "bench",
+  "results",
+  "h6-repeated-failure"
+);
+var BENCH_CODING_USAGE = `Usage: remnic bench coding repo-gen [--count 30] [--seed N] [--out DIR]
+       remnic bench coding repo-gen verify-all [DIR]
+       remnic bench coding repeated-failure --seeds N --profile FILE [--profile FILE ...] [options]
+       remnic bench coding repeated-failure stats --run DIR
+       remnic bench coding repeated-failure report --run DIR
+       remnic bench coding repeated-failure trap-audit --profile FILE [--profile FILE ...] [options]
+
+Commands:
+  repo-gen                  Generate the frozen H6 synthetic repo fixture dataset
+  repo-gen verify-all [DIR] Verify every H6 fixture in DIR, or the committed fixtures
+  repeated-failure          Run or resume the controlled repeated-failure suite
+  repeated-failure stats    Replay statistics offline from a completed run
+  repeated-failure report   Generate paper tables and figures from a completed run
+  repeated-failure trap-audit Run seeded trap effectiveness audit for model profiles
+
+Repo generation options:
+  --count 30                Contract assertion; the published H6 v1 suite has exactly 30 tasks
+  --seed 81                 Contract assertion; the published H6 v1 inventory uses seed 81
+  --out DIR                 Output directory (default: ./h6-failure-gate)
+
+Repeated-failure options:
+  --phase <pilot|main>      Run phase (default: pilot); main also requires --pilot-run
+  --pilot-run DIR           Directory of completed pilot run (required when --phase is main)
+  --seeds 5                 Five deterministic seeds (required)
+  --profile FILE            One or two immutable model profile files are required
+  --out DIR                 New run output directory (default: ~/.remnic/bench/results/h6-repeated-failure)
+  --run DIR                 Existing run directory to resume
+  --fixture DIR             Generated H6 fixture directory
+  --max-steps 12            Frozen episode step cap
+  --max-output-chars 16384  Frozen serialized model output cap
+  --max-duration-ms 120000  Episode wall-clock cap (trap-audit only; raise for large local models)
+  --request-timeout-ms 60000 Per-request timeout (trap-audit only; raise for large local models)
+  --draws 10000             Contract assertion for confirmatory and pilot statistics
+  --statistics-seed N       Unsigned 32-bit statistics seed
+  --help, -h                Show this help
+
+Profile JSON v2:
+  {"schemaVersion":2,"id":"...","provider":"openai-responses","model":"...",
+   "instructions":{"system":"...","developer":"..."},
+   "tokenizer":{"identity":"...","implementation":"nfkc-whitespace-v1"},
+   "temperature":0,"maxOutputTokens":N}
+  Optional endpoint, reasoningEffort, think, and strict nonstandard endpoint seedCapability
+  fields participate in the canonical profile hash. Credentials never enter profile files or hashes.
+
+A live run never chooses a model implicitly. The bench package derives the immutable
+profile ID and lowercase SHA-256 profile hash. Stats replay and report generation accept
+only --run and do not load a model or host.`;
+var DEFAULT_DEPENDENCIES = {
+  loadBenchModule: async () => await loadBenchModule()
+};
+function parseBoundedInteger(value, flag, minimum, maximum) {
+  if (value === void 0 || value.length === 0 || value.startsWith("-")) {
+    throw new Error(`missing value for ${flag}`);
+  }
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    throw new Error(`${flag} must be an integer between ${minimum} and ${maximum}`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum) {
+    throw new Error(`${flag} must be an integer between ${minimum} and ${maximum}`);
+  }
+  return parsed;
+}
+function readSingleValue(args, index, flag, seen) {
+  if (seen.has(flag)) throw new Error(`${flag} may be provided only once`);
+  seen.add(flag);
+  const value = args[index + 1];
+  if (value === void 0 || value.trim().length === 0 || value.startsWith("-")) {
+    throw new Error(`missing value for ${flag}`);
+  }
+  return { value, nextIndex: index + 1 };
+}
+function parseRepoGenerate(args) {
+  let seed = 81;
+  let outputDir = "./h6-failure-gate";
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < args.length; index += 1) {
+    const flag = args[index];
+    if (flag === void 0) break;
+    if (flag === "--help" || flag === "-h") return { kind: "help" };
+    if (flag !== "--count" && flag !== "--seed" && flag !== "--out") {
+      throw new Error(flag.startsWith("-") ? `unknown option ${flag}` : `ambiguous repo-gen subcommand ${flag}`);
+    }
+    const read = readSingleValue(args, index, flag, seen);
+    index = read.nextIndex;
+    if (flag === "--count") {
+      const count = parseBoundedInteger(read.value, flag, 0, UINT32_MAX);
+      if (count !== FROZEN_TASK_COUNT) {
+        throw new Error("--count must be exactly 30 for the published H6 v1 suite");
+      }
+    } else if (flag === "--seed") {
+      const parsedSeed = parseBoundedInteger(read.value, flag, 0, UINT32_MAX);
+      if (parsedSeed !== FROZEN_GENERATOR_SEED) {
+        throw new Error("--seed must be exactly 81 for the published H6 v1 inventory");
+      }
+      seed = parsedSeed;
+    } else {
+      outputDir = read.value;
+    }
+  }
+  return { kind: "repo-generate", count: 30, seed, outputDir };
+}
+function parseRepoVerify(args) {
+  if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) return { kind: "help" };
+  const unknownFlag = args.find((arg) => arg.startsWith("-"));
+  if (unknownFlag) throw new Error(`unknown option ${unknownFlag}`);
+  if (args.length > 1) throw new Error("repo-gen verify-all accepts at most one directory");
+  const directory = args[0];
+  return directory === void 0 ? { kind: "repo-verify" } : { kind: "repo-verify", directory };
+}
+function parseRepeatedRunArtifact(args, kind, commandName) {
+  if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) return { kind: "help" };
+  if (args.length !== 2 || args[0] !== "--run") {
+    const unknown = args.find((arg) => arg.startsWith("-") && arg !== "--run");
+    if (unknown) throw new Error(`unknown option ${unknown}`);
+    throw new Error(`repeated-failure ${commandName} requires exactly --run DIR`);
+  }
+  const runDir = args[1];
+  if (runDir === void 0 || runDir.trim().length === 0 || runDir.startsWith("-")) {
+    throw new Error("missing value for --run");
+  }
+  return { kind, runDir };
+}
+function parseRepeatedRun(args) {
+  let phase = "pilot";
+  let seedCount;
+  const profilePaths = [];
+  let outputDir = DEFAULT_REPEATED_FAILURE_OUTPUT_DIR;
+  let fixtureDir;
+  let resumeRunDir;
+  let pilotRunDir;
+  let maxSteps;
+  let maxToolCalls;
+  let maxOutputChars;
+  let maxDurationMs;
+  let requestTimeoutMs;
+  let statisticsDraws;
+  let statisticsSeed;
+  const seen = /* @__PURE__ */ new Set();
+  const allowed = /* @__PURE__ */ new Set([
+    "--phase",
+    "--pilot-run",
+    "--pilot-run-dir",
+    "--seeds",
+    "--profile",
+    "--out",
+    "--run",
+    "--fixture",
+    "--max-steps",
+    "--max-tool-calls",
+    "--max-output-chars",
+    "--max-duration-ms",
+    "--request-timeout-ms",
+    "--draws",
+    "--statistics-seed"
+  ]);
+  for (let index = 0; index < args.length; index += 1) {
+    const flag = args[index];
+    if (flag === void 0) break;
+    if (flag === "--help" || flag === "-h") return { kind: "help" };
+    if (!allowed.has(flag)) {
+      throw new Error(
+        flag.startsWith("-") ? `unknown option ${flag}` : `ambiguous repeated-failure subcommand ${flag}`
+      );
+    }
+    if (flag === "--profile") {
+      const value = args[index + 1];
+      if (value === void 0 || value.trim().length === 0 || value.startsWith("-")) {
+        throw new Error("missing value for --profile");
+      }
+      profilePaths.push(value);
+      index += 1;
+      continue;
+    }
+    const read = readSingleValue(args, index, flag, seen);
+    index = read.nextIndex;
+    if (flag === "--phase") {
+      if (read.value !== "pilot" && read.value !== "main") {
+        throw new Error("--phase must be pilot or main");
+      }
+      phase = read.value;
+    } else if (flag === "--seeds") {
+      seedCount = parseBoundedInteger(read.value, flag, FROZEN_SEED_COUNT, FROZEN_SEED_COUNT);
+    } else if (flag === "--out") outputDir = read.value;
+    else if (flag === "--run") resumeRunDir = read.value;
+    else if (flag === "--pilot-run" || flag === "--pilot-run-dir") pilotRunDir = read.value;
+    else if (flag === "--fixture") fixtureDir = read.value;
+    else if (flag === "--max-steps") {
+      maxSteps = parseBoundedInteger(read.value, flag, FROZEN_MAX_STEPS, FROZEN_MAX_STEPS);
+    } else if (flag === "--max-tool-calls") {
+      maxToolCalls = parseBoundedInteger(
+        read.value,
+        flag,
+        FROZEN_MAX_TOOL_CALLS,
+        FROZEN_MAX_TOOL_CALLS
+      );
+    } else if (flag === "--max-output-chars") {
+      maxOutputChars = parseBoundedInteger(
+        read.value,
+        flag,
+        FROZEN_MAX_OUTPUT_CHARS,
+        FROZEN_MAX_OUTPUT_CHARS
+      );
+    } else if (flag === "--max-duration-ms") {
+      maxDurationMs = parseBoundedInteger(read.value, flag, 1e3, 36e5);
+    } else if (flag === "--request-timeout-ms") {
+      requestTimeoutMs = parseBoundedInteger(read.value, flag, 1e3, 36e5);
+    } else if (flag === "--draws") {
+      statisticsDraws = parseBoundedInteger(
+        read.value,
+        flag,
+        FROZEN_STATISTICS_DRAWS,
+        FROZEN_STATISTICS_DRAWS
+      );
+    } else statisticsSeed = parseBoundedInteger(read.value, flag, 0, UINT32_MAX);
+  }
+  if (seedCount === void 0) throw new Error("repeated-failure requires --seeds N");
+  if (profilePaths.length < 1 || profilePaths.length > 2) {
+    throw new Error("repeated-failure runs require one or two --profile files");
+  }
+  if (phase === "main" && pilotRunDir === void 0 && resumeRunDir === void 0) {
+    throw new Error("--phase main requires --pilot-run DIR");
+  }
+  if (phase === "pilot" && pilotRunDir !== void 0) {
+    throw new Error("--pilot-run is only valid when --phase is main");
+  }
+  if (resumeRunDir !== void 0 && seen.has("--out")) throw new Error("--run and --out are mutually exclusive");
+  return {
+    kind: "repeated-run",
+    phase,
+    seedCount,
+    profilePaths,
+    outputDir,
+    ...fixtureDir === void 0 ? {} : { fixtureDir },
+    ...resumeRunDir === void 0 ? {} : { resumeRunDir },
+    ...pilotRunDir === void 0 ? {} : { pilotRunDir },
+    ...maxSteps === void 0 ? {} : { maxSteps },
+    ...maxToolCalls === void 0 ? {} : { maxToolCalls },
+    ...maxOutputChars === void 0 ? {} : { maxOutputChars },
+    ...maxDurationMs === void 0 ? {} : { maxDurationMs },
+    ...requestTimeoutMs === void 0 ? {} : { requestTimeoutMs },
+    ...statisticsDraws === void 0 ? {} : { statisticsDraws },
+    ...statisticsSeed === void 0 ? {} : { statisticsSeed }
+  };
+}
+function parseTrapAudit(args) {
+  const profilePaths = [];
+  let outputDir = "./h6-trap-audit";
+  let fixtureDir;
+  let maxSteps;
+  let maxToolCalls;
+  let maxOutputChars;
+  let maxDurationMs;
+  let requestTimeoutMs;
+  const seen = /* @__PURE__ */ new Set();
+  const allowed = /* @__PURE__ */ new Set([
+    "--profile",
+    "--out",
+    "--fixture",
+    "--max-steps",
+    "--max-tool-calls",
+    "--max-output-chars",
+    "--max-duration-ms",
+    "--request-timeout-ms"
+  ]);
+  for (let index = 0; index < args.length; index += 1) {
+    const flag = args[index];
+    if (flag === void 0) break;
+    if (flag === "--help" || flag === "-h") return { kind: "help" };
+    if (!allowed.has(flag)) {
+      throw new Error(
+        flag.startsWith("-") ? `unknown option ${flag}` : `ambiguous trap-audit subcommand ${flag}`
+      );
+    }
+    if (flag === "--profile") {
+      const value = args[index + 1];
+      if (value === void 0 || value.trim().length === 0 || value.startsWith("-")) {
+        throw new Error("missing value for --profile");
+      }
+      profilePaths.push(value);
+      index += 1;
+      continue;
+    }
+    const read = readSingleValue(args, index, flag, seen);
+    index = read.nextIndex;
+    if (flag === "--out") outputDir = read.value;
+    else if (flag === "--fixture") fixtureDir = read.value;
+    else if (flag === "--max-steps") maxSteps = parseBoundedInteger(read.value, flag, 1, 100);
+    else if (flag === "--max-tool-calls") maxToolCalls = parseBoundedInteger(read.value, flag, 1, 100);
+    else if (flag === "--max-output-chars") maxOutputChars = parseBoundedInteger(read.value, flag, 256, 65536);
+    else if (flag === "--max-duration-ms") maxDurationMs = parseBoundedInteger(read.value, flag, 1e3, 36e5);
+    else if (flag === "--request-timeout-ms") requestTimeoutMs = parseBoundedInteger(read.value, flag, 1e3, 36e5);
+  }
+  if (profilePaths.length === 0) throw new Error("trap-audit requires at least one --profile FILE");
+  return {
+    kind: "trap-audit",
+    profilePaths,
+    outputDir,
+    ...fixtureDir === void 0 ? {} : { fixtureDir },
+    ...maxSteps === void 0 ? {} : { maxSteps },
+    ...maxToolCalls === void 0 ? {} : { maxToolCalls },
+    ...maxOutputChars === void 0 ? {} : { maxOutputChars },
+    ...maxDurationMs === void 0 ? {} : { maxDurationMs },
+    ...requestTimeoutMs === void 0 ? {} : { requestTimeoutMs }
+  };
+}
+function parseBenchCodingArgs(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") return { kind: "help" };
+  if (args[0] === "repo-gen") {
+    return args[1] === "verify-all" ? parseRepoVerify(args.slice(2)) : parseRepoGenerate(args.slice(1));
+  }
+  if (args[0] === "repeated-failure") {
+    if (args[1] === "stats") {
+      return parseRepeatedRunArtifact(args.slice(2), "repeated-stats", "stats");
+    }
+    if (args[1] === "report") {
+      return parseRepeatedRunArtifact(args.slice(2), "repeated-report", "report");
+    }
+    if (args[1] === "trap-audit" || args[1] === "audit") return parseTrapAudit(args.slice(2));
+    return parseRepeatedRun(args.slice(1));
+  }
+  if (args[0] === "trap-audit") {
+    return parseTrapAudit(args.slice(1));
+  }
+  throw new Error(`unknown bench coding subcommand ${args[0]}`);
+}
+function normalizeCommandPaths(command) {
+  const resolve2 = (value) => path14.resolve(expandTilde(value));
+  if (command.kind === "repo-generate") {
+    return { ...command, outputDir: resolve2(command.outputDir) };
+  }
+  if (command.kind === "repo-verify") {
+    return command.directory === void 0 ? command : { ...command, directory: resolve2(command.directory) };
+  }
+  if (command.kind === "repeated-stats" || command.kind === "repeated-report") {
+    return { ...command, runDir: resolve2(command.runDir) };
+  }
+  if (command.kind === "repeated-run") {
+    return {
+      ...command,
+      profilePaths: command.profilePaths.map(resolve2),
+      outputDir: resolve2(command.resumeRunDir ?? command.outputDir),
+      ...command.fixtureDir === void 0 ? {} : { fixtureDir: resolve2(command.fixtureDir) },
+      ...command.resumeRunDir === void 0 ? {} : { resumeRunDir: resolve2(command.resumeRunDir) },
+      ...command.pilotRunDir === void 0 ? {} : { pilotRunDir: resolve2(command.pilotRunDir) }
+    };
+  }
+  if (command.kind === "trap-audit") {
+    return {
+      ...command,
+      profilePaths: command.profilePaths.map(resolve2),
+      outputDir: resolve2(command.outputDir),
+      ...command.fixtureDir === void 0 ? {} : { fixtureDir: resolve2(command.fixtureDir) }
+    };
+  }
+  return command;
+}
+async function canonicalProspectivePath(value) {
+  let candidate = path14.resolve(value);
+  const missingSegments = [];
+  while (true) {
+    try {
+      return path14.join(await realpath(candidate), ...missingSegments.reverse());
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const parent = path14.dirname(candidate);
+      if (parent === candidate) throw error;
+      missingSegments.push(path14.basename(candidate));
+      candidate = parent;
+    }
+  }
+}
+function isSameOrDescendant(candidate, root) {
+  const relative = path14.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative);
+}
+async function pathExists(value) {
+  try {
+    await lstat2(value);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function assertSafeBenchmarkOutput(outputDir) {
+  const refusal = "refusing benchmark output inside a Remnic memory store";
+  try {
+    const canonicalOutput = await canonicalProspectivePath(outputDir);
+    for (const variable of ["REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR"]) {
+      const configured = process.env[variable]?.trim();
+      if (!configured) continue;
+      const memoryRoot = await canonicalProspectivePath(
+        path14.resolve(expandTilde(configured))
+      );
+      if (isSameOrDescendant(canonicalOutput, memoryRoot)) {
+        throw new Error(refusal);
+      }
+    }
+    let candidate = canonicalOutput;
+    while (true) {
+      const hasProfile = await pathExists(path14.join(candidate, "profile.md"));
+      const hasMemoryData = await pathExists(path14.join(candidate, "facts")) || await pathExists(path14.join(candidate, "entities")) || await pathExists(path14.join(candidate, "state"));
+      if (hasProfile && hasMemoryData) throw new Error(refusal);
+      const parent = path14.dirname(candidate);
+      if (parent === candidate) break;
+      candidate = parent;
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message === refusal) throw error;
+    throw new Error(refusal);
+  }
+}
+async function assertH6StatsRunDirectory(runDir, commandName = "stats") {
+  try {
+    const parsed = JSON.parse(
+      await readFile2(path14.join(runDir, "run.json"), "utf8")
+    );
+    if (parsed.schemaVersion !== 1 || typeof parsed.runId !== "string" || parsed.runId.length === 0 || typeof parsed.suiteVersion !== "string" || !parsed.suiteVersion.startsWith("h6-failure-gate-v1-")) {
+      throw new Error("invalid H6 metadata");
+    }
+  } catch {
+    throw new Error(`${commandName} requires existing H6 run metadata`);
+  }
+}
+function sanitizeOutput(output) {
+  const home = os.homedir();
+  const safe = home.length > 1 ? output.replaceAll(home, "~") : output;
+  if (Buffer.byteLength(safe, "utf8") <= MAX_OUTPUT_BYTES) return safe.trimEnd();
+  const bounded = Buffer.from(safe, "utf8").subarray(0, MAX_OUTPUT_BYTES - 32).toString("utf8");
+  return `${bounded}
+[output truncated]`;
+}
+async function requireDirectory(directory, label) {
+  const details = await stat(directory).catch(() => void 0);
+  if (!details?.isDirectory()) throw new Error(`${label} must be a directory that exists`);
+}
+async function rejectExistingNonDirectory(directory, label) {
+  const details = await stat(directory).catch(() => void 0);
+  if (details !== void 0 && !details.isDirectory()) throw new Error(`${label} must be a directory`);
+}
+function requireFunction(bench, name) {
+  const value = bench[name];
+  if (typeof value !== "function") {
+    throw new Error(`Installed @remnic/bench does not export ${name}; install a compatible version`);
+  }
+  return value;
+}
+function formatValidationSummary(report) {
+  const { metrics } = report;
+  return `H6 repo fixtures valid: ${metrics.totalTasks} tasks, ${metrics.totalVariants} variants (dev=${metrics.devTaskCount}, pilot=${metrics.pilotTaskCount}, main=${metrics.mainTaskCount}).`;
+}
+async function runRepoGeneration(command, bench) {
+  const generate = requireFunction(bench, "generateH6BenchmarkDataset");
+  const validate = requireFunction(bench, "validateH6Dataset");
+  const writeBundle = requireFunction(bench, "writeH6FixtureBundle");
+  const dataset = await generate(command.seed);
+  const report = await validate(dataset);
+  if (!report.valid) {
+    return {
+      exitCode: 1,
+      output: `Generated H6 repo fixtures are invalid: ${report.issues.length} issue(s).`
+    };
+  }
+  await writeBundle(command.outputDir, dataset);
+  return {
+    exitCode: 0,
+    output: `Generated H6 repo fixtures: ${report.metrics.totalTasks} tasks, ${report.metrics.totalVariants} variants, seed ${command.seed}.`
+  };
+}
+async function runRepoVerification(command, bench) {
+  let dataset;
+  if (command.directory === void 0) {
+    dataset = await requireFunction(bench, "loadCommittedH6BenchmarkDataset")();
+  } else {
+    const serialized = await readFile2(path14.join(command.directory, "dataset.json"), "utf8").catch(
+      () => void 0
+    );
+    if (serialized === void 0) {
+      return {
+        exitCode: 1,
+        output: "H6 repo fixtures invalid: dataset.json is missing or unreadable."
+      };
+    }
+    try {
+      dataset = JSON.parse(serialized);
+    } catch {
+      return { exitCode: 1, output: "H6 repo fixtures invalid: dataset.json is not valid JSON." };
+    }
+  }
+  const report = command.directory === void 0 ? await requireFunction(bench, "validateH6Dataset")(dataset) : await requireFunction(bench, "validateH6FixtureBundle")(command.directory);
+  if (!report.valid) {
+    const codes = [...new Set(report.issues.map((issue) => issue.code))].sort().slice(0, 20);
+    return {
+      exitCode: 1,
+      output: `H6 repo fixtures invalid: ${report.issues.length} issue(s) [${codes.join(", ")}].`
+    };
+  }
+  return { exitCode: 0, output: formatValidationSummary(report) };
+}
+async function executeCommand(command, dependencies) {
+  if (command.kind === "help") return { exitCode: 0, output: BENCH_CODING_USAGE };
+  if (command.kind === "repo-generate") {
+    await assertSafeBenchmarkOutput(command.outputDir);
+    await rejectExistingNonDirectory(command.outputDir, "--out");
+  } else if (command.kind === "repo-verify" && command.directory !== void 0) {
+    await requireDirectory(command.directory, "verify-all input");
+  } else if (command.kind === "repeated-stats" || command.kind === "repeated-report") {
+    await assertSafeBenchmarkOutput(command.runDir);
+    await requireDirectory(command.runDir, "--run");
+    await assertH6StatsRunDirectory(
+      command.runDir,
+      command.kind === "repeated-stats" ? "stats" : "report"
+    );
+  } else if (command.kind === "repeated-run" || command.kind === "trap-audit") {
+    await assertSafeBenchmarkOutput(command.outputDir);
+    if (command.kind === "repeated-run" && command.resumeRunDir !== void 0) {
+      await requireDirectory(command.resumeRunDir, "--run");
+    } else {
+      await rejectExistingNonDirectory(command.outputDir, "--out");
+    }
+    if (command.fixtureDir !== void 0) {
+      await requireDirectory(command.fixtureDir, "--fixture");
+    }
+    if (command.kind === "repeated-run" && command.pilotRunDir !== void 0) {
+      await requireDirectory(command.pilotRunDir, "--pilot-run");
+    }
+    for (const profilePath of command.profilePaths) {
+      const details = await stat(profilePath).catch(() => void 0);
+      if (!details?.isFile()) {
+        throw new Error("each --profile value must be an existing file");
+      }
+    }
+  }
+  const bench = await dependencies.loadBenchModule();
+  if (command.kind === "repo-generate") return runRepoGeneration(command, bench);
+  if (command.kind === "repo-verify") return runRepoVerification(command, bench);
+  if (command.kind === "repeated-stats") {
+    return requireFunction(bench, "replayRepeatedFailureStatistics")({ runDir: command.runDir });
+  }
+  if (command.kind === "repeated-report") {
+    return requireFunction(bench, "runRepeatedFailurePaperReportCliCommand")({
+      runDir: command.runDir
+    });
+  }
+  if (command.kind === "trap-audit") {
+    return requireFunction(bench, "runTrapAuditCliCommand")({
+      profilePaths: command.profilePaths,
+      outputDir: command.outputDir,
+      ...command.fixtureDir === void 0 ? {} : { fixtureDir: command.fixtureDir },
+      ...command.maxSteps === void 0 ? {} : { maxSteps: command.maxSteps },
+      ...command.maxToolCalls === void 0 ? {} : { maxToolCalls: command.maxToolCalls },
+      ...command.maxOutputChars === void 0 ? {} : { maxOutputChars: command.maxOutputChars },
+      ...command.maxDurationMs === void 0 ? {} : { maxDurationMs: command.maxDurationMs },
+      ...command.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: command.requestTimeoutMs }
+    });
+  }
+  if (command.kind === "repeated-run") {
+    return requireFunction(bench, "runRepeatedFailureCliCommand")({
+      phase: command.phase,
+      seedCount: command.seedCount,
+      profilePaths: command.profilePaths,
+      outputDir: command.outputDir,
+      ...command.fixtureDir === void 0 ? {} : { fixtureDir: command.fixtureDir },
+      ...command.resumeRunDir === void 0 ? {} : { resumeRunDir: command.resumeRunDir },
+      ...command.pilotRunDir === void 0 ? {} : { pilotRunDir: command.pilotRunDir },
+      ...command.maxSteps === void 0 ? {} : { maxSteps: command.maxSteps },
+      ...command.maxToolCalls === void 0 ? {} : { maxToolCalls: command.maxToolCalls },
+      ...command.maxOutputChars === void 0 ? {} : { maxOutputChars: command.maxOutputChars },
+      ...command.maxDurationMs === void 0 ? {} : { maxDurationMs: command.maxDurationMs },
+      ...command.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: command.requestTimeoutMs },
+      ...command.statisticsDraws === void 0 ? {} : { statisticsDraws: command.statisticsDraws },
+      ...command.statisticsSeed === void 0 ? {} : { statisticsSeed: command.statisticsSeed }
+    });
+  }
+  throw new Error("unhandled command kind");
+}
+function validateCommandResult(result) {
+  if (!Number.isInteger(result.exitCode) || result.exitCode < 0 || result.exitCode > 255 || typeof result.output !== "string") {
+    throw new Error("Installed @remnic/bench returned an invalid coding command result");
+  }
+  return result;
+}
+async function runBenchCodingCommand(args, dependencies = DEFAULT_DEPENDENCIES) {
+  try {
+    const command = normalizeCommandPaths(parseBenchCodingArgs(args));
+    const result = validateCommandResult(await executeCommand(command, dependencies));
+    return { ...result, output: sanitizeOutput(result.output) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 1, output: sanitizeOutput(`${message}
+
+${BENCH_CODING_USAGE}`) };
+  }
+}
+async function cmdBenchCoding(args) {
+  const result = await runBenchCodingCommand(args);
+  if (result.exitCode === 0) console.log(result.output);
+  else console.error(result.output);
+  if (result.exitCode !== 0) process.exitCode = result.exitCode;
+}
+
+// src/bench-research-commands.ts
+import path15 from "path";
 function emit(result) {
   if (result.output) {
     console.log(result.output);
@@ -5679,7 +6301,7 @@ async function runBenchResearchCommand(parsed) {
     emit(
       await runAttributeCliCommand({
         runRef: parsed.runRef,
-        resultsDir: parsed.resultsDir ?? path14.join(resolveHomeDir(), ".remnic", "bench", "results"),
+        resultsDir: parsed.resultsDir ?? path15.join(resolveHomeDir(), ".remnic", "bench", "results"),
         memoryDir: parsed.memoryDir,
         qmdPath: parsed.qmdPath,
         collection: parsed.collection,
@@ -5708,8 +6330,8 @@ async function runBenchResearchCommand(parsed) {
 
 // src/bench-usage.ts
 function getBenchUsageText() {
-  return `Usage: remnic bench <list|run|published|datasets|runs|compare|results|baseline|export|publish|ui|providers|judge-calibrate|attribute|drift-gen> [options] [benchmark...]
-       remnic benchmark <list|run|published|datasets|runs|compare|results|baseline|export|publish|ui|providers|judge-calibrate|check|report|attribute|drift-gen> [options] [benchmark...]
+  return `Usage: remnic bench <list|run|published|datasets|runs|compare|results|baseline|export|publish|ui|providers|judge-calibrate|attribute|drift-gen|coding> [options] [benchmark...]
+       remnic benchmark <list|run|published|datasets|runs|compare|results|baseline|export|publish|ui|providers|judge-calibrate|check|report|attribute|drift-gen|coding> [options] [benchmark...]
 
 Commands:
   list                     List published benchmark packs
@@ -5744,6 +6366,9 @@ Commands:
                            local + frontier judges over a benchmark's cached
                            answers, reports Cohen's kappa, and persists it so
                            subsequent local artifacts carry the kappa + warning.
+  coding                   H6 synthetic coding benchmark commands
+                           Run \`remnic bench coding --help\` for repo generation,
+                           repeated-failure runs, resume, and offline stats replay
   check                    Legacy latency regression gate (compatibility)
   attribute --run <id> [--results-dir <path>] [--memory-dir <path>] [--threshold <value>]
                            [--qmd <path> --collection <name>]
@@ -5895,6 +6520,10 @@ Examples:
   remnic bench attribute --run legacy-run --memory-dir ./memories --qmd /opt/qmd --collection memories
   remnic bench drift-gen generate --users 20 --epochs 10 --out ./corpus
   remnic bench drift-gen validate ./corpus
+  remnic bench coding repo-gen --count 30 --seed 81 --out ./h6-fixtures
+  remnic bench coding repo-gen verify-all ./h6-fixtures
+  remnic bench coding repeated-failure --seeds 5 --profile ./profiles/model-a.json
+  remnic bench coding repeated-failure stats --run ./h6-repeated-failure
   remnic benchmark run --quick longmemeval`;
 }
 
@@ -5941,15 +6570,15 @@ registerPublisher("omp", () => new LazyPluginPiPublisher("omp", (mod) => mod.Omp
 function readCompatEnv(primary, legacy) {
   return process.env[primary] ?? process.env[legacy];
 }
-var PID_DIR = path15.join(resolveHomeDir(), ".remnic");
-var LEGACY_PID_DIR = path15.join(resolveHomeDir(), ".engram");
-var PID_FILE = path15.join(PID_DIR, "server.pid");
-var LEGACY_PID_FILE = path15.join(LEGACY_PID_DIR, "server.pid");
-var LOG_FILE = path15.join(PID_DIR, "server.log");
-var LEGACY_LOG_FILE = path15.join(LEGACY_PID_DIR, "server.log");
-var CLI_MODULE_DIR = path15.dirname(fileURLToPath4(import.meta.url));
-var CLI_REPO_ROOT = path15.resolve(CLI_MODULE_DIR, "../../..");
-var EVAL_RUNNER_PATH = path15.join(CLI_REPO_ROOT, "evals", "run.ts");
+var PID_DIR = path16.join(resolveHomeDir(), ".remnic");
+var LEGACY_PID_DIR = path16.join(resolveHomeDir(), ".engram");
+var PID_FILE = path16.join(PID_DIR, "server.pid");
+var LEGACY_PID_FILE = path16.join(LEGACY_PID_DIR, "server.pid");
+var LOG_FILE = path16.join(PID_DIR, "server.log");
+var LEGACY_LOG_FILE = path16.join(LEGACY_PID_DIR, "server.log");
+var CLI_MODULE_DIR = path16.dirname(fileURLToPath4(import.meta.url));
+var CLI_REPO_ROOT = path16.resolve(CLI_MODULE_DIR, "../../..");
+var EVAL_RUNNER_PATH = path16.join(CLI_REPO_ROOT, "evals", "run.ts");
 var OPENCLAW_GATEWAY_LABEL = "ai.openclaw.gateway";
 var CLI_SUCCESS_EXIT_GRACE_MS = 5e3;
 var CLI_OUTPUT_FLUSH_GRACE_MS = 250;
@@ -6169,8 +6798,8 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
     process.exit(1);
   }
   const tsxCandidates = [
-    path15.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
-    path15.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
+    path16.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
+    path16.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
   ];
   const tsxCmd = tsxCandidates.find((candidate) => fs13.existsSync(candidate)) ?? "tsx";
   const fallbackOutputDir = createFallbackBenchOutputDir(
@@ -6189,7 +6818,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
   return resolveFallbackBenchResultPath(fallbackOutputDir);
 }
 function resolveBenchOutputDir() {
-  return path15.join(resolveHomeDir(), ".remnic", "bench", "results");
+  return path16.join(resolveHomeDir(), ".remnic", "bench", "results");
 }
 var DOWNLOADABLE_BENCHMARK_DATASETS = [
   "ama-bench",
@@ -6234,8 +6863,8 @@ var MEMORY_AGENT_BENCH_SPLIT_FILENAMES = [
 ];
 var MEMORY_AGENT_BENCH_ENTITY_MAPPING_CANDIDATES = [
   "entity2id.json",
-  path15.join("processed_data", "Recsys_Redial", "entity2id.json"),
-  path15.join("Recsys_Redial", "entity2id.json")
+  path16.join("processed_data", "Recsys_Redial", "entity2id.json"),
+  path16.join("Recsys_Redial", "entity2id.json")
 ];
 var DOWNLOADED_DATASET_MARKERS = {
   "ama-bench": { anyOf: ["open_end_qa_set.jsonl"] },
@@ -6310,7 +6939,7 @@ var PERSONAMEM_DATASET_FILE_CANDIDATES = [
   "benchmark/benchmark.csv",
   "benchmark.csv"
 ];
-var PERSONAMEM_COMPLETION_MARKER = path15.join(
+var PERSONAMEM_COMPLETION_MARKER = path16.join(
   "data",
   "chat_history_32k",
   ".download-complete"
@@ -6318,10 +6947,10 @@ var PERSONAMEM_COMPLETION_MARKER = path15.join(
 function resolveRealpathWithinDataset(datasetPath, relativePath) {
   try {
     const datasetRoot = fs13.realpathSync(datasetPath);
-    const candidatePath = path15.resolve(datasetRoot, relativePath);
+    const candidatePath = path16.resolve(datasetRoot, relativePath);
     const candidateRealPath = fs13.realpathSync(candidatePath);
-    const relativeToRoot = path15.relative(datasetRoot, candidateRealPath);
-    if (relativeToRoot.startsWith("..") || path15.isAbsolute(relativeToRoot)) {
+    const relativeToRoot = path16.relative(datasetRoot, candidateRealPath);
+    if (relativeToRoot.startsWith("..") || path16.isAbsolute(relativeToRoot)) {
       return null;
     }
     return candidateRealPath;
@@ -6377,7 +7006,7 @@ function parseCsvRows(raw) {
 }
 function isPersonaMemDatasetComplete(datasetPath) {
   try {
-    const completionMarkerPath = path15.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
+    const completionMarkerPath = path16.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
     if (fs13.statSync(completionMarkerPath).isFile()) {
       return true;
     }
@@ -6385,7 +7014,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
   }
   const datasetFile = PERSONAMEM_DATASET_FILE_CANDIDATES.find((candidate) => {
     try {
-      return fs13.statSync(path15.join(datasetPath, candidate)).isFile();
+      return fs13.statSync(path16.join(datasetPath, candidate)).isFile();
     } catch {
       return false;
     }
@@ -6394,7 +7023,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     return false;
   }
   try {
-    const rows = parseCsvRows(fs13.readFileSync(path15.join(datasetPath, datasetFile), "utf8"));
+    const rows = parseCsvRows(fs13.readFileSync(path16.join(datasetPath, datasetFile), "utf8"));
     if (rows.length < 2) {
       return false;
     }
@@ -6417,14 +7046,14 @@ function isPersonaMemDatasetComplete(datasetPath) {
 }
 function hasDatasetFile(datasetPath, relativePath) {
   try {
-    return fs13.statSync(path15.join(datasetPath, relativePath)).isFile();
+    return fs13.statSync(path16.join(datasetPath, relativePath)).isFile();
   } catch {
     return false;
   }
 }
 function hasMemoryAgentBenchEntityMapping(datasetPath) {
-  const absoluteDatasetPath = path15.resolve(datasetPath);
-  const roots = [absoluteDatasetPath, path15.dirname(absoluteDatasetPath)];
+  const absoluteDatasetPath = path16.resolve(datasetPath);
+  const roots = [absoluteDatasetPath, path16.dirname(absoluteDatasetPath)];
   return hasDatasetFile(absoluteDatasetPath, "entity2id.json") || roots.some(
     (root) => MEMORY_AGENT_BENCH_ENTITY_MAPPING_CANDIDATES.filter((relativePath) => relativePath !== "entity2id.json").some((relativePath) => hasDatasetFile(root, relativePath))
   );
@@ -6435,7 +7064,7 @@ function memoryAgentBenchDatasetHasRecSysSamples(datasetPath) {
     ...MEMORY_AGENT_BENCH_SPLIT_FILENAMES
   ];
   return candidateFilenames.some((filename) => {
-    const filePath = path15.join(datasetPath, filename);
+    const filePath = path16.join(datasetPath, filename);
     try {
       if (!fs13.statSync(filePath).isFile()) {
         return false;
@@ -6474,7 +7103,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.allOf) {
     const hasAllRequiredFiles = marker.allOf.every((name) => {
       try {
-        return fs13.statSync(path15.join(datasetPath, name)).isFile();
+        return fs13.statSync(path16.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -6486,7 +7115,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.anyOf) {
     const hasMarkerFile = marker.anyOf.some((name) => {
       try {
-        return fs13.statSync(path15.join(datasetPath, name)).isFile();
+        return fs13.statSync(path16.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -6514,9 +7143,9 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   return false;
 }
 async function launchBenchUi(resultsDir) {
-  const benchUiDir = path15.join(CLI_REPO_ROOT, "packages", "bench-ui");
+  const benchUiDir = path16.join(CLI_REPO_ROOT, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs13.existsSync(path15.join(benchUiDir, "package.json"))) {
+  if (!fs13.existsSync(path16.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -6543,24 +7172,24 @@ async function launchBenchUi(resultsDir) {
   });
 }
 function resolveRepoDatasetRoot() {
-  const repoCandidate = path15.join(CLI_REPO_ROOT, "evals", "datasets");
+  const repoCandidate = path16.join(CLI_REPO_ROOT, "evals", "datasets");
   if (isRepoCheckout()) {
     return repoCandidate;
   }
-  return path15.join(resolveHomeDir(), ".remnic", "bench", "datasets");
+  return path16.join(resolveHomeDir(), ".remnic", "bench", "datasets");
 }
 function listDownloadableBenchmarks() {
   return [...DOWNLOADABLE_BENCHMARK_DATASETS];
 }
 function resolveDatasetDownloadScriptPath() {
-  const bundled = path15.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
+  const bundled = path16.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
   if (fs13.existsSync(bundled)) {
     return bundled;
   }
-  return path15.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
+  return path16.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
 }
 function isRepoCheckout() {
-  return fs13.existsSync(path15.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs13.existsSync(path15.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+  return fs13.existsSync(path16.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs13.existsSync(path16.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
 }
 function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
   const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
@@ -6611,7 +7240,7 @@ function resolveBenchDatasetDir(benchmarkId, quick, datasetDirOverride) {
   if (quick) {
     return void 0;
   }
-  const datasetDir = path15.join(resolveRepoDatasetRoot(), benchmarkId);
+  const datasetDir = path16.join(resolveRepoDatasetRoot(), benchmarkId);
   if (isDatasetDownloaded(datasetDir, benchmarkId)) {
     return datasetDir;
   }
@@ -6868,12 +7497,12 @@ async function exportBenchPackageResult(parsed) {
     process.exit(1);
   }
   const result = await loadBenchmarkResult(summary.path);
-  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path15.dirname(summary.path), result.meta.id) : void 0;
+  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path16.dirname(summary.path), result.meta.id) : void 0;
   const rendered = renderBenchmarkResultExport(result, parsed.format, {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs13.mkdirSync(path15.dirname(parsed.output), { recursive: true });
+    fs13.mkdirSync(path16.dirname(parsed.output), { recursive: true });
     fs13.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
@@ -6891,7 +7520,7 @@ async function manageBenchDatasets(parsed) {
       process.exit(1);
     }
     const status = supported.map((benchmarkId) => {
-      const datasetPath = path15.join(datasetRoot, benchmarkId);
+      const datasetPath = path16.join(datasetRoot, benchmarkId);
       return {
         benchmark: benchmarkId,
         downloaded: isDatasetDownloaded(datasetPath, benchmarkId),
@@ -6929,7 +7558,7 @@ async function manageBenchDatasets(parsed) {
     runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, parsed.json === true);
     downloaded.push({
       benchmark: benchmarkId,
-      path: path15.join(datasetRoot, benchmarkId)
+      path: path16.join(datasetRoot, benchmarkId)
     });
   }
   if (parsed.json) {
@@ -7068,10 +7697,10 @@ async function calibrateBenchJudges(parsed, rawArgs) {
   }
   const bench = await loadBenchModule();
   const resultsDir = expandTilde(
-    parsed.resultsDir ?? path15.join(resolveHomeDir(), ".remnic", "bench", "results")
+    parsed.resultsDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "results")
   );
   const calibrationDir = expandTilde(
-    parsed.calibrationDir ?? path15.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    parsed.calibrationDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const stored = await bench.listBenchmarkResults(resultsDir);
   const allForBenchmark = stored.filter((entry) => entry.benchmark === benchmarkId);
@@ -7631,7 +8260,7 @@ async function loadPublishedPromotionHelpers() {
   return {
     async promoteArtifactsToPublished(args) {
       const { mkdirSync, readFileSync: readFileSync4, writeFileSync } = await import("fs");
-      const path16 = await import("path");
+      const path17 = await import("path");
       mkdirSync(args.publishedOutDir, { recursive: true });
       if (args.artifactPaths.length === 0) {
         console.warn(
@@ -7648,13 +8277,13 @@ async function loadPublishedPromotionHelpers() {
         const modelSlug = args.model.replace(/[^a-zA-Z0-9_.-]/g, "-");
         const rawProfile = parsedObj.config?.runtimeProfile;
         const profileSlug = typeof rawProfile === "string" && rawProfile.length > 0 ? `-${rawProfile.replace(/[^a-zA-Z0-9_.-]/g, "-")}` : "";
-        const target = path16.join(
+        const target = path17.join(
           args.publishedOutDir,
           `${today}-${args.benchmarkId}-${modelSlug}${profileSlug}-${gitShaShort}.json`
         );
         writeFileSync(target, raw, "utf8");
         console.log(
-          `[bench published] Promoted ${path16.basename(artifactPath)} \u2192 ${target}`
+          `[bench published] Promoted ${path17.basename(artifactPath)} \u2192 ${target}`
         );
       }
       void benchModule;
@@ -7761,7 +8390,7 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
   const previousCodexDiagnosticsDir = process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV];
   const previousCodexDiagnosticsMode = process.env[CODEX_CLI_BENCH_DIAGNOSTICS_MODE_ENV];
   if (!previousCodexDiagnosticsDir) {
-    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path15.join(
+    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path16.join(
       outputDir,
       "codex-cli-diagnostics"
     );
@@ -7909,7 +8538,7 @@ async function preparePersistedJudgeCalibrationAttachment(benchModule, benchmark
     );
   }
   const calibrationDir = expandTilde(
-    calibrationBinding.calibrationDir ?? path15.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    calibrationBinding.calibrationDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const state = await benchModule.loadJudgeCalibrationState?.(benchmarkId, calibrationDir);
   if (!state) {
@@ -8279,19 +8908,19 @@ function loadConvergeCommandConfig() {
   return loadStandaloneConvergeCommandConfig();
 }
 function resolveConfigPath(cliPath) {
-  if (cliPath) return path15.resolve(expandTilde(cliPath));
+  if (cliPath) return path16.resolve(expandTilde(cliPath));
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
-  if (envPath) return path15.resolve(expandTilde(envPath));
+  if (envPath) return path16.resolve(expandTilde(envPath));
   const candidates = [
-    path15.join(process.cwd(), "remnic.config.json"),
-    path15.join(process.cwd(), "engram.config.json"),
-    path15.join(resolveHomeDir(), ".config", "remnic", "config.json"),
-    path15.join(resolveHomeDir(), ".config", "engram", "config.json")
+    path16.join(process.cwd(), "remnic.config.json"),
+    path16.join(process.cwd(), "engram.config.json"),
+    path16.join(resolveHomeDir(), ".config", "remnic", "config.json"),
+    path16.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
     if (fs13.existsSync(candidate)) return candidate;
   }
-  return path15.join(resolveHomeDir(), ".config", "remnic", "config.json");
+  return path16.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
 function resolveExistingBenchRemnicConfigPath(cliPath) {
   const configPath = resolveConfigPath(cliPath);
@@ -8405,7 +9034,7 @@ async function resolvePackageBenchRuntime(benchModule, parsed, runtimeProfile) {
   );
 }
 function normalizeMemoryDirPath(memoryDir) {
-  return path15.resolve(expandTilde(memoryDir));
+  return path16.resolve(expandTilde(memoryDir));
 }
 function resolveMemoryDir() {
   const configMemoryDir = (() => {
@@ -8418,9 +9047,9 @@ function resolveMemoryDir() {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
     const home = resolveHomeDir();
-    const standalonePath = path15.join(home, ".remnic", "memory");
-    const legacyStandalonePath = path15.join(home, ".engram", "memory");
-    const openclawPath = path15.join(home, ".openclaw", "workspace", "memory", "local");
+    const standalonePath = path16.join(home, ".remnic", "memory");
+    const legacyStandalonePath = path16.join(home, ".engram", "memory");
+    const openclawPath = path16.join(home, ".openclaw", "workspace", "memory", "local");
     if (fs13.existsSync(standalonePath)) return standalonePath;
     if (fs13.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
@@ -8471,16 +9100,16 @@ var REMNIC_OPENCLAW_LEGACY_PLUGIN_ID = "openclaw-engram";
 var DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR = [
   process.env.OPENCLAW_CONFIG_PATH,
   process.env.OPENCLAW_ENGRAM_CONFIG_PATH,
-  path15.join(resolveHomeDir(), ".openclaw", "openclaw.json")
+  path16.join(resolveHomeDir(), ".openclaw", "openclaw.json")
 ].filter(Boolean);
 function resolveOpenclawConfigPath(cliPath) {
-  if (cliPath) return path15.resolve(expandTilde(cliPath));
+  if (cliPath) return path16.resolve(expandTilde(cliPath));
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
-  if (envPath) return path15.resolve(expandTilde(envPath));
+  if (envPath) return path16.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
     if (fs13.existsSync(candidate)) return candidate;
   }
-  return path15.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+  return path16.join(resolveHomeDir(), ".openclaw", "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
   if (!fs13.existsSync(configPath)) return {};
@@ -8539,10 +9168,10 @@ function buildRemnicOpenclawHooksPolicy(legacyHooks, existingHooks) {
 function resolveOpenclawInstallMemoryDir(args) {
   const existingMemoryDir = (typeof args.existingNewEntryConfig.memoryDir === "string" ? args.existingNewEntryConfig.memoryDir : void 0) || (args.migrateLegacy && typeof args.legacyConfigToMerge.memoryDir === "string" ? args.legacyConfigToMerge.memoryDir : void 0);
   if (args.requestedMemoryDir) {
-    return path15.resolve(expandTilde(args.requestedMemoryDir));
+    return path16.resolve(expandTilde(args.requestedMemoryDir));
   }
   if (existingMemoryDir) {
-    return path15.resolve(expandTilde(existingMemoryDir));
+    return path16.resolve(expandTilde(existingMemoryDir));
   }
   return args.fallbackMemoryDir;
 }
@@ -8560,18 +9189,18 @@ function resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir) {
     if (!config || typeof config !== "object" || Array.isArray(config)) continue;
     const memoryDir = config.memoryDir;
     if (typeof memoryDir === "string" && memoryDir.trim().length > 0) {
-      return path15.resolve(expandTilde(memoryDir));
+      return path16.resolve(expandTilde(memoryDir));
     }
   }
   return fallbackMemoryDir;
 }
 function resolveOpenclawPluginDir(cliPath) {
-  if (cliPath) return path15.resolve(expandTilde(cliPath));
-  return path15.join(resolveHomeDir(), ".openclaw", "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  if (cliPath) return path16.resolve(expandTilde(cliPath));
+  return path16.join(resolveHomeDir(), ".openclaw", "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
 }
 function resolveOpenclawLegacyPluginDir(cliPath) {
-  if (cliPath) return path15.resolve(expandTilde(cliPath));
-  return path15.join(resolveHomeDir(), ".openclaw", "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
+  if (cliPath) return path16.resolve(expandTilde(cliPath));
+  return path16.join(resolveHomeDir(), ".openclaw", "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
 }
 function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   const yyyy = now.getFullYear().toString();
@@ -8584,14 +9213,14 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
 }
 function backupPathIfPresent(sourcePath, backupPath) {
   if (!fs13.existsSync(sourcePath)) return false;
-  fs13.mkdirSync(path15.dirname(backupPath), { recursive: true });
+  fs13.mkdirSync(path16.dirname(backupPath), { recursive: true });
   fs13.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
 function assertDirectoryPathOrMissing(targetPath, label) {
   if (!fs13.existsSync(targetPath)) return;
-  const stat = fs13.statSync(targetPath);
-  if (!stat.isDirectory()) {
+  const stat2 = fs13.statSync(targetPath);
+  if (!stat2.isDirectory()) {
     throw new Error(`${label} must be a directory when it already exists: ${targetPath}`);
   }
 }
@@ -8615,7 +9244,7 @@ var PublishedOpenclawPluginInstallError = class extends Error {
   }
 };
 function installPublishedOpenclawPlugin(spec, pluginDir) {
-  const tempRoot = fs13.mkdtempSync(path15.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
+  const tempRoot = fs13.mkdtempSync(path16.join(os2.tmpdir(), "remnic-openclaw-upgrade-"));
   const stagedDir = `${pluginDir}.next-${process.pid}-${Date.now()}`;
   const rollbackDir = `${pluginDir}.rollback-${process.pid}-${Date.now()}`;
   let swapRollbackDir;
@@ -8630,12 +9259,12 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
     if (!tarballName) {
       throw new Error(`npm pack ${spec} did not return a tarball name`);
     }
-    const unpackDir = path15.join(tempRoot, "unpacked");
+    const unpackDir = path16.join(tempRoot, "unpacked");
     fs13.mkdirSync(unpackDir, { recursive: true });
-    childProcess2.execFileSync("tar", ["-xzf", path15.join(tempRoot, tarballName), "-C", unpackDir], {
+    childProcess2.execFileSync("tar", ["-xzf", path16.join(tempRoot, tarballName), "-C", unpackDir], {
       stdio: ["ignore", "pipe", "pipe"]
     });
-    const packagedDir = path15.join(unpackDir, "package");
+    const packagedDir = path16.join(unpackDir, "package");
     if (!fs13.existsSync(packagedDir)) {
       throw new Error(`npm pack ${spec} did not contain a package/ directory`);
     }
@@ -8655,7 +9284,7 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
       }
     })();
     swapRollbackDir = swapResult.rollbackDir;
-    const installedPackageJsonPath = path15.join(pluginDir, "package.json");
+    const installedPackageJsonPath = path16.join(pluginDir, "package.json");
     const installedPackage = fs13.existsSync(installedPackageJsonPath) ? JSON.parse(fs13.readFileSync(installedPackageJsonPath, "utf8")) : {};
     return {
       rollbackDir: swapRollbackDir,
@@ -8690,7 +9319,7 @@ function restartOpenclawGateway() {
   });
 }
 function cmdInit() {
-  const configPath = path15.join(process.cwd(), "remnic.config.json");
+  const configPath = path16.join(process.cwd(), "remnic.config.json");
   if (fs13.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
@@ -8698,7 +9327,7 @@ function cmdInit() {
   const template = {
     remnic: {
       openaiApiKey: "${OPENAI_API_KEY}",
-      memoryDir: path15.join(process.cwd(), ".remnic", "memory"),
+      memoryDir: path16.join(process.cwd(), ".remnic", "memory"),
       memoryOsPreset: "balanced"
     },
     server: {
@@ -8835,7 +9464,7 @@ function oauthResolveOperatorToken() {
   }
   return void 0;
 }
-async function oauthFetch(method, path16, token, body) {
+async function oauthFetch(method, path17, token, body) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), 5e3);
   try {
@@ -8854,7 +9483,7 @@ async function oauthFetch(method, path16, token, body) {
     if (body !== void 0) {
       init.body = JSON.stringify(body);
     }
-    const response = await fetch(`${oauthResolveBaseUrl()}${path16}`, init);
+    const response = await fetch(`${oauthResolveBaseUrl()}${path17}`, init);
     if (response.status === 401) {
       throw new Error(
         "operator token rejected by remnic-server (HTTP 401). Update `server.authToken` or `REMNIC_AUTH_TOKEN` to match the running daemon."
@@ -9409,7 +10038,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions list <page-path>");
         process.exit(1);
       }
-      const absPath = path15.resolve(pagePath);
+      const absPath = path16.resolve(pagePath);
       const history = await listVersions(absPath, versioningConfig, memDir);
       if (json) {
         console.log(JSON.stringify(history, null, 2));
@@ -9434,7 +10063,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions show <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path15.resolve(pagePath);
+      const absPath = path16.resolve(pagePath);
       try {
         const content = await getVersion(absPath, versionId, versioningConfig, memDir);
         console.log(content);
@@ -9452,7 +10081,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions diff <page-path> <v1> <v2>");
         process.exit(1);
       }
-      const absPath = path15.resolve(pagePath);
+      const absPath = path16.resolve(pagePath);
       try {
         const diffOutput = await diffVersions(absPath, v1, v2, versioningConfig, memDir);
         console.log(diffOutput);
@@ -9469,7 +10098,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions revert <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path15.resolve(pagePath);
+      const absPath = path16.resolve(pagePath);
       try {
         const version = await revertToVersion(absPath, versionId, versioningConfig, void 0, memDir);
         if (json) {
@@ -9509,7 +10138,7 @@ async function cmdEnrich(rest) {
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
-    const auditDir2 = path15.join(memoryDir2, "enrichment");
+    const auditDir2 = path16.join(memoryDir2, "enrichment");
     const sinceFlag = resolveFlag(rest.slice(1), "--since");
     const entries = await readAuditLog(auditDir2, sinceFlag ?? void 0);
     if (entries.length === 0) {
@@ -9634,7 +10263,7 @@ Registered providers:`);
     return;
   }
   const memoryDir = expandTilde(config.memoryDir);
-  const auditDir = path15.join(memoryDir, "enrichment");
+  const auditDir = path16.join(memoryDir, "enrichment");
   let totalPersisted = 0;
   for (const result of results) {
     for (const candidate of result.acceptedCandidates) {
@@ -9825,7 +10454,7 @@ Root: ${root}`);
       const validNames = new Set(extensions.map((e) => e.name));
       let errors = 0;
       for (const entry of entries) {
-        const entryPath = path15.join(root, entry);
+        const entryPath = path16.join(root, entry);
         try {
           if (!fs13.statSync(entryPath).isDirectory()) continue;
         } catch {
@@ -9941,7 +10570,7 @@ async function cmdBriefing(rest) {
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
       fs13.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
-      const filePath = path15.join(saveDir, filename);
+      const filePath = path16.join(saveDir, filename);
       fs13.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
       console.error(`Saved briefing: ${filePath}`);
     } catch (err) {
@@ -10097,14 +10726,14 @@ async function cmdDoctor() {
       const rawMemoryDir = entryConfig?.memoryDir;
       const configuredMemoryDir = typeof rawMemoryDir === "string" ? rawMemoryDir : void 0;
       if (configuredMemoryDir) {
-        const resolvedMemDir = path15.resolve(expandTilde(configuredMemoryDir));
+        const resolvedMemDir = path16.resolve(expandTilde(configuredMemoryDir));
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
         if (fs13.existsSync(resolvedMemDir)) {
           try {
-            const stat = fs13.statSync(resolvedMemDir);
-            if (stat.isDirectory()) {
+            const stat2 = fs13.statSync(resolvedMemDir);
+            if (stat2.isDirectory()) {
               memDirOk = true;
               memDirDetail = resolvedMemDir;
               memDirRemediation = void 0;
@@ -10297,7 +10926,7 @@ async function cmdMigrate(json, rollback) {
   console.log(`  Rollback: ${result.rollbackCommand}`);
 }
 function cmdOnboard(dirPath, json) {
-  const directory = path15.resolve(dirPath || process.cwd());
+  const directory = path16.resolve(dirPath || process.cwd());
   const result = onboard({ directory });
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -10316,7 +10945,7 @@ Suggested namespace: ${result.plan.suggestedNamespace}`);
 async function cmdCurate(targetPath, json) {
   const memoryDir = resolveMemoryDir();
   const result = await curate({
-    targetPath: path15.resolve(targetPath),
+    targetPath: path16.resolve(targetPath),
     memoryDir,
     source: "curation",
     checkDuplicates: true,
@@ -10445,8 +11074,8 @@ async function cmdSync(action, rest, json) {
   }
 }
 function localOfflineSourceId(memoryDir) {
-  const host = os.hostname() || "unknown-host";
-  const dirHash = createHash4("sha256").update(path15.resolve(memoryDir)).digest("hex").slice(0, 16);
+  const host = os2.hostname() || "unknown-host";
+  const dirHash = createHash4("sha256").update(path16.resolve(memoryDir)).digest("hex").slice(0, 16);
   return `remnic-local:${host}:${dirHash}`;
 }
 function normalizeOfflineRemoteUrl(raw) {
@@ -10844,10 +11473,10 @@ var OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX = 3;
 var OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS = 250;
 var OfflineRemoteFileChangedError = class extends Error {
   path;
-  constructor(path16) {
-    super(`remote file changed while fetching offline content: ${path16}`);
+  constructor(path17) {
+    super(`remote file changed while fetching offline content: ${path17}`);
     this.name = "OfflineRemoteFileChangedError";
-    this.path = path16;
+    this.path = path17;
   }
 };
 function isOfflineRemoteFileChangedError(error) {
@@ -11038,10 +11667,10 @@ function offlineDirectPushFiles(options) {
   }).sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
 }
 function resolveOfflineDirectHydrationPath(memoryDir, relPath) {
-  const base = path15.resolve(memoryDir);
-  const target = path15.resolve(base, relPath);
-  const relative = path15.relative(base, target);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path15.sep}`) || path15.isAbsolute(relative)) {
+  const base = path16.resolve(memoryDir);
+  const target = path16.resolve(base, relPath);
+  const relative = path16.relative(base, target);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative)) {
     throw new Error(`offline sync direct hydration path escapes memory dir: ${relPath}`);
   }
   return target;
@@ -11111,13 +11740,13 @@ async function pushOfflineFileContent(args) {
 }
 async function pushOfflineFileContentFromChunkReader(args) {
   const filePath = resolveOfflineDirectHydrationPath(args.memoryDir, args.file.path);
-  const stat = fs13.statSync(filePath);
-  if (stat.mtimeMs !== args.file.mtimeMs) {
+  const stat2 = fs13.statSync(filePath);
+  if (stat2.mtimeMs !== args.file.mtimeMs) {
     throw new Error(`local file changed while pushing offline content: ${args.file.path}`);
   }
   const hash = createHash4("sha256");
   const chunks = args.readFileChunks({
-    root: path15.resolve(args.memoryDir),
+    root: path16.resolve(args.memoryDir),
     path: args.file.path,
     filePath,
     chunkSize: OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES
@@ -12222,7 +12851,7 @@ Environment fallbacks:
   REMNIC_OFFLINE_REMOTE_URL, REMNIC_OFFLINE_TOKEN, REMNIC_AUTH_TOKEN`);
     return;
   }
-  const memoryDir = path15.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
+  const memoryDir = path16.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
   const namespace = resolveRequiredValueFlag(rest, "--namespace");
   const includeTranscripts = !hasFlag(rest, "--no-transcripts");
   const stateOverride = resolveRequiredValueFlag(rest, "--state");
@@ -12242,7 +12871,7 @@ Environment fallbacks:
   const needsRemote = action === "prepare" || action === "sync" || action === "watch";
   const remoteUrl = needsRemote ? resolveOfflineRemoteUrl(rest) : resolveOptionalOfflineRemoteUrl(rest);
   const token = needsRemote ? resolveOfflineToken(rest) : void 0;
-  const statePath = statePathExplicit ? path15.resolve(expandTilde(stateOverride)) : remoteUrl !== void 0 ? defaultOfflineSyncStatePath(memoryDir, remoteUrl, namespace) : void 0;
+  const statePath = statePathExplicit ? path16.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");
     fs13.mkdirSync(memoryDir, { recursive: true });
@@ -12424,11 +13053,11 @@ Environment fallbacks:
           failures: result.largeFilePushFailures
         });
         largeFileFailureCounts = advanced.counts;
-        for (const path16 of advanced.newlySkipped) {
-          if (skippedLargeFiles.has(path16)) continue;
-          skippedLargeFiles.add(path16);
+        for (const path17 of advanced.newlySkipped) {
+          if (skippedLargeFiles.has(path17)) continue;
+          skippedLargeFiles.add(path17);
           console.warn(
-            `offline sync: permanently skipping ${path16} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
+            `offline sync: permanently skipping ${path17} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
           );
         }
         const pulled = result.pull ? result.pull.upserted + result.pull.deleted : 0;
@@ -12443,11 +13072,11 @@ Environment fallbacks:
             failures: error.failures
           });
           largeFileFailureCounts = advanced.counts;
-          for (const path16 of advanced.newlySkipped) {
-            if (skippedLargeFiles.has(path16)) continue;
-            skippedLargeFiles.add(path16);
+          for (const path17 of advanced.newlySkipped) {
+            if (skippedLargeFiles.has(path17)) continue;
+            skippedLargeFiles.add(path17);
             console.warn(
-              `offline sync: permanently skipping ${path16} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
+              `offline sync: permanently skipping ${path17} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
             );
           }
         }
@@ -12588,7 +13217,7 @@ async function cmdConnectors(action, rest, json) {
             const connectorDaemonUrl = typeof effectiveConnectorConfig.remnicDaemonUrl === "string" && effectiveConnectorConfig.remnicDaemonUrl.trim().length > 0 ? effectiveConnectorConfig.remnicDaemonUrl.trim() : void 0;
             const pubResult = await pub.publish({
               config: { memoryDir, namespace: connectorNamespace, daemonUrl: connectorDaemonUrl },
-              skillsRoot: path15.join(memoryDir, "skills"),
+              skillsRoot: path16.join(memoryDir, "skills"),
               rollbackTokenEntry: preInstallTokenEntry,
               log: { info: console.log, warn: console.warn, error: console.error }
             });
@@ -12948,15 +13577,15 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     }
     const manifest = generateMarketplaceManifest();
     await writeMarketplaceManifest(outputDir, manifest);
-    const outPath = path15.join(outputDir, "marketplace.json");
+    const outPath = path16.join(outputDir, "marketplace.json");
     if (json) {
       console.log(JSON.stringify({ status: "generated", path: outPath }, null, 2));
     } else {
       console.log(`Generated marketplace.json at ${outPath}`);
     }
   } else if (subAction === "validate") {
-    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path15.join(process.cwd(), "marketplace.json");
-    const resolved = path15.resolve(targetPath);
+    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path16.join(process.cwd(), "marketplace.json");
+    const resolved = path16.resolve(targetPath);
     if (!fs13.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
@@ -13238,6 +13867,7 @@ async function cmdLegacyBenchmark(action, rest, json) {
   }
 }
 async function cmdBench(rest) {
+  if (rest[0] === "coding") return cmdBenchCoding(rest.slice(1));
   if (rest[0] === "procedural-ablation") {
     await cmdBenchProceduralAblation(rest.slice(1));
     return;
@@ -13364,7 +13994,7 @@ async function cmdBench(rest) {
     }
     const completeCount = prevStatus.benchmarks.filter((b) => b.status === "complete").length;
     const failedCount = prevStatus.benchmarks.filter((b) => b.status === "failed").length;
-    printBenchStatusLine(parsed.json, `Resuming from: ${path15.basename(latestStatusPath)}`);
+    printBenchStatusLine(parsed.json, `Resuming from: ${path16.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;
@@ -13532,9 +14162,9 @@ Options:
     );
     process.exit(1);
   } else {
-    fixturePath = path15.resolve(expandTilde(fixturePathRaw));
+    fixturePath = path16.resolve(expandTilde(fixturePathRaw));
   }
-  const outPath = path15.resolve(expandTilde(outPathRaw));
+  const outPath = path16.resolve(expandTilde(outPathRaw));
   const benchModule = await loadBenchModule();
   const runner = benchModule.runProceduralAblationCli;
   if (typeof runner !== "function") {
@@ -13553,7 +14183,7 @@ Options:
   );
   console.log(`wrote ${outPath}`);
 }
-var LOGS_DIR = path15.join(PID_DIR, "logs");
+var LOGS_DIR = path16.join(PID_DIR, "logs");
 var LAUNCHD_PLIST_PATHS = launchdPlistPaths(resolveHomeDir());
 var [LAUNCHD_PLIST_PATH] = LAUNCHD_PLIST_PATHS;
 var SYSTEMD_UNIT_PATHS = systemdUnitPaths(resolveHomeDir());
@@ -13630,7 +14260,7 @@ function selectLaunchdInspection(openclawPluginModeConfigured) {
   for (const plistPath of LAUNCHD_PLIST_PATHS.slice(1)) {
     const legacy = inspectLaunchdPlist(plistPath);
     if (!legacy.installed) continue;
-    const label = path15.basename(plistPath, ".plist");
+    const label = path16.basename(plistPath, ".plist");
     return legacy.ok ? {
       ...legacy,
       warn: true,
@@ -13664,10 +14294,10 @@ function daemonInstall() {
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
   fs13.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
-    const templatePath = path15.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
+    const templatePath = path16.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
     const template = fs13.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs13.mkdirSync(path15.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs13.mkdirSync(path16.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
     fs13.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
@@ -13684,10 +14314,10 @@ function daemonInstall() {
     console.log(`  RunAtLoad: true, KeepAlive: true`);
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
-    const templatePath = path15.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
+    const templatePath = path16.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
     const template = fs13.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs13.mkdirSync(path15.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs13.mkdirSync(path16.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
     fs13.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
@@ -14166,7 +14796,7 @@ Clean complete: cleaned=${result.cleaned}`
 }
 async function cmdOpenclawInstall(opts) {
   const configPath = resolveOpenclawConfigPath(opts.configPath);
-  const fallbackMemoryDir = path15.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+  const fallbackMemoryDir = path16.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
   console.log(`OpenClaw config: ${configPath}`);
   const existingConfig = readOpenclawConfig(configPath);
   const { plugins, entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
@@ -14269,7 +14899,7 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
     fs13.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
-  const configDir = path15.dirname(configPath);
+  const configDir = path16.dirname(configPath);
   if (!fs13.existsSync(configDir)) {
     fs13.mkdirSync(configDir, { recursive: true });
   }
@@ -14297,11 +14927,11 @@ async function cmdOpenclawUpgrade(opts) {
   const configPath = resolveOpenclawConfigPath(opts.configPath);
   const pluginDir = resolveOpenclawPluginDir(opts.pluginDir);
   const legacyPluginDirForBackup = opts.legacyPluginDirForBackup ? resolveOpenclawLegacyPluginDir(opts.legacyPluginDirForBackup) : void 0;
-  const fallbackMemoryDir = path15.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+  const fallbackMemoryDir = path16.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
   const packageSpec = `@remnic/plugin-openclaw@${opts.version ?? "latest"}`;
   const existingConfig = readOpenclawConfig(configPath);
   const { entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
-  const preservedMemoryDir = opts.memoryDir ? path15.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
+  const preservedMemoryDir = opts.memoryDir ? path16.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
   assertDirectoryPathOrMissing(pluginDir, "OpenClaw plugin dir");
   if (legacyPluginDirForBackup) {
     assertDirectoryPathOrMissing(legacyPluginDirForBackup, "Legacy OpenClaw plugin dir");
@@ -14313,7 +14943,7 @@ async function cmdOpenclawUpgrade(opts) {
   }
   console.log(`Memory dir:      ${preservedMemoryDir}`);
   console.log(`Package spec:    ${packageSpec}`);
-  console.log(`Backup root:     ${path15.join(resolveHomeDir(), ".openclaw", "backups")}`);
+  console.log(`Backup root:     ${path16.join(resolveHomeDir(), ".openclaw", "backups")}`);
   const plannedActions = [
     `backup openclaw.json and the existing ${REMNIC_OPENCLAW_PLUGIN_ID} extension`,
     ...legacyPluginDirForBackup ? [`backup the existing ${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID} extension without modifying it`] : [],
@@ -14339,9 +14969,9 @@ async function cmdOpenclawUpgrade(opts) {
     }
   }
   const backupDir = createOpenclawUpgradeBackupDir();
-  const configBackupPath = path15.join(backupDir, "openclaw.json");
-  const pluginBackupDir = path15.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
-  const legacyPluginBackupDir = legacyPluginDirForBackup ? path15.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
+  const configBackupPath = path16.join(backupDir, "openclaw.json");
+  const pluginBackupDir = path16.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  const legacyPluginBackupDir = legacyPluginDirForBackup ? path16.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
   const backupNotes = [];
   if (backupPathIfPresent(configPath, configBackupPath)) {
     backupNotes.push(`+ Backed up config to ${configBackupPath}`);
@@ -14442,9 +15072,9 @@ async function cmdOpenclawMigrateEngram(opts) {
   console.log("  - Re-apply any local source patches to the new package only after verifying the published build.");
 }
 function createOpenclawUpgradeBackupDir() {
-  const backupsRoot = path15.join(resolveHomeDir(), ".openclaw", "backups");
+  const backupsRoot = path16.join(resolveHomeDir(), ".openclaw", "backups");
   fs13.mkdirSync(backupsRoot, { recursive: true });
-  return fs13.mkdtempSync(path15.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  return fs13.mkdtempSync(path16.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger2();
@@ -14486,8 +15116,8 @@ async function cmdTaxonomy(rest) {
       const doc = generateResolverDocument(taxonomy);
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
-        const resolverPath = path15.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs13.mkdirSync(path15.dirname(resolverPath), { recursive: true });
+        const resolverPath = path16.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs13.mkdirSync(path16.dirname(resolverPath), { recursive: true });
         fs13.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
@@ -14533,7 +15163,7 @@ async function cmdTaxonomy(rest) {
       console.log(`Added category "${id}" (${name}).`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path15.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        const resolverPath = path16.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
         fs13.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
@@ -14564,7 +15194,7 @@ async function cmdTaxonomy(rest) {
       console.log(`Removed category "${id}".`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path15.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        const resolverPath = path16.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
         fs13.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
@@ -14846,7 +15476,7 @@ async function runTrainingExport(args, stdout = process.stdout) {
     );
   }
   const formatted = adapter.formatRecords(records);
-  const outDir = path15.dirname(args.output);
+  const outDir = path16.dirname(args.output);
   fs13.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
   fs13.writeFileSync(tmpPath, formatted, "utf-8");
@@ -14954,7 +15584,7 @@ async function main(argv = process.argv.slice(2)) {
     case "tree": {
       const subAction = rest[0];
       const json = rest.includes("--json");
-      const outputDir = resolveFlag(rest, "--output") ?? path15.join(process.cwd(), ".remnic", "context-tree");
+      const outputDir = resolveFlag(rest, "--output") ?? path16.join(process.cwd(), ".remnic", "context-tree");
       const categoriesFlag = resolveFlag(rest, "--categories");
       const categories = categoriesFlag ? categoriesFlag.split(",") : void 0;
       const maxPerCategoryRaw = resolveFlag(rest, "--max-per-category");
@@ -15031,7 +15661,7 @@ async function main(argv = process.argv.slice(2)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
-        const indexPath = path15.join(treeDir, "INDEX.md");
+        const indexPath = path16.join(treeDir, "INDEX.md");
         if (!fs13.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
@@ -15502,9 +16132,9 @@ Usage:
   remnic extensions <list|show|validate|reload>  Manage memory extensions
   remnic space <list|switch|create|delete|push|pull|share|promote|audit>  Manage spaces
     create accepts --parent <id> to set parent-child relationship
-  remnic bench <list|run|published|datasets|runs|compare|results|baseline|export|publish|ui|providers|judge-calibrate|attribute|drift-gen> [benchmark...] [--quick] [--all] [--dataset-dir <path>] [--results-dir <path>] [--baselines-dir <path>] [--threshold <value>] [--detail] [--format <json|csv|html>] [--output <path>] [--target remnic-ai] [--json]
+  remnic bench <list|run|published|datasets|runs|compare|results|baseline|export|publish|ui|providers|judge-calibrate|attribute|drift-gen|coding> [benchmark...] [--quick] [--all] [--dataset-dir <path>] [--results-dir <path>] [--baselines-dir <path>] [--threshold <value>] [--detail] [--format <json|csv|html>] [--output <path>] [--target remnic-ai] [--json]
     benchmark is kept as a compatibility alias. check/report remain under that alias.
-  remnic benchmark <list|run|datasets|runs|compare|results|baseline|export|publish|ui|providers|check|report|attribute|drift-gen> [queries...] [--explain] [--baseline=<path>] [--report=<path>]
+  remnic benchmark <list|run|datasets|runs|compare|results|baseline|export|publish|ui|providers|check|report|attribute|drift-gen|coding> [queries...] [--explain] [--baseline=<path>] [--report=<path>]
   remnic briefing [--since <window>] [--focus <filter>] [--save] [--format markdown|json]
     Daily context briefing. Windows: yesterday, today, NNh, NNd, NNw.
     Focus: person:<name>, project:<name>, topic:<name>.