nexus-agents 2.33.0 → 2.33.2

package/dist/index.js

@@ -656,7 +656,7 @@ import {
   validateWorkflowDependencies,
   withLogging,
   writePredictions
-} from "./chunk-SOW2AJPT.js";
+} from "./chunk-SOPWV5AT.js";
 import {
   getTokenEnvVars,
   hasToken,
@@ -851,7 +851,7 @@ import {
   connectTransport,
   createServer,
   startStdioServer
-} from "./chunk-F3ZEU2IK.js";
+} from "./chunk-SI4GQN6Q.js";
 import "./chunk-XH6CQMDU.js";
 import "./chunk-72OMG44X.js";
 import "./chunk-633WH2ML.js";
@@ -3402,10 +3402,10 @@ var RulesSnapshotSchema = z4.object({
 var PersistentStrategyDistiller = class extends StrategyDistiller {
   filePath;
   persistLogger;
-  constructor(outcomeStore, persistConfig, logger10, distillerConfig) {
-    super(outcomeStore, logger10, distillerConfig);
+  constructor(outcomeStore, persistConfig, logger15, distillerConfig) {
+    super(outcomeStore, logger15, distillerConfig);
     this.filePath = persistConfig?.filePath ?? RULES_FILE;
-    this.persistLogger = logger10 ?? createLogger({ component: "PersistentStrategyDistiller" });
+    this.persistLogger = logger15 ?? createLogger({ component: "PersistentStrategyDistiller" });
     const dataDir = persistConfig?.dataDir;
     ensureLearningDir(dataDir);
     this.hydrate();
@@ -3481,7 +3481,7 @@ var PersistentStrategyDistiller = class extends StrategyDistiller {
   }
 };
 registerPersistentDistillerFactory(
-  (outcomeStore, logger10) => new PersistentStrategyDistiller(outcomeStore, void 0, logger10)
+  (outcomeStore, logger15) => new PersistentStrategyDistiller(outcomeStore, void 0, logger15)
 );
 
 // src/learning/ab-test-tracker.ts
@@ -5314,12 +5314,976 @@ function calculateTokenCost(tokens, ratePerThousand) {
   return tokens.totalTokens / 1e3 * ratePerThousand;
 }
 
-// src/pipeline/v1-adapters.ts
+// src/benchmarks/memory-benchmarks-helpers.ts
 import { randomUUID } from "crypto";
+var BENCHMARK_WORDS = ["memory", "test", "benchmark", "data", "entry", "performance", "latency"];
+function generateContent(sizeBytes, words = BENCHMARK_WORDS) {
+  const parts = [];
+  let currentSize = 0;
+  while (currentSize < sizeBytes) {
+    const word = words[Math.floor(getRandomProvider().random() * words.length)] ?? "data";
+    parts.push(word);
+    currentSize += word.length + 1;
+  }
+  return parts.join(" ").slice(0, sizeBytes);
+}
+function generateTags(count, words = BENCHMARK_WORDS) {
+  const tags = [];
+  for (let i = 0; i < count; i++) {
+    tags.push(words[Math.floor(getRandomProvider().random() * words.length)] ?? "tag");
+  }
+  return tags;
+}
+function generateTestData(size, config) {
+  const entries = [];
+  for (let i = 0; i < size; i++) {
+    const key = `bench-${randomUUID()}`;
+    const content = generateContent(config.contentSizeBytes, BENCHMARK_WORDS);
+    const tags = generateTags(config.tagsPerEntry, BENCHMARK_WORDS);
+    entries.push({ key, content, tags });
+  }
+  return { entries, size };
+}
+function calculatePatternMetrics(retrieved, relevant) {
+  const relevantRetrieved = retrieved.filter((key) => relevant.some((r) => r.key === key));
+  const precision = retrieved.length > 0 ? relevantRetrieved.length / retrieved.length : 0;
+  const recall = relevant.length > 0 ? relevantRetrieved.length / relevant.length : 0;
+  const firstRelevantIndex = retrieved.findIndex(
+    (key) => relevant.some((r) => r.key === key)
+  );
+  const mrr = firstRelevantIndex >= 0 ? 1 / (firstRelevantIndex + 1) : 0;
+  return { precision, recall, mrr };
+}
+function computeAverageMetrics(totalPrecision, totalRecall, totalMrr, queries) {
+  const avgPrecision = queries > 0 ? totalPrecision / queries : 0;
+  const avgRecall = queries > 0 ? totalRecall / queries : 0;
+  const f1Score = avgPrecision + avgRecall > 0 ? 2 * avgPrecision * avgRecall / (avgPrecision + avgRecall) : 0;
+  return {
+    precision: avgPrecision,
+    recall: avgRecall,
+    f1Score,
+    mrr: queries > 0 ? totalMrr / queries : 0,
+    ndcgAtK: f1Score
+    // Simplified approximation
+  };
+}
+function createOperationComparison(options) {
+  const { operation, datasetSize, baselineP95, currentP95, baselineThroughput, currentThroughput } = options;
+  const latencyChangePercent = (currentP95 - baselineP95) / baselineP95 * 100;
+  const throughputChangePercent = (currentThroughput - baselineThroughput) / baselineThroughput * 100;
+  return {
+    operation,
+    datasetSize,
+    baselineP95,
+    currentP95,
+    latencyChangePercent,
+    baselineThroughput,
+    currentThroughput,
+    throughputChangePercent,
+    improved: latencyChangePercent < 0 || throughputChangePercent > 0
+  };
+}
+function calculateAverageLatencyImprovement(comparisons) {
+  if (comparisons.length === 0) return 0;
+  return comparisons.reduce((sum, c) => sum + c.latencyChangePercent, 0) / comparisons.length;
+}
+function formatComparisonResults(comparison) {
+  const lines = [];
+  lines.push(`
+Benchmark Comparison: ${comparison.baseline} vs ${comparison.current}`);
+  lines.push("=".repeat(60));
+  for (const c of comparison.comparisons) {
+    const latencyArrow = c.latencyChangePercent < 0 ? "\u2193" : "\u2191";
+    const throughputArrow = c.throughputChangePercent > 0 ? "\u2191" : "\u2193";
+    lines.push(`
+${c.operation} (n=${String(c.datasetSize)})`);
+    lines.push(
+      `  p95 Latency: ${c.baselineP95.toFixed(2)}ms \u2192 ${c.currentP95.toFixed(2)}ms (${latencyArrow}${Math.abs(c.latencyChangePercent).toFixed(1)}%)`
+    );
+    lines.push(
+      `  Throughput: ${c.baselineThroughput.toFixed(2)} \u2192 ${c.currentThroughput.toFixed(2)} ops/sec (${throughputArrow}${Math.abs(c.throughputChangePercent).toFixed(1)}%)`
+    );
+  }
+  lines.push("\n" + "=".repeat(60));
+  lines.push(`Overall Latency Change: ${comparison.overallLatencyChangePercent.toFixed(1)}%`);
+  lines.push(`Meets Mem0 Target (-91%): ${comparison.meetsMemZeroTarget ? "YES" : "NO"}`);
+  lines.push("=".repeat(60) + "\n");
+  return lines.join("\n");
+}
+
+// src/benchmarks/benchmark-types.ts
+var DEFAULT_BENCHMARK_CONFIG = {
+  datasetSizes: [100, 1e3, 1e4],
+  warmupIterations: 10,
+  measurementIterations: 100,
+  timeoutMs: 3e4,
+  thresholds: {
+    maxP95LatencyMs: 100,
+    minThroughput: 100,
+    maxMemoryBytes: 512 * 1024 * 1024,
+    // 512MB
+    minPrecision: 0.8,
+    minRecall: 0.7
+  }
+};
+
+// src/benchmarks/benchmark-runner.ts
+import { cpus, totalmem, platform, arch } from "os";
+var logger4 = createLogger({ component: "benchmark-runner" });
+var LatencySampler = class {
+  samples = [];
+  startTimes = /* @__PURE__ */ new Map();
+  /**
+   * Start timing an operation.
+   */
+  start(id) {
+    this.startTimes.set(id, process.hrtime.bigint());
+  }
+  /**
+   * End timing and record the sample.
+   */
+  end(id) {
+    const startTime = this.startTimes.get(id);
+    if (startTime === void 0) {
+      throw new Error(`No start time for ${id}`);
+    }
+    const endTime = process.hrtime.bigint();
+    const durationNs = Number(endTime - startTime);
+    const durationMs = Math.max(0, durationNs / 1e6);
+    this.samples.push(durationMs);
+    this.startTimes.delete(id);
+    return durationMs;
+  }
+  /**
+   * Record a sample directly.
+   */
+  record(durationMs) {
+    this.samples.push(durationMs);
+  }
+  /**
+   * Calculate latency metrics from collected samples.
+   */
+  getMetrics() {
+    if (this.samples.length === 0) {
+      return createEmptyLatencyMetrics();
+    }
+    const sorted = [...this.samples].sort((a, b) => a - b);
+    const sum = sorted.reduce((a, b) => a + b, 0);
+    const mean = sum / sorted.length;
+    const squaredDiffs = sorted.map((v) => Math.pow(v - mean, 2));
+    const variance = squaredDiffs.reduce((a, b) => a + b, 0) / sorted.length;
+    const stdDev = Math.sqrt(variance);
+    return {
+      min: sorted[0] ?? 0,
+      max: sorted[sorted.length - 1] ?? 0,
+      mean,
+      p50: percentile(sorted, 50),
+      p75: percentile(sorted, 75),
+      p90: percentile(sorted, 90),
+      p95: percentile(sorted, 95),
+      p99: percentile(sorted, 99),
+      stdDev,
+      sampleCount: sorted.length
+    };
+  }
+  /**
+   * Reset collected samples.
+   */
+  reset() {
+    this.samples.length = 0;
+    this.startTimes.clear();
+  }
+};
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  if (sorted.length === 1) return sorted[0] ?? 0;
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  const fraction = index - lower;
+  const lowerValue = sorted[lower] ?? 0;
+  const upperValue = sorted[upper] ?? 0;
+  return lowerValue + fraction * (upperValue - lowerValue);
+}
+function createEmptyLatencyMetrics() {
+  return {
+    min: 0,
+    max: 0,
+    mean: 0,
+    p50: 0,
+    p75: 0,
+    p90: 0,
+    p95: 0,
+    p99: 0,
+    stdDev: 0,
+    sampleCount: 0
+  };
+}
+async function runOperationBenchmark(operation, datasetSize, fn, config = {}) {
+  const cfg = { ...DEFAULT_BENCHMARK_CONFIG, ...config };
+  const sampler = new LatencySampler();
+  const startTime = getTimeProvider().now();
+  const startMemory = process.memoryUsage().heapUsed;
+  let peakMemory = startMemory;
+  logger4.debug("Running warmup", { operation, iterations: cfg.warmupIterations });
+  for (let i = 0; i < cfg.warmupIterations; i++) {
+    await fn();
+  }
+  logger4.debug("Running measurements", { operation, iterations: cfg.measurementIterations });
+  for (let i = 0; i < cfg.measurementIterations; i++) {
+    const id = `op-${String(i)}`;
+    sampler.start(id);
+    await fn();
+    sampler.end(id);
+    const currentMemory = process.memoryUsage().heapUsed;
+    if (currentMemory > peakMemory) {
+      peakMemory = currentMemory;
+    }
+  }
+  const endTime = getTimeProvider().now();
+  const durationMs = endTime - startTime;
+  const latency = sampler.getMetrics();
+  const throughput = {
+    opsPerSecond: cfg.measurementIterations / durationMs * 1e3,
+    totalOps: cfg.measurementIterations,
+    durationMs
+  };
+  const resources = {
+    peakMemoryBytes: peakMemory,
+    avgMemoryBytes: (startMemory + peakMemory) / 2,
+    cpuTimeMs: durationMs
+    // Approximation
+  };
+  return {
+    operation,
+    datasetSize,
+    latency,
+    throughput,
+    resources,
+    timestamp: getTimeProvider().nowIso()
+  };
+}
+function getBenchmarkEnvironment() {
+  const cpuInfo = cpus();
+  return {
+    nodeVersion: process.version,
+    platform: platform(),
+    arch: arch(),
+    cpuModel: cpuInfo[0]?.model ?? "Unknown",
+    cpuCores: cpuInfo.length,
+    totalMemory: totalmem()
+  };
+}
+function createBenchmarkSummary(operations, config = {}) {
+  const cfg = { ...DEFAULT_BENCHMARK_CONFIG, ...config };
+  const failures = [];
+  const totalDurationMs = operations.reduce((sum, op) => sum + op.throughput.durationMs, 0);
+  const totalOps = operations.reduce((sum, op) => sum + op.throughput.totalOps, 0);
+  const overallThroughput = totalOps / (totalDurationMs / 1e3);
+  const p95Values = operations.map((op) => op.latency.p95);
+  const avgP95Latency = p95Values.reduce((a, b) => a + b, 0) / p95Values.length;
+  for (const op of operations) {
+    if (op.latency.p95 > cfg.thresholds.maxP95LatencyMs) {
+      failures.push(
+        `${op.operation}: p95 latency ${op.latency.p95.toFixed(2)}ms exceeds threshold`
+      );
+    }
+    if (op.throughput.opsPerSecond < cfg.thresholds.minThroughput) {
+      failures.push(
+        `${op.operation}: throughput ${op.throughput.opsPerSecond.toFixed(2)} below threshold`
+      );
+    }
+    if (op.resources.peakMemoryBytes > cfg.thresholds.maxMemoryBytes) {
+      failures.push(
+        `${op.operation}: memory ${String(op.resources.peakMemoryBytes)} exceeds threshold`
+      );
+    }
+  }
+  return {
+    totalDurationMs,
+    totalOperations: totalOps,
+    overallThroughput,
+    avgP95Latency,
+    passed: failures.length === 0,
+    failures
+  };
+}
+function formatBenchmarkResults(result) {
+  const lines = [];
+  lines.push(`
+${"=".repeat(60)}`);
+  lines.push(`Benchmark Suite: ${result.name}`);
+  lines.push(`Component: ${result.component} v${result.version}`);
+  lines.push(`${"=".repeat(60)}
+`);
+  lines.push("Environment:");
+  lines.push(`  Node.js: ${result.environment.nodeVersion}`);
+  lines.push(`  Platform: ${result.environment.platform} ${result.environment.arch}`);
+  lines.push(
+    `  CPU: ${result.environment.cpuModel} (${String(result.environment.cpuCores)} cores)`
+  );
+  lines.push(`  Memory: ${(result.environment.totalMemory / 1024 / 1024 / 1024).toFixed(1)} GB
+`);
+  lines.push("Operations:");
+  for (const op of result.operations) {
+    lines.push(`
+  ${op.operation} (n=${String(op.datasetSize)})`);
+    lines.push(
+      `    Latency: p50=${op.latency.p50.toFixed(2)}ms, p95=${op.latency.p95.toFixed(2)}ms, p99=${op.latency.p99.toFixed(2)}ms`
+    );
+    lines.push(`    Throughput: ${op.throughput.opsPerSecond.toFixed(2)} ops/sec`);
+    lines.push(`    Memory: ${(op.resources.peakMemoryBytes / 1024 / 1024).toFixed(2)} MB peak`);
+  }
+  lines.push(`
+${"=".repeat(60)}`);
+  lines.push("Summary:");
+  lines.push(`  Total Duration: ${result.summary.totalDurationMs.toFixed(2)}ms`);
+  lines.push(`  Total Operations: ${String(result.summary.totalOperations)}`);
+  lines.push(`  Overall Throughput: ${result.summary.overallThroughput.toFixed(2)} ops/sec`);
+  lines.push(`  Average p95 Latency: ${result.summary.avgP95Latency.toFixed(2)}ms`);
+  lines.push(`  Status: ${result.summary.passed ? "PASSED" : "FAILED"}`);
+  if (result.summary.failures.length > 0) {
+    lines.push("\nFailures:");
+    for (const failure of result.summary.failures) {
+      lines.push(`  - ${failure}`);
+    }
+  }
+  lines.push(`${"=".repeat(60)}
+`);
+  return lines.join("\n");
+}
+
+// src/benchmarks/memory-benchmarks.ts
+var logger5 = createLogger({ component: "memory-benchmarks" });
+var DEFAULT_MEMORY_BENCHMARK_CONFIG = {
+  ...DEFAULT_BENCHMARK_CONFIG,
+  contentSizeBytes: 1024,
+  tagsPerEntry: 5,
+  searchPatterns: ["test", "memory", "benchmark", "data", "entry"]
+};
+async function benchmarkStore(backend, data, config) {
+  let dataIndex = 0;
+  return runOperationBenchmark(
+    "store",
+    data.size,
+    async () => {
+      const entry = data.entries[dataIndex % data.entries.length];
+      if (entry === void 0) return;
+      await backend.store(entry.key, entry.content, {
+        tags: entry.tags,
+        importance: "medium"
+      });
+      dataIndex++;
+    },
+    config
+  );
+}
+async function benchmarkRetrieve(backend, data, config) {
+  for (const entry of data.entries) {
+    await backend.store(entry.key, entry.content, {
+      tags: entry.tags,
+      importance: "medium"
+    });
+  }
+  let dataIndex = 0;
+  return runOperationBenchmark(
+    "retrieve",
+    data.size,
+    async () => {
+      const entry = data.entries[dataIndex % data.entries.length];
+      if (entry === void 0) return;
+      await backend.retrieve(entry.key);
+      dataIndex++;
+    },
+    config
+  );
+}
+async function measureSearchQuality(backend, data, config) {
+  let totalPrecision = 0;
+  let totalRecall = 0;
+  let totalMrr = 0;
+  let queries = 0;
+  for (const pattern of config.searchPatterns) {
+    const relevant = data.entries.filter(
+      (e) => e.content.includes(pattern) || e.tags.includes(pattern)
+    );
+    if (relevant.length === 0) continue;
+    const searchResult = await backend.search(pattern, 10);
+    if (!searchResult.ok) continue;
+    const retrieved = searchResult.value.map((r) => r.key);
+    const metrics = calculatePatternMetrics(retrieved, relevant);
+    totalPrecision += metrics.precision;
+    totalRecall += metrics.recall;
+    totalMrr += metrics.mrr;
+    queries++;
+  }
+  return computeAverageMetrics(totalPrecision, totalRecall, totalMrr, queries);
+}
+async function benchmarkSearch(backend, data, config) {
+  for (const entry of data.entries) {
+    await backend.store(entry.key, entry.content, {
+      tags: entry.tags,
+      importance: "medium"
+    });
+  }
+  let patternIndex = 0;
+  const benchmark = await runOperationBenchmark(
+    "search",
+    data.size,
+    async () => {
+      const pattern = config.searchPatterns[patternIndex % config.searchPatterns.length];
+      if (pattern === void 0) return;
+      await backend.search(pattern, 10);
+      patternIndex++;
+    },
+    config
+  );
+  const quality = await measureSearchQuality(backend, data, config);
+  return { ...benchmark, quality };
+}
+async function benchmarkPrune(backend, data, config) {
+  for (const entry of data.entries) {
+    await backend.store(entry.key, entry.content, {
+      tags: entry.tags,
+      importance: "low"
+    });
+  }
+  return runOperationBenchmark(
+    "prune",
+    data.size,
+    async () => {
+      const pruneDate = new Date(getTimeProvider().now() - 24 * 60 * 60 * 1e3);
+      await backend.prune(pruneDate);
+    },
+    { ...config, measurementIterations: 10 }
+    // Fewer iterations for destructive operation
+  );
+}
+async function runMemoryBenchmarks(backend, name, config = {}) {
+  const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
+  const operations = [];
+  logger5.info("Starting memory benchmarks", { name, sizes: cfg.datasetSizes });
+  for (const size of cfg.datasetSizes) {
+    logger5.info("Running benchmarks for dataset size", { size });
+    const data = generateTestData(size, cfg);
+    try {
+      const futureDate = new Date(getTimeProvider().now() + 365 * 24 * 60 * 60 * 1e3);
+      await backend.prune(futureDate);
+    } catch {
+    }
+    operations.push(await benchmarkStore(backend, data, cfg));
+    operations.push(await benchmarkRetrieve(backend, data, cfg));
+    operations.push(await benchmarkSearch(backend, data, cfg));
+    operations.push(await benchmarkPrune(backend, data, cfg));
+  }
+  const environment = getBenchmarkEnvironment();
+  const summary = createBenchmarkSummary(operations, cfg);
+  logger5.info("Benchmarks complete", {
+    name,
+    passed: summary.passed,
+    avgP95: summary.avgP95Latency,
+    throughput: summary.overallThroughput
+  });
+  return {
+    name: `Memory Backend: ${name}`,
+    component: "memory-backend",
+    version: "2.0.0",
+    operations,
+    environment,
+    summary
+  };
+}
+function compareBenchmarks(baseline, current) {
+  const comparisons = [];
+  for (const currentOp of current.operations) {
+    const baselineOp = baseline.operations.find(
+      (op) => op.operation === currentOp.operation && op.datasetSize === currentOp.datasetSize
+    );
+    if (baselineOp !== void 0) {
+      comparisons.push(
+        createOperationComparison({
+          operation: currentOp.operation,
+          datasetSize: currentOp.datasetSize,
+          baselineP95: baselineOp.latency.p95,
+          currentP95: currentOp.latency.p95,
+          baselineThroughput: baselineOp.throughput.opsPerSecond,
+          currentThroughput: currentOp.throughput.opsPerSecond
+        })
+      );
+    }
+  }
+  const avgLatencyImprovement = calculateAverageLatencyImprovement(comparisons);
+  return {
+    baseline: baseline.name,
+    current: current.name,
+    comparisons,
+    overallLatencyChangePercent: avgLatencyImprovement,
+    meetsMemZeroTarget: avgLatencyImprovement <= -91
+    // Mem0 claims 91% lower latency
+  };
+}
+
+// src/benchmarks/token-benchmark.ts
+var logger6 = createLogger({ component: "token-benchmark" });
+var CHARS_PER_TOKEN2 = 4;
+function estimateTokens2(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN2);
+}
+function calculateTokenMetrics(entries, queryCount) {
+  const totalTokens = estimateTokens2(entries.map((e) => e.content).join("\n"));
+  return {
+    inputTokens: totalTokens,
+    outputTokens: 0,
+    totalTokens,
+    avgTokensPerOp: queryCount > 0 ? totalTokens / queryCount : 0
+  };
+}
+async function runTokenBenchmark(backend, config = {}) {
+  const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
+  const results = [];
+  for (const size of cfg.datasetSizes) {
+    logger6.info("Running token benchmark", { size });
+    const data = generateTestData(size, cfg);
+    for (const entry of data.entries) {
+      await backend.store(entry.key, entry.content, {
+        tags: entry.tags,
+        importance: "medium"
+      });
+    }
+    const baseline = calculateTokenMetrics(data.entries, cfg.searchPatterns.length);
+    const searchResults = [];
+    for (const pattern of cfg.searchPatterns) {
+      const result = await backend.search(pattern, 10);
+      if (result.ok) {
+        searchResults.push(...result.value);
+      }
+    }
+    const optimizedEntries = searchResults.map((r) => ({
+      content: String(r.value)
+    }));
+    const optimized = calculateTokenMetrics(optimizedEntries, cfg.searchPatterns.length);
+    const savingsPercent = baseline.totalTokens > 0 ? (baseline.totalTokens - optimized.totalTokens) / baseline.totalTokens * 100 : 0;
+    results.push({
+      datasetSize: size,
+      baseline,
+      optimized,
+      savingsPercent,
+      meetsMemZeroTarget: savingsPercent >= 90
+    });
+  }
+  return results;
+}
+
+// src/benchmarks/consolidation-benchmark.ts
+var logger7 = createLogger({ component: "consolidation-benchmark" });
+async function runConsolidationBenchmark(operations, config = {}) {
+  const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
+  const benchmarks = [];
+  logger7.info("Starting consolidation benchmarks", {
+    operationCount: operations.length
+  });
+  for (const op of operations) {
+    logger7.info("Benchmarking consolidation operation", { name: op.name });
+    const benchmark = await runOperationBenchmark(
+      op.name,
+      0,
+      // consolidation ops don't have dataset size
+      op.run,
+      cfg
+    );
+    benchmarks.push(benchmark);
+  }
+  return {
+    operations: benchmarks,
+    timestamp: getTimeProvider().nowIso()
+  };
+}
+function createPromotionOp(name, promoteFn) {
+  return { name: `promotion:${name}`, run: promoteFn };
+}
+function createDecayOp(name, decayFn) {
+  return { name: `decay:${name}`, run: decayFn };
+}
+
+// src/benchmarks/benchmark-report.ts
+var MEM0_TARGETS = {
+  latencyReductionPercent: 91,
+  tokenSavingsPercent: 90,
+  qualityImprovementPercent: 26
+};
+function validateLatencyClaim(comparison) {
+  const actual = comparison !== void 0 ? Math.abs(comparison.overallLatencyChangePercent) : 0;
+  return {
+    claim: "Latency reduction",
+    targetPercent: MEM0_TARGETS.latencyReductionPercent,
+    actualPercent: actual,
+    met: actual >= MEM0_TARGETS.latencyReductionPercent,
+    delta: actual - MEM0_TARGETS.latencyReductionPercent
+  };
+}
+function validateTokenClaim(tokenResults) {
+  const avgSavings = tokenResults.length > 0 ? tokenResults.reduce((sum, r) => sum + r.savingsPercent, 0) / tokenResults.length : 0;
+  return {
+    claim: "Token savings",
+    targetPercent: MEM0_TARGETS.tokenSavingsPercent,
+    actualPercent: avgSavings,
+    met: avgSavings >= MEM0_TARGETS.tokenSavingsPercent,
+    delta: avgSavings - MEM0_TARGETS.tokenSavingsPercent
+  };
+}
+function validateQualityClaim(suite) {
+  const searchOps = suite?.operations.filter((op) => op.quality !== void 0) ?? [];
+  const avgF1 = searchOps.length > 0 ? searchOps.reduce((sum, op) => sum + (op.quality?.f1Score ?? 0), 0) / searchOps.length : 0;
+  const actualPercent = avgF1 * 100;
+  return {
+    claim: "Quality improvement (F1)",
+    targetPercent: MEM0_TARGETS.qualityImprovementPercent,
+    actualPercent,
+    met: actualPercent >= MEM0_TARGETS.qualityImprovementPercent,
+    delta: actualPercent - MEM0_TARGETS.qualityImprovementPercent
+  };
+}
+function generateBenchmarkReport(options) {
+  const validations = [
+    validateLatencyClaim(options.comparison),
+    validateTokenClaim(options.tokenResults ?? []),
+    validateQualityClaim(options.suite)
+  ];
+  return {
+    version: "1.0.0",
+    timestamp: getTimeProvider().nowIso(),
+    suite: options.suite ?? null,
+    comparison: options.comparison ?? null,
+    tokenResults: options.tokenResults ?? [],
+    consolidation: options.consolidation ?? null,
+    mem0Validation: validations,
+    overallPass: validations.every((v) => v.met)
+  };
+}
+function formatBenchmarkReport(report) {
+  const lines = [];
+  lines.push("=".repeat(60));
+  lines.push("Mem0 Memory Benchmark Report");
+  lines.push(`Generated: ${report.timestamp}`);
+  lines.push("=".repeat(60));
+  lines.push("\nMem0 Claim Validation:");
+  for (const v of report.mem0Validation) {
+    const status = v.met ? "PASS" : "FAIL";
+    const sign = v.delta >= 0 ? "+" : "";
+    lines.push(
+      `  [${status}] ${v.claim}: ${v.actualPercent.toFixed(1)}% (target: ${String(v.targetPercent)}%, delta: ${sign}${v.delta.toFixed(1)}%)`
+    );
+  }
+  if (report.tokenResults.length > 0) {
+    lines.push("\nToken Savings by Dataset Size:");
+    for (const t of report.tokenResults) {
+      const status = t.meetsMemZeroTarget ? "PASS" : "FAIL";
+      lines.push(
+        `  [${status}] n=${String(t.datasetSize)}: ${String(t.baseline.totalTokens)} \u2192 ${String(t.optimized.totalTokens)} tokens (${t.savingsPercent.toFixed(1)}% saved)`
+      );
+    }
+  }
+  if (report.consolidation !== null) {
+    lines.push("\nConsolidation Operations:");
+    for (const op of report.consolidation.operations) {
+      lines.push(
+        `  ${op.operation}: p95=${op.latency.p95.toFixed(2)}ms, ${op.throughput.opsPerSecond.toFixed(0)} ops/sec`
+      );
+    }
+  }
+  lines.push("\n" + "=".repeat(60));
+  lines.push(`Overall: ${report.overallPass ? "ALL CLAIMS VALIDATED" : "SOME CLAIMS NOT MET"}`);
+  lines.push("=".repeat(60));
+  return lines.join("\n");
+}
+
+// src/benchmarks/adapter-latency-benchmark.ts
+var logger8 = createLogger({ component: "adapter-latency-benchmark" });
+var DEFAULT_ADAPTER_LATENCY_CONFIG = {
+  warmupIterations: 3,
+  measurementIterations: 10,
+  timeoutMs: 6e4
+};
+var DEFAULT_SCENARIOS = [
+  {
+    name: "simple-prompt",
+    content: "What is 2+2?",
+    maxTokens: 50
+  },
+  {
+    name: "complex-prompt",
+    content: [
+      "Analyze the following code for security vulnerabilities,",
+      "performance issues, and best practice violations.",
+      "Provide a structured report with severity ratings.",
+      "Code: function processInput(data) {",
+      "  const query = `SELECT * FROM users WHERE id = ${data.id}`;",
+      "  return db.execute(query);",
+      "}"
+    ].join(" "),
+    systemPrompt: "You are a senior security engineer.",
+    maxTokens: 500
+  }
+];
+async function runAdapterLatencyBenchmark(adapters, scenarios = DEFAULT_SCENARIOS, config = {}) {
+  const cfg = { ...DEFAULT_ADAPTER_LATENCY_CONFIG, ...config };
+  const environment = getBenchmarkEnvironment();
+  const overallStart = getTimeProvider().now();
+  const results = [];
+  for (const adapter of adapters) {
+    for (const scenario of scenarios) {
+      const result = await benchmarkScenario(adapter, scenario, cfg);
+      results.push(result);
+    }
+  }
+  return {
+    timestamp: getTimeProvider().nowIso(),
+    environment,
+    results,
+    totalDurationMs: getTimeProvider().now() - overallStart
+  };
+}
+async function benchmarkScenario(adapter, scenario, config) {
+  const sampler = new LatencySampler();
+  const errors = [];
+  let successCount = 0;
+  let failureCount = 0;
+  logger8.info("Benchmarking scenario", {
+    adapter: adapter.name,
+    scenario: scenario.name,
+    warmup: config.warmupIterations,
+    iterations: config.measurementIterations
+  });
+  for (let i = 0; i < config.warmupIterations; i++) {
+    await executeScenario(adapter, scenario, config.timeoutMs);
+  }
+  for (let i = 0; i < config.measurementIterations; i++) {
+    const id = `${adapter.name}-${scenario.name}-${String(i)}`;
+    sampler.start(id);
+    const result = await executeScenario(adapter, scenario, config.timeoutMs);
+    sampler.end(id);
+    if (result.ok) {
+      successCount++;
+    } else {
+      failureCount++;
+      errors.push(result.error);
+    }
+  }
+  return {
+    adapterName: adapter.name,
+    transport: adapter.transport,
+    scenario: scenario.name,
+    latency: sampler.getMetrics(),
+    successCount,
+    failureCount,
+    errors
+  };
+}
+async function executeScenario(adapter, scenario, timeoutMs) {
+  try {
+    const task = {
+      content: scenario.content,
+      timeoutMs
+    };
+    if (scenario.systemPrompt !== void 0) {
+      task.systemPrompt = scenario.systemPrompt;
+    }
+    if (scenario.maxTokens !== void 0) {
+      task.maxTokens = scenario.maxTokens;
+    }
+    const result = await adapter.execute(task, {
+      timeoutMs
+    });
+    return result.ok ? { ok: true } : { ok: false, error: result.error.message };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: msg };
+  }
+}
+function formatScenarioTables(results) {
+  const lines = [];
+  const scenarios = new Set(results.map((r) => r.scenario));
+  for (const scenario of scenarios) {
+    lines.push(`## Scenario: ${scenario}`);
+    lines.push("");
+    lines.push(
+      "| Adapter | Transport | p50 (ms) | p95 (ms) | p99 (ms) | Mean (ms) | Success Rate |"
+    );
+    lines.push(
+      "|---------|-----------|----------|----------|----------|-----------|-------------|"
+    );
+    const scenarioResults = results.filter((r) => r.scenario === scenario);
+    for (const r of scenarioResults) {
+      const total = r.successCount + r.failureCount;
+      const rate = total > 0 ? (r.successCount / total * 100).toFixed(0) : "0";
+      lines.push(
+        `| ${r.adapterName} | ${r.transport} | ${r.latency.p50.toFixed(1)} | ${r.latency.p95.toFixed(1)} | ${r.latency.p99.toFixed(1)} | ${r.latency.mean.toFixed(1)} | ${rate}% |`
+      );
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function formatTransportComparison(results) {
+  const lines = [];
+  lines.push("## Transport Comparison");
+  lines.push("");
+  const transports = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const existing = transports.get(r.transport) ?? [];
+    existing.push(r);
+    transports.set(r.transport, existing);
+  }
+  for (const [transport, items] of transports) {
+    const avgP50 = items.reduce((s, r) => s + r.latency.p50, 0) / items.length;
+    const avgP95 = items.reduce((s, r) => s + r.latency.p95, 0) / items.length;
+    lines.push(
+      `- **${transport}**: avg p50=${avgP50.toFixed(1)}ms, avg p95=${avgP95.toFixed(1)}ms`
+    );
+  }
+  return lines;
+}
+function formatAdapterLatencyReport(result) {
+  const lines = [];
+  lines.push("# CLI Adapter Latency Benchmark Report");
+  lines.push("");
+  lines.push(`**Date:** ${result.timestamp}`);
+  lines.push(`**Duration:** ${result.totalDurationMs.toFixed(0)}ms`);
+  lines.push(`**Platform:** ${result.environment.platform} ${result.environment.arch}`);
+  lines.push(`**Node:** ${result.environment.nodeVersion}`);
+  lines.push(
+    `**CPU:** ${result.environment.cpuModel} (${String(result.environment.cpuCores)} cores)`
+  );
+  lines.push("");
+  lines.push(...formatScenarioTables(result.results));
+  lines.push(...formatTransportComparison(result.results));
+  lines.push("");
+  lines.push("---");
+  lines.push("*Generated by nexus-agents adapter-latency-benchmark*");
+  return lines.join("\n");
+}
+function toSuiteResult(result) {
+  const operations = result.results.map((r) => ({
+    operation: `${r.adapterName}/${r.scenario}`,
+    datasetSize: r.successCount + r.failureCount,
+    latency: r.latency,
+    throughput: {
+      opsPerSecond: r.latency.sampleCount > 0 ? r.latency.sampleCount / (r.latency.mean * r.latency.sampleCount) * 1e3 : 0,
+      totalOps: r.latency.sampleCount,
+      durationMs: r.latency.mean * r.latency.sampleCount
+    },
+    resources: {
+      peakMemoryBytes: 0,
+      avgMemoryBytes: 0,
+      cpuTimeMs: 0
+    },
+    timestamp: result.timestamp
+  }));
+  const totalDurationMs = operations.reduce((s, op) => s + op.throughput.durationMs, 0);
+  const totalOps = operations.reduce((s, op) => s + op.throughput.totalOps, 0);
+  const avgP95 = operations.length > 0 ? operations.reduce((s, op) => s + op.latency.p95, 0) / operations.length : 0;
+  return {
+    name: "CLI Adapter Latency",
+    component: "cli-adapters",
+    version: "1.0.0",
+    operations,
+    environment: result.environment,
+    summary: {
+      totalDurationMs,
+      totalOperations: totalOps,
+      overallThroughput: totalDurationMs > 0 ? totalOps / totalDurationMs * 1e3 : 0,
+      avgP95Latency: avgP95,
+      passed: true,
+      failures: []
+    }
+  };
+}
+
+// src/benchmarks/adapter.ts
+var NOOP_PROGRESS = () => {
+};
+
+// src/benchmarks/orchestrator.ts
+var DEFAULT_INSTANCE_TIMEOUT_MS = 3e5;
+async function runOneInstance(args) {
+  const prediction = await args.adapter.runInstance(args.instance, args.ctx);
+  const evalResult = await args.adapter.evaluate(args.instance, prediction);
+  args.state.results[args.idx] = evalResult;
+  args.state.completed++;
+  args.onProgress?.(args.state.completed, args.total);
+}
+async function runWorkerPool(args) {
+  const { adapter, instances, ctx, state, concurrency, onProgress } = args;
+  let next = 0;
+  const worker = async () => {
+    while (next < instances.length) {
+      const i = next++;
+      const instance = instances[i];
+      if (instance === void 0) continue;
+      try {
+        await runOneInstance({
+          adapter,
+          instance,
+          ctx,
+          state,
+          idx: i,
+          total: instances.length,
+          onProgress
+        });
+      } catch (e) {
+        state.failures.push(e);
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, instances.length) }, () => worker())
+  );
+}
+async function runBenchmark(adapter, config, options = {}) {
+  const concurrency = Math.max(1, options.concurrency ?? 1);
+  const instanceTimeoutMs = options.instanceTimeoutMs ?? DEFAULT_INSTANCE_TIMEOUT_MS;
+  const start = performance.now();
+  let instances = await adapter.loadInstances(config);
+  if (options.limit !== void 0 && options.limit < instances.length) {
+    instances = instances.slice(0, options.limit);
+  }
+  const state = {
+    results: new Array(instances.length),
+    failures: [],
+    completed: 0
+  };
+  const ctx = {
+    timeoutMs: instanceTimeoutMs,
+    ...options.signal !== void 0 ? { signal: options.signal } : {}
+  };
+  await runWorkerPool({
+    adapter,
+    instances,
+    ctx,
+    state,
+    concurrency,
+    onProgress: options.onProgress
+  });
+  const runTimeMs = Math.round(performance.now() - start);
+  const completedResults = state.results.filter((r) => r !== void 0);
+  const summary = adapter.summarize(completedResults, runTimeMs);
+  if (state.failures.length === 0) return summary;
+  return {
+    ...summary,
+    metadata: {
+      ...summary.metadata,
+      failureCount: state.failures.length,
+      sampleFailure: state.failures[0] instanceof Error ? state.failures[0].message : String(state.failures[0])
+    }
+  };
+}
+
+// src/pipeline/v1-adapters.ts
+import { randomUUID as randomUUID2 } from "crypto";
 function analysisToTaskContract(description, analysis) {
   const now = Date.now();
   return {
-    id: `task-${randomUUID().slice(0, 8)}`,
+    id: `task-${randomUUID2().slice(0, 8)}`,
     description,
     status: "intake",
     analysis: {
@@ -5468,7 +6432,7 @@ function matchesArtifactFilter(artifact, filter) {
 }
 
 // src/pipeline/feedback-subscriber.ts
-var logger4 = createLogger({ component: "FeedbackSubscriber" });
+var logger9 = createLogger({ component: "FeedbackSubscriber" });
 var VALID_CLIS = new Set(CLI_NAMES);
 function createFeedbackSubscriber(bus, store) {
   return bus.subscribe({ type: ["model.called", "stage.failed"] }, (event) => {
@@ -5476,7 +6440,7 @@ function createFeedbackSubscriber(bus, store) {
       handleEvent(event, store);
     } catch (error) {
       const msg = getErrorMessage(error);
-      logger4.warn("Feedback subscriber error", { error: msg });
+      logger9.warn("Feedback subscriber error", { error: msg });
     }
   });
 }
@@ -5522,7 +6486,7 @@ function normalizeCli(cli) {
   if (VALID_CLIS.has(cli)) {
     return cli;
   }
-  logger4.warn("Unknown CLI in event", { cli });
+  logger9.warn("Unknown CLI in event", { cli });
   return void 0;
 }
 
@@ -5587,10 +6551,10 @@ var GateCheckResultSchema = z17.object({
 });
 
 // src/pipeline/quality-pipeline.ts
-var logger5 = createLogger({ component: "quality-pipeline" });
+var logger10 = createLogger({ component: "quality-pipeline" });
 
 // src/pipeline/research-trigger.ts
-var logger6 = createLogger({ component: "research-trigger" });
+var logger11 = createLogger({ component: "research-trigger" });
 var DEFAULT_QUALITY_THRESHOLD = 7;
 var DEFAULT_MAX_TRIGGERS = 3;
 function parseDiscoveries(text) {
@@ -5622,7 +6586,7 @@ async function checkForResearchTriggers(config = {}) {
       `Use research_discover to find recent papers and repos about "${topic}". For each result, include: title, quality score (1-10), and source URL.`
     );
     if (!result.success) {
-      logger6.debug("Research trigger: expert unavailable", { error: result.error });
+      logger11.debug("Research trigger: expert unavailable", { error: result.error });
       return [];
     }
     const discoveries = parseDiscoveries(result.text);
@@ -5638,7 +6602,7 @@ Assess this research for applicability to nexus-agents.`,
       status: "pending"
     }));
     if (tasks.length > 0) {
-      logger6.info("Research triggers created", {
+      logger11.info("Research triggers created", {
         total: discoveries.length,
         qualified: qualified.length,
         triggered: tasks.length
@@ -5646,13 +6610,13 @@ Assess this research for applicability to nexus-agents.`,
     }
     return tasks;
   } catch (error) {
-    logger6.debug("Research trigger failed gracefully", { error: String(error) });
+    logger11.debug("Research trigger failed gracefully", { error: String(error) });
     return [];
   }
 }
 
 // src/pipeline/research-pipeline.ts
-var logger7 = createLogger({ component: "research-pipeline" });
+var logger12 = createLogger({ component: "research-pipeline" });
 
 // src/pipeline/iterative-consensus.ts
 var defaultLogger = createLogger({ component: "iterative-consensus" });
@@ -5773,7 +6737,7 @@ function filterBySeverity(results, minSeverity) {
 }
 
 // src/pipeline/dynamic-expert.ts
-var logger8 = createLogger({ component: "dynamic-expert" });
+var logger13 = createLogger({ component: "dynamic-expert" });
 var MAX_DYNAMIC_EXPERTS = 2;
 var DynamicExpertManager = class {
   experts = [];
@@ -5784,18 +6748,18 @@ var DynamicExpertManager = class {
   /** Create a new dynamic expert. Returns null if limit reached. */
   create(spec) {
     if (this.experts.length >= this.maxExperts) {
-      logger8.warn("Dynamic expert limit reached", {
+      logger13.warn("Dynamic expert limit reached", {
         limit: this.maxExperts,
         requested: spec.id
       });
       return null;
     }
     if (spec.id.trim() === "" || spec.name.trim() === "") {
-      logger8.warn("Invalid dynamic expert spec", { id: spec.id });
+      logger13.warn("Invalid dynamic expert spec", { id: spec.id });
       return null;
     }
     if (this.experts.some((e) => e.spec.id === spec.id)) {
-      logger8.warn("Duplicate dynamic expert ID", { id: spec.id });
+      logger13.warn("Duplicate dynamic expert ID", { id: spec.id });
       return null;
     }
     const expert = {
@@ -5804,7 +6768,7 @@ var DynamicExpertManager = class {
       promoted: false
     };
     this.experts.push(expert);
-    logger8.info("Dynamic expert created", {
+    logger13.info("Dynamic expert created", {
       id: spec.id,
       name: spec.name,
       total: this.experts.length,
@@ -5831,7 +6795,7 @@ var DynamicExpertManager = class {
 };
 
 // src/replay/replay-executor.ts
-var logger9 = createLogger({ component: "ReplayExecutor" });
+var logger14 = createLogger({ component: "ReplayExecutor" });
 export {
   ALLOWED_COMMANDS,
   ARTIFACT_TYPES,
@@ -5944,6 +6908,8 @@ export {
   CrossTreeStrategySchema,
   DECEPTION_CATEGORY,
   DEFAULT_ACTIVATION_OPTIONS,
+  DEFAULT_ADAPTER_LATENCY_CONFIG,
+  DEFAULT_BENCHMARK_CONFIG,
   DEFAULT_BUDGET,
   DEFAULT_COLLECT_STREAM_MAX_CHUNKS,
   DEFAULT_COMPOSER_CONFIG,
@@ -5959,6 +6925,7 @@ export {
   DEFAULT_HARNESS_EXECUTION_CONFIG,
   DEFAULT_HIGHER_ORDER_CONFIG,
   DEFAULT_MAX_RETRIES,
+  DEFAULT_MEMORY_BENCHMARK_CONFIG,
   DEFAULT_OUTCOME_STORAGE_CONFIG,
   DEFAULT_PATCH_OPTIONS,
   DEFAULT_PATH_SCORING_OPTIONS,
@@ -5970,6 +6937,7 @@ export {
   DEFAULT_RESOURCE_LIMITS,
   DEFAULT_RETRY_CONFIG,
   DEFAULT_ROLE_MAPPINGS,
+  DEFAULT_SCENARIOS,
   DEFAULT_SKILL_LIBRARY_CONFIG,
   DEFAULT_SKILL_LOADER_CONFIG,
   DEFAULT_STATISTICAL_OPTIONS,
@@ -6075,6 +7043,7 @@ export {
   IssueTriageInputSchema,
   JsonDashboardRenderer,
   KNOWN_SECTIONS,
+  LatencySampler,
   ListExpertsInputSchema,
   ListWorkflowsInputSchema,
   LoadedSkillSetSchema,
@@ -6083,6 +7052,7 @@ export {
   MANIPULATION_CATEGORY,
   MAX_DYNAMIC_EXPERTS,
   MAX_EXECUTION_TIME_MS,
+  MEM0_TARGETS,
   MIN_EXPERTS_FOR_PATTERN,
   MODEL_CAPABILITIES,
   RateLimiter as McpRateLimiter,
@@ -6096,6 +7066,7 @@ export {
   ModelSelectionSchema,
   ModelTiersSchema,
   NOOP_NOTIFIER,
+  NOOP_PROGRESS,
   NexusAgentExecutor,
   NexusError,
   NoAdapterError,
@@ -6369,6 +7340,7 @@ export {
   calculateRepositoryMetrics,
   calculateRoutingDistribution,
   calculateTokenCost,
+  calculateTokenMetrics,
   calculateVoteWeight,
   calculateWinLoss,
   canApplyPatch,
@@ -6394,6 +7366,7 @@ export {
   closeServer,
   collectRealVotes,
   collectStream,
+  compareBenchmarks,
   compareProportions,
   compilePipelineGraph,
   compilePlan,
@@ -6414,6 +7387,7 @@ export {
   createAuditLogger,
   createAuditTrail,
   createBenchmarkMemory,
+  createBenchmarkSummary,
   createCheckpoint,
   createCheckpointStore,
   createClaudeAdapter,
@@ -6430,6 +7404,7 @@ export {
   createCorrelationTracker,
   createDashboard,
   createDashboardRenderer,
+  createDecayOp,
   createDefaultDeps,
   createDefaultPolicyEngine,
   createDefaultPolicyFirewall,
@@ -6484,6 +7459,7 @@ export {
   createPreferenceRouter,
   createProductionWorkflowEngine,
   createProgressAdapter,
+  createPromotionOp,
   createProtocolFactory,
   createRateLimiter,
   createRealWorkflowEngine,
@@ -6560,6 +7536,7 @@ export {
   emitTrendDetected,
   emitTrustEvent,
   err,
+  estimateTokens2 as estimateBenchmarkTokens,
   estimateDifficulty,
   estimateTaskComplexity,
   estimateTokens,
@@ -6601,11 +7578,16 @@ export {
   findActiveSession,
   findMissingDependencies,
   flushPipelineMemory,
+  formatAdapterLatencyReport,
+  formatBenchmarkReport,
+  formatBenchmarkResults,
+  formatComparisonResults,
   formatCompileError,
   formatContextForPrompt,
   formatValidationResult,
   fromArray,
   generateATL,
+  generateBenchmarkReport,
   generateMcpConfig,
   generateProposalId,
   generateReport,
@@ -6615,6 +7597,7 @@ export {
   getAvailabilityCache,
   getAvailableClis,
   getAvailableRoles,
+  getBenchmarkEnvironment,
   getBuiltInTemplates,
   getBuiltInTemplatesPath,
   getBuiltInTemplatesWithMetadata,
@@ -6776,16 +7759,22 @@ export {
   resolveV2Config,
   resolveWithFallbacks,
   resultToOutcome,
+  runAdapterLatencyBenchmark,
   runAdaptiveOrchestrator,
   runAgentOnInstance,
+  runBenchmark,
   runBenchmarkInstances,
   runBenchmarkParallel,
+  runConsolidationBenchmark,
   runDevPipeline,
   runGraphPipeline,
   runIterativeConsensus,
+  runMemoryBenchmarks,
+  runOperationBenchmark,
   runPreconditions,
   runSingleInstance,
   runTests,
+  runTokenBenchmark,
   runVerification,
   safePathsRule,
   safeValidateExpertConfig,
@@ -6810,6 +7799,7 @@ export {
   takeUntil,
   tapStream,
   taskContractToToolResponse,
+  toSuiteResult,
   toolError,
   toolSuccess,
   toolSuccessStructured,