@ngockhoale/ukit 3.0.7 → 3.0.9

package/scripts/bench/memory-baseline.mjs

@@ -0,0 +1,596 @@
+#!/usr/bin/env node
+// TASK-003 — memory baseline harness (SPEC §5 FR-003).
+//
+// Runs the fixed baseline checklist against TEMP COPIES of the TASK-002 fixture
+// corpus and emits baseline-report.json + baseline-report.md. The harness never
+// touches the repo's own .ukit/ store: every probe runs with cwd/HOME pointed at
+// a mkdtemp fixture copy.
+//
+// Exit codes: 0 = ran to completion (verdicts are data), 1 = usage/fixture
+// error, 2 = harness crash. Per-probe timeout default 30s → verdict 'error'.
+// Privacy (SPEC §7/§10): probe text and record bodies never reach the report —
+// commands reference fixture ids and redact probe arguments as `<probe>`.
+
+import { execSync, spawn } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const NODE = process.execPath;
+const UKIT_BIN = path.join(REPO_ROOT, 'bin/ukit');
+const ROUTE_TASK = path.join(REPO_ROOT, 'template_project/.claude/ukit/index/route-task.mjs');
+const REINJECT = path.join(REPO_ROOT, 'template_project/.claude/ukit/runtime/reinject-context.mjs');
+
+const DEFAULT_RUNS = 9;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const VITEST_TIMEOUT_MS = 600_000;
+const BURST_PROCESSES = 4;
+const BURST_WRITES_PER_PROCESS = 10;
+
+// SPEC §5 FR-003 checklist item 1 — the memory-scoped vitest set.
+const MEMORY_TEST_SET = [
+  'tests/core/memoryV2.test.js',
+  'tests/core/memoryRetrieval.test.js',
+  'tests/core/memoryMigration.test.js',
+  'tests/core/migrateLegacy.test.js',
+  'tests/core/userMemory.test.js',
+  'tests/core/deltaOverlays.test.js',
+  'tests/core/learningCandidates.test.js',
+  'tests/cli/memoryCommand.test.js',
+  'tests/audit/memory.test.js',
+  'tests/hooks/sessionEpisode.test.js',
+  'tests/hooks/sessionEpisodeHook.test.js',
+  'tests/index/routeTaskUserLayer.test.js',
+];
+
+const ALL_PROBES = [
+  'vitest-memory-set',
+  'pack',
+  'cli-search',
+  'cli-recall',
+  'route-task',
+  'reinject-context',
+  'write-burst',
+  'corrupt-store',
+];
+
+const USAGE = `Usage: node scripts/bench/memory-baseline.mjs --fixture-root <dir> --out <file.json> [options]
+
+Runs the C55 W0 memory baseline checklist (SPEC §5 FR-003) against temp copies
+of the fixture corpus and writes <file.json> plus a sibling .md report.
+
+Options:
+  --fixture-root <dir>   Fixture corpus root containing manifest.json (required)
+  --out <file.json>      Report output path; <file>.md is written beside it (required)
+  --runs <n>             Latency probe repetitions (default ${DEFAULT_RUNS})
+  --timeout <ms>         Per-probe timeout (default ${DEFAULT_TIMEOUT_MS})
+  --skip <ids>           Comma-separated probe ids to skip
+  --only <ids>           Comma-separated probe ids to run (overrides --skip)
+  --help                 Show this help
+
+Probe ids: ${ALL_PROBES.join(', ')}
+
+Exit codes: 0 = completed (verdicts are data), 1 = usage/fixture error, 2 = crash.`;
+
+// ---------- small helpers ----------
+
+function parseArgs(argv) {
+  const opts = { runs: DEFAULT_RUNS, timeoutMs: DEFAULT_TIMEOUT_MS, skip: new Set(), only: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') return { help: true };
+    const takeValue = () => {
+      i += 1;
+      if (i >= argv.length) throw new Error(`Missing value for ${arg}`);
+      return argv[i];
+    };
+    if (arg === '--fixture-root') opts.fixtureRoot = takeValue();
+    else if (arg === '--out') opts.out = takeValue();
+    else if (arg === '--runs') opts.runs = Number(takeValue());
+    else if (arg === '--timeout') opts.timeoutMs = Number(takeValue());
+    else if (arg === '--skip') opts.skip = new Set(takeValue().split(',').map((s) => s.trim()).filter(Boolean));
+    else if (arg === '--only') opts.only = new Set(takeValue().split(',').map((s) => s.trim()).filter(Boolean));
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return opts;
+}
+
+function sha256File(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function percentile(sorted, q) {
+  if (sorted.length === 0) return null;
+  const rank = Math.max(1, Math.ceil((q / 100) * sorted.length));
+  return sorted[rank - 1];
+}
+
+function latencyStats(durations) {
+  const sorted = [...durations].sort((a, b) => a - b);
+  return {
+    runs: sorted.length,
+    p50: percentile(sorted, 50),
+    p95: percentile(sorted, 95),
+    p99: percentile(sorted, 99),
+  };
+}
+
+/**
+ * Spawn one probe command. `redactArgs` lists argv indices replaced by `<probe>`
+ * in the recorded cmd string so prompt text never reaches the report.
+ */
+function runCommand({ id, argv, cwd, env, stdin, timeoutMs, redactArgs = [], measured = false }) {
+  const redact = new Set(redactArgs);
+  const cmd = argv.map((a, i) => (redact.has(i) ? '<probe>' : a)).join(' ');
+  return new Promise((resolve) => {
+    const started = Date.now();
+    let timedOut = false;
+    let spawnError = null;
+    let child;
+    try {
+      child = spawn(argv[0], argv.slice(1), {
+        cwd,
+        env: { ...process.env, ...env },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      resolve({ id, cmd, exitCode: -1, durationMs: Date.now() - started, timedOut: false, verdict: 'error', note: String(error?.message ?? error) });
+      return;
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGKILL');
+    }, timeoutMs);
+    child.stdout.resume();
+    child.stderr.resume();
+    child.on('error', (error) => { spawnError = error; });
+    if (stdin != null) child.stdin.write(stdin);
+    child.stdin.end();
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - started;
+      let verdict;
+      if (timedOut || spawnError) verdict = 'error';
+      else if (measured) verdict = code === 0 ? 'measured' : 'fail';
+      else verdict = code === 0 ? 'pass' : 'fail';
+      const entry = { id, cmd, exitCode: timedOut || code == null ? -1 : code, durationMs, verdict };
+      if (spawnError) entry.note = String(spawnError.message ?? spawnError);
+      resolve(entry);
+    });
+  });
+}
+
+// ---------- fixture helpers ----------
+
+function loadManifest(fixtureRoot) {
+  const manifestPath = path.join(fixtureRoot, 'manifest.json');
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`fixture manifest not found: ${manifestPath}`);
+  }
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  if (!Array.isArray(manifest.fixtures)) {
+    throw new Error(`fixture manifest has no fixtures[] array: ${manifestPath}`);
+  }
+  for (const fixture of manifest.fixtures) {
+    const abs = path.join(fixtureRoot, fixture.path);
+    if (!fs.existsSync(abs)) {
+      throw new Error(`fixture path missing on disk: ${fixture.path} (${fixture.id})`);
+    }
+    if (fixture.sha256 && sha256File(abs) !== fixture.sha256) {
+      throw new Error(`fixture sha256 mismatch: ${fixture.path} (${fixture.id})`);
+    }
+  }
+  return manifest;
+}
+
+function fixtureById(manifest, id) {
+  const fixture = manifest.fixtures.find((f) => f.id === id);
+  if (!fixture) throw new Error(`fixture id not in manifest: ${id}`);
+  return fixture;
+}
+
+/** Repo dir = fixture path up to (not including) the `.ukit` segment. */
+function fixtureRepoDir(fixtureRoot, fixture) {
+  const segments = fixture.path.split('/');
+  const cut = segments.indexOf('.ukit');
+  if (cut < 0) throw new Error(`fixture path has no .ukit segment: ${fixture.path}`);
+  return path.join(fixtureRoot, ...segments.slice(0, cut));
+}
+
+function copyDir(src, dst) {
+  fs.cpSync(src, dst, { recursive: true });
+}
+
+/** First few words of an active record's text — used as probe input, never reported. */
+function deriveProbeText(repoDir) {
+  const recordsPath = path.join(repoDir, '.ukit/storage/memory/v2/records.json');
+  try {
+    const doc = JSON.parse(fs.readFileSync(recordsPath, 'utf8'));
+    const record = (doc.records ?? []).find((r) => r.status === 'active' && typeof r.text === 'string')
+      ?? (doc.records ?? []).find((r) => typeof r.text === 'string');
+    if (record) return record.text.split(/\s+/).slice(0, 4).join(' ');
+  } catch { /* fall through to generic probe */ }
+  return 'memory baseline probe';
+}
+
+// ---------- probes ----------
+
+async function probeVitest(ctx) {
+  let vitestBin;
+  try {
+    const require = createRequire(import.meta.url);
+    vitestBin = path.join(path.dirname(require.resolve('vitest/package.json')), 'vitest.mjs');
+  } catch (error) {
+    ctx.commands.push({
+      id: 'vitest-memory-set',
+      cmd: 'vitest run <memory-scoped set>',
+      exitCode: -1,
+      durationMs: 0,
+      verdict: 'error',
+      note: `vitest not resolvable: ${error?.message ?? error}`,
+    });
+    return;
+  }
+  const entry = await runCommand({
+    id: 'vitest-memory-set',
+    argv: [NODE, vitestBin, 'run', ...MEMORY_TEST_SET],
+    cwd: REPO_ROOT,
+    timeoutMs: VITEST_TIMEOUT_MS,
+  });
+  ctx.commands.push(entry);
+}
+
+async function probePack(ctx) {
+  const entry = await runCommand({
+    id: 'pack',
+    argv: ['npm', 'pack', '--dry-run', '--json'],
+    cwd: REPO_ROOT,
+    timeoutMs: ctx.timeoutMs,
+  });
+  ctx.commands.push(entry);
+  // Re-run capturing stdout for the stats (dry-run is side-effect free).
+  const captured = await new Promise((resolve) => {
+    const child = spawn('npm', ['pack', '--dry-run', '--json'], { cwd: REPO_ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.resume();
+    const timer = setTimeout(() => { child.kill('SIGKILL'); }, ctx.timeoutMs);
+    child.on('close', () => { clearTimeout(timer); resolve(out); });
+    child.on('error', () => { clearTimeout(timer); resolve(''); });
+  });
+  try {
+    const parsed = JSON.parse(captured);
+    const entry0 = Array.isArray(parsed) ? parsed[0] : parsed;
+    ctx.report.pack = {
+      fileCount: Number.isInteger(entry0?.totalFiles) ? entry0.totalFiles : (entry0?.files?.length ?? 0),
+      totalBytes: Number.isInteger(entry0?.unpackedSize)
+        ? entry0.unpackedSize
+        : (entry0?.files ?? []).reduce((sum, f) => sum + (f.size ?? 0), 0),
+      verdict: 'measured',
+    };
+  } catch {
+    ctx.report.pack = { fileCount: 0, totalBytes: 0, verdict: 'error' };
+  }
+}
+
+async function probeLatency(ctx, { id, argv, cwd, env, stdin, redactArgs }) {
+  const durations = [];
+  for (let run = 0; run < ctx.runs; run += 1) {
+    const entry = await runCommand({
+      id, argv, cwd, env, stdin, redactArgs,
+      timeoutMs: ctx.timeoutMs,
+      measured: true,
+    });
+    ctx.commands.push(entry);
+    if (entry.verdict === 'measured') durations.push(entry.durationMs);
+  }
+  ctx.report.latency[id] = latencyStats(durations);
+}
+
+async function probeWriteBurst(ctx) {
+  const fixture = fixtureById(ctx.manifest, 'fx-stale');
+  const repoDir = fixtureRepoDir(ctx.fixtureRoot, fixture);
+  // `memory --user add` writes the same v2 records.json document through the
+  // same mutateRecordStore/withFileLock path as the project store; HOME is
+  // redirected to a temp dir seeded with the fixture's .ukit state so the
+  // burst targets a temp copy of a fixture store, never the repo's own.
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'ukit-burst-home-'));
+  copyDir(path.join(repoDir, '.ukit'), path.join(home, '.ukit'));
+
+  const expectedWrites = BURST_PROCESSES * BURST_WRITES_PER_PROCESS;
+  const started = Date.now();
+  let spawnFailures = 0;
+  const lanes = [];
+  for (let lane = 0; lane < BURST_PROCESSES; lane += 1) {
+    lanes.push((async () => {
+      for (let w = 0; w < BURST_WRITES_PER_PROCESS; w += 1) {
+        const marker = `burst-${lane}-${w}`;
+        const entry = await runCommand({
+          id: 'write-burst',
+          argv: [NODE, UKIT_BIN, 'memory', '--user', 'add', '--type', 'derived_fact', marker],
+          cwd: ctx.tmpRoot,
+          env: { HOME: home, UKIT_CLI_DEADLINE_MS: '25000' },
+          timeoutMs: ctx.timeoutMs,
+          redactArgs: [7],
+          measured: true,
+        });
+        if (entry.verdict !== 'measured') spawnFailures += 1;
+      }
+    })());
+  }
+  await Promise.all(lanes);
+  const durationMs = Date.now() - started;
+
+  let persistedWrites = 0;
+  let parseOk = true;
+  try {
+    const doc = JSON.parse(fs.readFileSync(path.join(home, '.ukit/storage/memory/v2/records.json'), 'utf8'));
+    persistedWrites = (doc.records ?? []).filter((r) => typeof r.text === 'string' && r.text.startsWith('burst-')).length;
+  } catch {
+    parseOk = false;
+  }
+  const lostUpdates = Math.max(0, expectedWrites - persistedWrites);
+  const verdict = !parseOk || spawnFailures === expectedWrites
+    ? 'error'
+    : lostUpdates > 0 ? 'reproduced' : 'not-reproduced';
+
+  ctx.commands.push({
+    id: 'write-burst',
+    cmd: `${NODE} bin/ukit memory --user add <probe> ×${expectedWrites} (${BURST_PROCESSES}×${BURST_WRITES_PER_PROCESS})`,
+    exitCode: spawnFailures === 0 ? 0 : 1,
+    durationMs,
+    verdict: 'measured',
+  });
+  ctx.report.writeBurst = {
+    processes: BURST_PROCESSES,
+    writesPerProcess: BURST_WRITES_PER_PROCESS,
+    expectedWrites,
+    persistedWrites,
+    lostUpdates,
+    spawnFailures,
+    verdict,
+  };
+}
+
+async function probeCorruptStore(ctx) {
+  const fixture = fixtureById(ctx.manifest, 'fx-corrupt-json');
+  const repoDir = fixtureRepoDir(ctx.fixtureRoot, fixture);
+  const tmpRepo = path.join(ctx.tmpRoot, 'corrupt-repo');
+  copyDir(repoDir, tmpRepo);
+  const recordsPath = path.join(tmpRepo, '.ukit/storage/memory/v2/records.json');
+  const before = sha256File(recordsPath);
+
+  const entry = await runCommand({
+    id: 'corrupt-store',
+    argv: [NODE, UKIT_BIN, 'memory', 'search', 'baseline-corrupt-probe'],
+    cwd: tmpRepo,
+    env: { UKIT_CLI_DEADLINE_MS: '25000' },
+    timeoutMs: ctx.timeoutMs,
+    redactArgs: [4],
+    measured: true,
+  });
+  ctx.commands.push(entry);
+
+  const after = sha256File(recordsPath);
+  const fileBytesUnchanged = before === after;
+  let wroteEmpty = false;
+  if (!fileBytesUnchanged) {
+    try {
+      const doc = JSON.parse(fs.readFileSync(recordsPath, 'utf8'));
+      wroteEmpty = Array.isArray(doc?.records) && doc.records.length === 0;
+    } catch { /* still unparseable — not an empty overwrite */ }
+  }
+  const readOk = entry.exitCode === 0 && !entry.timedOut;
+  ctx.report.corruptStore = {
+    readOk,
+    fileBytesUnchanged,
+    wroteEmpty,
+    verdict: !fileBytesUnchanged
+      ? (wroteEmpty ? 'corrupt-file-overwritten-empty' : 'corrupt-file-mutated')
+      : (readOk ? 'read-degrades-safely' : 'read-fails-but-bytes-unchanged'),
+  };
+}
+
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push('# Memory baseline report');
+  lines.push('');
+  lines.push(`- sha: \`${report.meta.sha}\``);
+  lines.push(`- version: \`${report.meta.version}\``);
+  lines.push(`- node: \`${report.meta.node}\` · os: \`${report.meta.os}\` · arch: \`${report.meta.arch}\``);
+  lines.push(`- date: ${report.meta.date}`);
+  lines.push(`- fs: \`${report.meta.fs}\` — ${report.meta.fsNote}`);
+  if (report.skipped.length > 0) lines.push(`- skipped probes: ${report.skipped.join(', ')}`);
+  lines.push('');
+  lines.push('## Commands');
+  lines.push('');
+  lines.push('| id | cmd | exit | durationMs | verdict |');
+  lines.push('|----|-----|------|------------|---------|');
+  for (const c of report.commands) {
+    lines.push(`| ${c.id} | \`${c.cmd}\` | ${c.exitCode} | ${c.durationMs} | ${c.verdict} |`);
+  }
+  lines.push('');
+  lines.push('## Latency (ms)');
+  lines.push('');
+  lines.push('| probe | runs | p50 | p95 | p99 |');
+  lines.push('|-------|------|-----|-----|-----|');
+  for (const [id, s] of Object.entries(report.latency)) {
+    lines.push(`| ${id} | ${s.runs} | ${s.p50 ?? 'n/a'} | ${s.p95 ?? 'n/a'} | ${s.p99 ?? 'n/a'} |`);
+  }
+  lines.push('');
+  lines.push('## Write burst');
+  lines.push('');
+  const wb = report.writeBurst;
+  lines.push(`- ${wb.processes} processes × ${wb.writesPerProcess} writes = ${wb.expectedWrites} expected`);
+  lines.push(`- persisted: ${wb.persistedWrites} · lost updates: ${wb.lostUpdates} · spawn failures: ${wb.spawnFailures ?? 0}`);
+  lines.push(`- verdict: **${wb.verdict}**`);
+  lines.push('');
+  lines.push('## Corrupt store');
+  lines.push('');
+  const cs = report.corruptStore;
+  lines.push(`- readOk: ${cs.readOk} · fileBytesUnchanged: ${cs.fileBytesUnchanged} · wroteEmpty: ${cs.wroteEmpty}`);
+  lines.push(`- verdict: **${cs.verdict}**`);
+  lines.push('');
+  lines.push('## Pack');
+  lines.push('');
+  lines.push(`- fileCount: ${report.pack.fileCount} · totalBytes: ${report.pack.totalBytes} · verdict: ${report.pack.verdict}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+// ---------- main ----------
+
+async function main() {
+  let opts;
+  try {
+    opts = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    console.error(`[memory-baseline] ${error.message}\n\n${USAGE}`);
+    process.exit(1);
+  }
+  if (opts.help) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  if (!opts.fixtureRoot || !opts.out) {
+    console.error(`[memory-baseline] --fixture-root and --out are required.\n\n${USAGE}`);
+    process.exit(1);
+  }
+  if (!Number.isFinite(opts.runs) || opts.runs < 1) {
+    console.error('[memory-baseline] --runs must be a positive integer.');
+    process.exit(1);
+  }
+
+  const fixtureRoot = path.resolve(opts.fixtureRoot);
+  if (!fs.existsSync(fixtureRoot)) {
+    console.error(`[memory-baseline] fixture root not found: ${fixtureRoot}`);
+    process.exit(1);
+  }
+
+  let manifest;
+  try {
+    manifest = loadManifest(fixtureRoot);
+  } catch (error) {
+    console.error(`[memory-baseline] fixture error: ${error.message}`);
+    process.exit(1);
+  }
+
+  const selected = opts.only ?? new Set(ALL_PROBES.filter((id) => !opts.skip.has(id)));
+  const skipped = ALL_PROBES.filter((id) => !selected.has(id));
+
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ukit-baseline-'));
+
+  // Temp probe repo: copy of the fx-stale fixture repo + a minimal valid
+  // config so `memory recall` (which requires a valid runtime config) runs.
+  const staleFixture = fixtureById(manifest, 'fx-stale');
+  const probeRepo = path.join(tmpRoot, 'probe-repo');
+  copyDir(fixtureRepoDir(fixtureRoot, staleFixture), probeRepo);
+  fs.writeFileSync(path.join(probeRepo, '.ukit/storage/config.json'), '{}\n');
+  const probeText = deriveProbeText(probeRepo);
+
+  const report = {
+    schemaVersion: 1,
+    meta: {
+      sha: 'unknown',
+      version: 'unknown',
+      node: process.version,
+      os: process.platform,
+      arch: process.arch,
+      date: new Date().toISOString(),
+      fs: 'local',
+      fsNote: 'local filesystem only; SMB/network-FS write burst deferred (SPEC §14)',
+    },
+    commands: [],
+    latency: {},
+    writeBurst: {
+      processes: BURST_PROCESSES,
+      writesPerProcess: BURST_WRITES_PER_PROCESS,
+      expectedWrites: BURST_PROCESSES * BURST_WRITES_PER_PROCESS,
+      persistedWrites: 0,
+      lostUpdates: 0,
+      verdict: 'skipped',
+    },
+    corruptStore: { readOk: false, fileBytesUnchanged: false, wroteEmpty: false, verdict: 'skipped' },
+    pack: { fileCount: 0, totalBytes: 0, verdict: 'skipped' },
+    skipped,
+  };
+
+  try {
+    report.meta.sha = execSync('git rev-parse HEAD', { cwd: REPO_ROOT, encoding: 'utf8' }).trim();
+  } catch { /* leave 'unknown' */ }
+  try {
+    report.meta.version = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8')).version ?? 'unknown';
+  } catch { /* leave 'unknown' */ }
+
+  const ctx = {
+    manifest,
+    fixtureRoot,
+    tmpRoot,
+    runs: opts.runs,
+    timeoutMs: opts.timeoutMs,
+    commands: report.commands,
+    report,
+  };
+
+  if (selected.has('vitest-memory-set')) await probeVitest(ctx);
+  if (selected.has('pack')) await probePack(ctx);
+
+  if (selected.has('cli-search')) {
+    await probeLatency(ctx, {
+      id: 'cli-search',
+      argv: [NODE, UKIT_BIN, 'memory', 'search', probeText],
+      cwd: probeRepo,
+      env: { UKIT_CLI_DEADLINE_MS: '25000' },
+      redactArgs: [4],
+    });
+  }
+  if (selected.has('cli-recall')) {
+    await probeLatency(ctx, {
+      id: 'cli-recall',
+      argv: [NODE, UKIT_BIN, 'memory', 'recall', probeText],
+      cwd: probeRepo,
+      env: { UKIT_CLI_DEADLINE_MS: '25000' },
+      redactArgs: [4],
+    });
+  }
+  if (selected.has('route-task')) {
+    await probeLatency(ctx, {
+      id: 'route-task',
+      argv: [NODE, ROUTE_TASK, 'baseline route probe: memory recall path', '--root', probeRepo],
+      cwd: tmpRoot,
+      redactArgs: [2],
+    });
+  }
+  if (selected.has('reinject-context')) {
+    await probeLatency(ctx, {
+      id: 'reinject-context',
+      argv: [NODE, REINJECT],
+      cwd: tmpRoot,
+      env: { CLAUDE_PROJECT_DIR: probeRepo },
+      stdin: JSON.stringify({ session_id: 'bench' }),
+    });
+  }
+  if (selected.has('write-burst')) await probeWriteBurst(ctx);
+  if (selected.has('corrupt-store')) await probeCorruptStore(ctx);
+
+  const outPath = path.resolve(opts.out);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}\n`);
+  const mdPath = outPath.replace(/\.json$/i, '') + '.md';
+  fs.writeFileSync(mdPath, renderMarkdown(report));
+
+  console.log(`[memory-baseline] report written: ${outPath}`);
+  console.log(`[memory-baseline] markdown:      ${mdPath}`);
+  console.log(`[memory-baseline] commands=${report.commands.length} skipped=[${skipped.join(',')}] `
+    + `writeBurst=${report.writeBurst.verdict} corruptStore=${report.corruptStore.verdict}`);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(`[memory-baseline] harness crash: ${error?.stack ?? error}`);
+  process.exit(2);
+});