create-walle 0.9.21 → 0.9.23

package/template/wall-e/eval/run-model-comparison.js

@@ -1,142 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Compare all available Ollama models on agent-001 (simplest benchmark).
- * Records per-model performance data for model-task affinity learning.
- */
-
-const path = require('path');
-process.chdir(path.join(__dirname, '..'));
-
-const { setupSandbox, cleanupSandbox, scoreAgentResult } = require('./agent-runner');
-const { execFileSync } = require('child_process');
-const benchmarks = require('./benchmarks/coding-agent.json');
-
-const MODELS = ['gemma4:e4b', 'qwen2.5:7b-instruct-q4_K_M', 'phi4:latest', 'llama3.1:8b-instruct-q4_K_M'];
-const BENCH_ID = process.argv[2] || 'agent-001';
-
-async function runWithModel(bench, modelName) {
-  const fixtureName = bench.agentExpectations?.projectFixture || 'express-basic';
-  const sandboxDir = setupSandbox(fixtureName);
-
-  try {
-    const { runAgentLoop } = require('../coding-orchestrator');
-    const start = Date.now();
-
-    const result = await runAgentLoop(bench.prompt, {
-      cwd: sandboxDir,
-      timeoutMs: 180000,
-      model: modelName,
-      mode: 'build',
-      persistTranscript: false,
-    });
-
-    const latencyMs = Date.now() - start;
-
-    // Extract tool calls from log
-    const toolCalls = [];
-    for (const entry of (result.log || [])) {
-      for (const tc of (entry.toolCalls || [])) {
-        toolCalls.push(tc.name);
-      }
-    }
-
-    // Check modified files
-    let modifiedFiles = [];
-    try {
-      const diff = execFileSync('git', ['diff', '--name-only', 'HEAD'], { cwd: sandboxDir, encoding: 'utf8' });
-      const untracked = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { cwd: sandboxDir, encoding: 'utf8' });
-      modifiedFiles = [...diff.trim().split('\n'), ...untracked.trim().split('\n')].filter(Boolean);
-    } catch {}
-
-    // Run tests
-    let testsPassed = null;
-    if (bench.agentExpectations?.testCommand === 'npm test') {
-      try {
-        execFileSync('node', ['test.js'], { cwd: sandboxDir, timeout: 10000, stdio: 'pipe' });
-        testsPassed = true;
-      } catch { testsPassed = false; }
-    }
-
-    const score = scoreAgentResult(bench, {
-      actualToolCalls: toolCalls,
-      actualFileChanges: modifiedFiles,
-      actualTurns: (result.log || []).length,
-      testsPassed,
-      output: result.output || '',
-      success: result.success,
-    });
-
-    return {
-      model: modelName,
-      success: result.success,
-      score,
-      latencyMs,
-      turns: (result.log || []).length,
-      toolCalls,
-      uniqueTools: [...new Set(toolCalls)],
-      modifiedFiles,
-      testsPassed,
-      error: result.stderr || null,
-    };
-  } catch (err) {
-    return { model: modelName, success: false, score: { composite: 0 }, error: err.message, latencyMs: Date.now() - start };
-  } finally {
-    cleanupSandbox(sandboxDir);
-  }
-}
-
-async function main() {
-  const bench = benchmarks.find(b => b.id === BENCH_ID);
-  if (!bench) { console.error(`No benchmark: ${BENCH_ID}`); process.exit(1); }
-
-  console.log(`=== Model Comparison: ${bench.id} (${bench.difficulty}) ===`);
-  console.log(`Prompt: ${bench.prompt.slice(0, 100)}...\n`);
-
-  const results = [];
-  for (const model of MODELS) {
-    console.log(`--- ${model} ---`);
-    const r = await runWithModel(bench, model);
-    results.push(r);
-
-    console.log(`  Score: ${(r.score?.composite || 0).toFixed(3)} | Success: ${r.success} | Turns: ${r.turns || 0} | Time: ${((r.latencyMs || 0) / 1000).toFixed(1)}s`);
-    if (r.score?.dimensions) {
-      const d = r.score.dimensions;
-      console.log(`  Tool eff: ${(d.toolEfficiency || 0).toFixed(2)} | Correct: ${(d.correctness || 0).toFixed(2)} | Plan: ${(d.planQuality || 0).toFixed(2)} | Turns: ${(d.turnEconomy || 0).toFixed(2)} | Error: ${(d.errorHandling || 0).toFixed(2)}`);
-    }
-    console.log(`  Tools: ${(r.uniqueTools || []).join(', ') || 'none'}`);
-    console.log(`  Files: ${(r.modifiedFiles || []).join(', ') || 'none'}`);
-    if (r.error) console.log(`  Error: ${r.error.slice(0, 200)}`);
-    console.log('');
-  }
-
-  // Summary table
-  console.log('=== LEADERBOARD ===');
-  results.sort((a, b) => (b.score?.composite || 0) - (a.score?.composite || 0));
-  console.log('Rank | Model                         | Score | Time   | Tools | Files');
-  console.log('-----|-------------------------------|-------|--------|-------|------');
-  results.forEach((r, i) => {
-    console.log(`  ${i + 1}  | ${r.model.padEnd(29)} | ${(r.score?.composite || 0).toFixed(3)} | ${((r.latencyMs || 0) / 1000).toFixed(1).padStart(5)}s | ${(r.toolCalls || []).length.toString().padStart(5)} | ${(r.modifiedFiles || []).length}`);
-  });
-
-  // Record to brain if available
-  try {
-    const brain = require('../brain');
-    brain.initDb();
-    for (const r of results) {
-      if (typeof brain.insertModelEvaluation === 'function') {
-        brain.insertModelEvaluation({
-          modelRegistryId: r.model,
-          taskType: 'coding-agent',
-          qualityScore: r.score?.composite || 0,
-          latencyMs: r.latencyMs,
-          wasSelected: false,
-        });
-      }
-    }
-    console.log('\nResults saved to brain.');
-  } catch {}
-}
-
-main().catch(err => { console.error('Fatal:', err); process.exit(1); });

package/template/wall-e/eval/session-evaluator.js

@@ -1,187 +0,0 @@
-'use strict';
-
-const { computeAgentScore } = require('./agent-scorer');
-
-/**
- * Evaluate a completed coding session.
- * Called after the agent loop finishes to score the session.
- *
- * @param {object} sessionData - From the agent loop
- * @param {string} sessionData.sessionId
- * @param {string} sessionData.prompt - Original user request
- * @param {Array} sessionData.toolCalls - Tool calls made
- * @param {number} sessionData.turns - Total turns used
- * @param {Array} sessionData.filesModified - Files changed
- * @param {boolean} sessionData.success - Whether task completed
- * @param {string} sessionData.output - Final output text
- * @param {boolean} [sessionData.testsPassed] - Test results
- * @param {number} [sessionData.consecutiveErrors] - Error count
- * @param {object} options
- * @param {object} options.brain - Brain instance for storage
- * @param {string} [options.model] - Model used
- * @returns {object} Evaluation result with scores
- */
-async function evaluateSession(sessionData, options = {}) {
-  const { brain, model } = options;
-
-  const toolCallNames = (sessionData.toolCalls || []).map(t =>
-    typeof t === 'string' ? t : t.name || ''
-  ).filter(Boolean);
-
-  // Compute multi-dimensional score
-  const score = computeAgentScore({
-    actualToolCalls: toolCallNames,
-    testsPassed: sessionData.testsPassed ?? null,
-    success: sessionData.success || false,
-    output: sessionData.output || '',
-    actualFiles: sessionData.filesModified || [],
-    actualTurns: sessionData.turns || 0,
-    maxTurns: 50,
-    consecutiveErrors: sessionData.consecutiveErrors || 0,
-  });
-
-  // Classify the session type
-  const classifiedType = classifySessionType(sessionData.prompt, toolCallNames);
-
-  // Build evaluation result
-  const evaluation = {
-    sessionId: sessionData.sessionId,
-    prompt: sessionData.prompt,
-    model: model || 'unknown',
-    classifiedType,
-    score,
-    toolCallCount: toolCallNames.length,
-    uniqueToolCount: new Set(toolCallNames).size,
-    turns: sessionData.turns || 0,
-    filesModified: sessionData.filesModified || [],
-    success: sessionData.success || false,
-    testsPassed: sessionData.testsPassed ?? null,
-    timestamp: new Date().toISOString(),
-  };
-
-  // Store in brain if available
-  if (brain) {
-    try {
-      // Store as coding agent session
-      if (typeof brain.insertCodingSession === 'function') {
-        brain.insertCodingSession({
-          id: sessionData.sessionId,
-          session_id: sessionData.sessionId,
-          prompt: sessionData.prompt || '',
-          tool_calls: JSON.stringify(toolCallNames),
-          turns: sessionData.turns || 0,
-          files_modified: JSON.stringify(sessionData.filesModified || []),
-          git_committed: sessionData.gitCommitted ? 1 : 0,
-          git_diff: sessionData.gitDiff || null,
-          significance_score: score.composite,
-          classified_type: classifiedType,
-        });
-      }
-
-      // Also record model evaluation for the learner
-      if (typeof brain.insertModelEvaluation === 'function') {
-        brain.insertModelEvaluation({
-          modelRegistryId: model || 'coding-orchestrator',
-          taskType: classifiedType,
-          qualityScore: score.composite,
-          latencyMs: sessionData.latencyMs || null,
-          inputTokens: sessionData.inputTokens || null,
-          outputTokens: sessionData.outputTokens || null,
-          wasSelected: true,
-        });
-      }
-    } catch (err) {
-      console.warn('[session-evaluator] Storage failed:', err.message);
-    }
-  }
-
-  // Generate learning insights
-  const insights = generateInsights(evaluation);
-
-  return { evaluation, insights };
-}
-
-/**
- * Classify session type from prompt and tool usage.
- */
-function classifySessionType(prompt, toolCalls) {
-  const p = (prompt || '').toLowerCase();
-
-  if (/plan|design|architect/i.test(p)) return 'coding:planning';
-  if (/debug|fix|bug|error|failing/i.test(p)) return 'coding:debugging';
-  if (/refactor|extract|rename|reorganize|clean/i.test(p)) return 'coding:refactoring';
-  if (/test|spec|coverage/i.test(p)) return 'coding:testing';
-  if (/review|assess|check|audit/i.test(p)) return 'coding:review';
-
-  // Classify by dominant tool usage
-  const genTools = toolCalls.filter(t => /write_file|edit_file|apply_patch/.test(t));
-  const readTools = toolCalls.filter(t => /read_file|glob|grep/.test(t));
-
-  if (genTools.length === 0 && readTools.length > 3) return 'coding:exploration';
-  return 'coding:generation';
-}
-
-/**
- * Generate learning insights from evaluation results.
- * These can be stored as brain memories for future reference.
- */
-function generateInsights(evaluation) {
-  const insights = [];
-  const { score, classifiedType, model, turns } = evaluation;
-
-  if (score.composite >= 0.8) {
-    insights.push({
-      type: 'positive',
-      content: `Model ${model} performed well on ${classifiedType} (score ${score.composite.toFixed(2)}, ${turns} turns)`,
-    });
-  }
-
-  if (score.dimensions.toolEfficiency < 0.5) {
-    insights.push({
-      type: 'improvement',
-      content: `Tool efficiency was low (${score.dimensions.toolEfficiency.toFixed(2)}) for ${classifiedType} - consider tool selection optimization`,
-    });
-  }
-
-  if (score.dimensions.turnEconomy < 0.3) {
-    insights.push({
-      type: 'improvement',
-      content: `Turn economy was poor (${turns} turns) for ${classifiedType} - task may need better planning phase`,
-    });
-  }
-
-  if (score.dimensions.errorHandling < 0.5) {
-    insights.push({
-      type: 'warning',
-      content: `Error handling issues detected in ${classifiedType} session - possible doom loop or repeated failures`,
-    });
-  }
-
-  return insights;
-}
-
-/**
- * Store learning insights as brain memories.
- */
-async function storeInsights(brain, insights) {
-  if (!brain || !insights || insights.length === 0) return;
-  if (typeof brain.addMemory !== 'function') return;
-
-  for (const insight of insights) {
-    try {
-      brain.addMemory({
-        source: 'coding-agent-eval',
-        type: 'learning',
-        content: insight.content,
-        importance: insight.type === 'warning' ? 0.8 : 0.5,
-      });
-    } catch { /* non-fatal */ }
-  }
-}
-
-module.exports = {
-  evaluateSession,
-  classifySessionType,
-  generateInsights,
-  storeInsights,
-};

package/template/wall-e/eval/session-miner.js

@@ -1,207 +0,0 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const { sessionToBenchmark } = require('./benchmark-generator');
-
-const BENCHMARKS_PATH = path.join(__dirname, 'benchmarks', 'coding-agent.json');
-const MAX_PER_WEEK_DEFAULT = 5;
-const MIN_SIGNIFICANCE = 0.7;
-
-/**
- * Load existing benchmark IDs from the coding-agent.json file.
- * @returns {Set<string>}
- */
-function loadExistingIds() {
-  const ids = new Set();
-  try {
-    const existing = JSON.parse(fs.readFileSync(BENCHMARKS_PATH, 'utf8'));
-    for (const b of existing) ids.add(b.id);
-  } catch { /* file missing or parse error */ }
-  return ids;
-}
-
-/**
- * Count how many benchmarks were generated in the current week (Mon-Sun).
- * Checks created_at timestamps of recently converted sessions.
- * @param {object} brain
- * @returns {number}
- */
-function countGeneratedThisWeek(brain) {
-  const now = new Date();
-  // Get Monday 00:00 of the current week
-  const day = now.getDay();
-  const diffToMonday = day === 0 ? 6 : day - 1;
-  const monday = new Date(now);
-  monday.setDate(now.getDate() - diffToMonday);
-  monday.setHours(0, 0, 0, 0);
-  const weekStart = monday.toISOString();
-
-  // Query sessions that were already converted (benchmark_generated = 1)
-  // and created this week. This is approximate — we use created_at as proxy
-  // since we don't track "converted_at" separately.
-  const sessions = brain.getCodingSessions({ minSignificance: MIN_SIGNIFICANCE, limit: 200 });
-  return sessions.filter(s => s.benchmark_generated && s.created_at >= weekStart).length;
-}
-
-/**
- * Pick a balanced subset of candidates across classified_type categories.
- * Distributes evenly, cycling through types until budget is exhausted.
- * @param {Array} candidates - session objects
- * @param {number} budget - max to pick
- * @returns {Array}
- */
-function pickBalanced(candidates, budget) {
-  if (candidates.length <= budget) return candidates;
-
-  // Group by classified_type
-  const groups = {};
-  for (const c of candidates) {
-    const type = c.classified_type || 'unknown';
-    if (!groups[type]) groups[type] = [];
-    groups[type].push(c);
-  }
-
-  const picked = [];
-  const types = Object.keys(groups);
-  let round = 0;
-
-  while (picked.length < budget) {
-    let addedAny = false;
-    for (const type of types) {
-      if (picked.length >= budget) break;
-      if (round < groups[type].length) {
-        picked.push(groups[type][round]);
-        addedAny = true;
-      }
-    }
-    if (!addedAny) break;
-    round++;
-  }
-
-  return picked;
-}
-
-/**
- * Mine high-significance coding sessions and generate benchmarks.
- *
- * @param {object} brain - Brain module instance
- * @param {object} opts
- * @param {boolean} opts.dryRun - If true, don't write files or mark sessions
- * @param {number} opts.maxPerWeek - Weekly cap (default 5)
- * @returns {{ candidates: Array, generated: Array, skipped: Array }}
- */
-async function mineAndGenerate(brain, { dryRun = false, maxPerWeek = MAX_PER_WEEK_DEFAULT } = {}) {
-  // 1. Check weekly budget
-  const usedThisWeek = countGeneratedThisWeek(brain);
-  const remaining = Math.max(0, maxPerWeek - usedThisWeek);
-
-  if (remaining === 0) {
-    return { candidates: [], generated: [], skipped: [], reason: 'weekly cap reached' };
-  }
-
-  // 2. Get high-significance unconverted sessions
-  const sessions = brain.getCodingSessions({ minSignificance: MIN_SIGNIFICANCE, limit: 100 });
-  const unconverted = sessions.filter(s => !s.benchmark_generated);
-
-  if (unconverted.length === 0) {
-    return { candidates: [], generated: [], skipped: [], reason: 'no unconverted sessions' };
-  }
-
-  // 3. Group by classified_type, pick balanced subset
-  const candidates = pickBalanced(unconverted, remaining);
-
-  // 4. Generate benchmarks
-  const existingIds = loadExistingIds();
-  const generated = [];
-  const skipped = [];
-
-  for (const session of candidates) {
-    const benchmark = sessionToBenchmark(session, existingIds);
-    if (benchmark) {
-      generated.push(benchmark);
-      existingIds.add(benchmark.id);
-    } else {
-      skipped.push({ id: session.id, reason: 'duplicate' });
-    }
-  }
-
-  // 5. Persist if not dry-run
-  if (!dryRun && generated.length > 0) {
-    // Append to existing benchmarks file
-    let existing = [];
-    try {
-      existing = JSON.parse(fs.readFileSync(BENCHMARKS_PATH, 'utf8'));
-    } catch { /* start fresh */ }
-
-    existing.push(...generated);
-    fs.mkdirSync(path.dirname(BENCHMARKS_PATH), { recursive: true });
-    fs.writeFileSync(BENCHMARKS_PATH, JSON.stringify(existing, null, 2) + '\n');
-
-    // Mark sessions as converted
-    for (const session of candidates) {
-      // Only mark if benchmark was actually generated (not skipped)
-      if (generated.some(b => b.sourceSessionId === session.session_id)) {
-        brain.markBenchmarkGenerated(session.id);
-      }
-    }
-  }
-
-  return { candidates, generated, skipped };
-}
-
-// CLI mode
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const dryRun = args.includes('--dry-run');
-  const maxPerWeek = (() => {
-    const idx = args.indexOf('--max');
-    return idx >= 0 && args[idx + 1] ? parseInt(args[idx + 1], 10) : MAX_PER_WEEK_DEFAULT;
-  })();
-
-  (async () => {
-    // Initialize brain
-    let brain;
-    try {
-      brain = require('../brain');
-      brain.initDb();
-    } catch (err) {
-      console.error('Failed to initialize brain:', err.message);
-      process.exit(1);
-    }
-
-    console.log(`Session Miner ${dryRun ? '(DRY RUN)' : ''}`);
-    console.log(`  Max per week: ${maxPerWeek}`);
-    console.log('');
-
-    const result = await mineAndGenerate(brain, { dryRun, maxPerWeek });
-
-    if (result.reason) {
-      console.log(`Skipped: ${result.reason}`);
-      return;
-    }
-
-    console.log(`Candidates: ${result.candidates.length}`);
-    console.log(`Generated:  ${result.generated.length}`);
-    console.log(`Skipped:    ${result.skipped.length}`);
-
-    if (result.generated.length > 0) {
-      console.log('\nGenerated benchmarks:');
-      for (const b of result.generated) {
-        console.log(`  - ${b.id} [${b.classifiedType}] ${b.difficulty} (${b.complexityIndicator} files)`);
-        if (b.expectedDiff) console.log(`    has golden diff: ${b.expectedDiff.length} chars`);
-      }
-    }
-
-    if (result.skipped.length > 0) {
-      console.log('\nSkipped:');
-      for (const s of result.skipped) {
-        console.log(`  - ${s.id}: ${s.reason}`);
-      }
-    }
-  })().catch(err => {
-    console.error(err);
-    process.exit(1);
-  });
-}
-
-module.exports = { mineAndGenerate };

package/template/wall-e/eval/session-retrieval-benchmark.js

@@ -1,150 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const brainDefault = require('../brain');
-const { indexMemory } = require('../memory/source-indexer');
-
-const DEFAULT_CASES_PATH = path.join(__dirname, 'benchmarks', 'memory-retrieval.json');
-
-function loadMemoryRetrievalCases(filePath = DEFAULT_CASES_PATH) {
-  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  return Array.isArray(parsed) ? parsed : [];
-}
-
-function seedBenchmarkMemories({ brain = brainDefault, cases = [] } = {}) {
-  let inserted = 0;
-  let indexed = 0;
-  for (const bench of cases) {
-    const memories = bench.retrieval?.seedMemories || [];
-    for (const seed of memories) {
-      const result = brain.insertMemory({
-        source: seed.source || 'codex-jsonl',
-        source_id: seed.source_id,
-        source_channel: seed.cwd || '',
-        memory_type: seed.memory_type || 'coding_session_exchange',
-        direction: seed.direction || 'exchange',
-        subject: seed.subject || seed.source_id,
-        content: seed.content,
-        content_raw: seed.content,
-        metadata: JSON.stringify(seed.metadata || {}),
-        importance: seed.importance ?? 0.7,
-        timestamp: seed.timestamp || new Date().toISOString(),
-      });
-      if (!result) continue;
-      inserted++;
-      indexMemory({
-        ...seed,
-        id: result.id,
-        source: seed.source || 'codex-jsonl',
-        source_id: seed.source_id,
-        source_channel: seed.cwd || '',
-        memory_type: seed.memory_type || 'coding_session_exchange',
-        content: seed.content,
-        metadata: JSON.stringify(seed.metadata || {}),
-        timestamp: seed.timestamp || new Date().toISOString(),
-      }, { brain });
-      indexed++;
-    }
-  }
-  return { inserted, indexed };
-}
-
-function searchRetrievalCase({ brain = brainDefault, query, limit = 10 } = {}) {
-  const max = Math.min(Math.max(Number(limit) || 10, 1), 50);
-  const direct = brain.searchMemories({ query, limit: max * 3 });
-  let indexed = [];
-  try {
-    const rows = brain.searchMemoryIndex({ query, limit: max * 3 });
-    indexed = hydrateIndexRows(brain, rows);
-  } catch {}
-  return mergeById(direct, indexed).slice(0, max);
-}
-
-function scoreRetrievalCase(bench, results, { ks = [5, 10] } = {}) {
-  const expected = new Set(bench.retrieval?.expectedSourceIds || []);
-  const sourceIds = results.map(resultSourceId);
-  const out = {
-    id: bench.id,
-    query: bench.retrieval?.query || '',
-    expected: [...expected],
-    returned: sourceIds,
-  };
-  for (const k of ks) {
-    out[`hit_at_${k}`] = sourceIds.slice(0, k).some((id) => expected.has(id));
-  }
-  return out;
-}
-
-function runMemoryRetrievalBenchmark({ brain = brainDefault, cases = loadMemoryRetrievalCases(), seed = false, limit = 10 } = {}) {
-  if (seed) seedBenchmarkMemories({ brain, cases });
-  const results = [];
-  for (const bench of cases) {
-    const query = bench.retrieval?.query || bench.prompt || '';
-    const hits = searchRetrievalCase({ brain, query, limit });
-    results.push(scoreRetrievalCase(bench, hits));
-  }
-  return summarizeRetrievalResults(results);
-}
-
-function summarizeRetrievalResults(results) {
-  const total = results.length || 1;
-  const hitAt5 = results.filter((result) => result.hit_at_5).length;
-  const hitAt10 = results.filter((result) => result.hit_at_10).length;
-  return {
-    total: results.length,
-    recall_at_5: hitAt5 / total,
-    recall_at_10: hitAt10 / total,
-    results,
-  };
-}
-
-function hydrateIndexRows(brain, rows) {
-  if (!rows?.length) return [];
-  const ids = [...new Set(rows.map((row) => row.memory_id).filter(Boolean))];
-  if (!ids.length) return [];
-  const placeholders = ids.map(() => '?').join(',');
-  return brain.getDb().prepare(`
-    SELECT * FROM memories
-    WHERE archived_at IS NULL AND id IN (${placeholders})
-  `).all(...ids);
-}
-
-function mergeById(...groups) {
-  const seen = new Set();
-  const merged = [];
-  for (const group of groups) {
-    for (const item of group || []) {
-      if (!item?.id || seen.has(item.id)) continue;
-      seen.add(item.id);
-      merged.push(item);
-    }
-  }
-  return merged;
-}
-
-function resultSourceId(result = {}) {
-  try {
-    const metadata = JSON.parse(result.metadata || '{}');
-    if (metadata?.sourceId) return metadata.sourceId;
-  } catch {}
-  const sourceId = String(result.source_id || '');
-  const parts = sourceId.split(':');
-  return parts.length > 2 ? parts.slice(0, 2).join(':') : sourceId;
-}
-
-if (require.main === module) {
-  brainDefault.initDb();
-  const summary = runMemoryRetrievalBenchmark({ seed: process.argv.includes('--seed') });
-  console.log(JSON.stringify(summary, null, 2));
-}
-
-module.exports = {
-  loadMemoryRetrievalCases,
-  resultSourceId,
-  runMemoryRetrievalBenchmark,
-  scoreRetrievalCase,
-  searchRetrievalCase,
-  seedBenchmarkMemories,
-  summarizeRetrievalResults,
-};