@stackmemoryai/stackmemory 1.6.0 → 1.6.1

package/scripts/gepa/hooks/auto-optimize.js

@@ -1,494 +0,0 @@
-#!/usr/bin/env node
-/**
- * GEPA Auto-Optimizer
- *
- * Watches CLAUDE.md for changes and automatically runs optimization.
- * Shows before/after comparison with metrics.
- *
- * Usage:
- *   node auto-optimize.js watch [path]     # Watch and auto-optimize
- *   node auto-optimize.js compare [a] [b]  # Compare two versions
- *   node auto-optimize.js report           # Show optimization report
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { execSync, spawn } from 'child_process';
-import crypto from 'crypto';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const GEPA_DIR = path.join(__dirname, '..');
-const GENERATIONS_DIR = path.join(GEPA_DIR, 'generations');
-const RESULTS_DIR = path.join(GEPA_DIR, 'results');
-
-// ANSI colors
-const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  bgGreen: '\x1b[42m',
-  bgRed: '\x1b[41m',
-  bgYellow: '\x1b[43m',
-};
-
-/**
- * Calculate content hash for change detection
- */
-function hashContent(content) {
-  return crypto.createHash('md5').update(content).digest('hex').slice(0, 8);
-}
-
-/**
- * Analyze markdown structure
- */
-function analyzeMarkdown(content) {
-  const lines = content.split('\n');
-
-  return {
-    totalLines: lines.length,
-    totalChars: content.length,
-    estimatedTokens: Math.ceil(content.length / 4),
-
-    // Structure
-    h1Count: (content.match(/^# /gm) || []).length,
-    h2Count: (content.match(/^## /gm) || []).length,
-    h3Count: (content.match(/^### /gm) || []).length,
-
-    // Content types
-    codeBlocks: (content.match(/```/g) || []).length / 2,
-    bulletPoints: (content.match(/^[-*] /gm) || []).length,
-    numberedLists: (content.match(/^\d+\. /gm) || []).length,
-
-    // Keywords (instruction density)
-    mustCount: (content.match(/\bMUST\b/gi) || []).length,
-    neverCount: (content.match(/\bNEVER\b/gi) || []).length,
-    alwaysCount: (content.match(/\bALWAYS\b/gi) || []).length,
-    importantCount: (content.match(/\bIMPORTANT\b/gi) || []).length,
-
-    // Sections
-    sections: [...content.matchAll(/^##+ (.+)$/gm)].map((m) => m[1]),
-  };
-}
-
-/**
- * Format comparison table
- */
-function formatComparison(before, after, label = 'Metric') {
-  const metrics = [
-    ['Lines', before.totalLines, after.totalLines],
-    ['Characters', before.totalChars, after.totalChars],
-    ['Est. Tokens', before.estimatedTokens, after.estimatedTokens],
-    ['H2 Sections', before.h2Count, after.h2Count],
-    ['Code Blocks', before.codeBlocks, after.codeBlocks],
-    ['Bullet Points', before.bulletPoints, after.bulletPoints],
-    ['MUST rules', before.mustCount, after.mustCount],
-    ['NEVER rules', before.neverCount, after.neverCount],
-    ['ALWAYS rules', before.alwaysCount, after.alwaysCount],
-  ];
-
-  console.log(
-    `\n${c.bold}${c.cyan}╔════════════════════════════════════════════════════════════╗${c.reset}`
-  );
-  console.log(
-    `${c.bold}${c.cyan}║${c.reset}  ${c.bold}BEFORE / AFTER COMPARISON${c.reset}                                  ${c.cyan}║${c.reset}`
-  );
-  console.log(
-    `${c.cyan}╠════════════════════════════════════════════════════════════╣${c.reset}`
-  );
-  console.log(
-    `${c.cyan}║${c.reset}  ${c.dim}Metric${c.reset}              ${c.dim}Before${c.reset}      ${c.dim}After${c.reset}       ${c.dim}Change${c.reset}      ${c.cyan}║${c.reset}`
-  );
-  console.log(
-    `${c.cyan}╠════════════════════════════════════════════════════════════╣${c.reset}`
-  );
-
-  metrics.forEach(([name, b, a]) => {
-    const diff = a - b;
-    const pct = b > 0 ? ((diff / b) * 100).toFixed(0) : '∞';
-    const sign = diff > 0 ? '+' : '';
-    const color = diff > 0 ? c.green : diff < 0 ? c.red : c.dim;
-
-    const nameStr = name.padEnd(18);
-    const beforeStr = String(b).padStart(8);
-    const afterStr = String(a).padStart(8);
-    const changeStr = `${sign}${diff} (${sign}${pct}%)`.padStart(12);
-
-    console.log(
-      `${c.cyan}║${c.reset}  ${nameStr}  ${beforeStr}  ${c.bold}${afterStr}${c.reset}  ${color}${changeStr}${c.reset}  ${c.cyan}║${c.reset}`
-    );
-  });
-
-  console.log(
-    `${c.cyan}╚════════════════════════════════════════════════════════════╝${c.reset}`
-  );
-}
-
-/**
- * Show section diff
- */
-function showSectionDiff(before, after) {
-  const beforeSections = new Set(before.sections);
-  const afterSections = new Set(after.sections);
-
-  const added = after.sections.filter((s) => !beforeSections.has(s));
-  const removed = before.sections.filter((s) => !afterSections.has(s));
-  const kept = before.sections.filter((s) => afterSections.has(s));
-
-  if (added.length || removed.length) {
-    console.log(`\n${c.bold}Section Changes:${c.reset}`);
-
-    if (removed.length) {
-      console.log(`${c.red}  Removed:${c.reset}`);
-      removed.forEach((s) => console.log(`${c.red}    - ${s}${c.reset}`));
-    }
-
-    if (added.length) {
-      console.log(`${c.green}  Added:${c.reset}`);
-      added.forEach((s) => console.log(`${c.green}    + ${s}${c.reset}`));
-    }
-  }
-}
-
-/**
- * Show inline diff (simplified)
- */
-function showInlineDiff(beforeContent, afterContent) {
-  const beforeLines = beforeContent.split('\n');
-  const afterLines = afterContent.split('\n');
-
-  console.log(`\n${c.bold}Key Changes (first 20 diffs):${c.reset}`);
-  console.log(c.dim + '─'.repeat(60) + c.reset);
-
-  let diffCount = 0;
-  const maxDiffs = 20;
-
-  // Simple line-by-line diff
-  const maxLen = Math.max(beforeLines.length, afterLines.length);
-
-  for (let i = 0; i < maxLen && diffCount < maxDiffs; i++) {
-    const b = beforeLines[i] || '';
-    const a = afterLines[i] || '';
-
-    if (b !== a) {
-      if (b && !a) {
-        console.log(
-          `${c.red}- L${i + 1}: ${b.slice(0, 70)}${b.length > 70 ? '...' : ''}${c.reset}`
-        );
-      } else if (!b && a) {
-        console.log(
-          `${c.green}+ L${i + 1}: ${a.slice(0, 70)}${a.length > 70 ? '...' : ''}${c.reset}`
-        );
-      } else if (b.trim() !== a.trim()) {
-        console.log(`${c.yellow}~ L${i + 1}:${c.reset}`);
-        console.log(
-          `${c.red}  - ${b.slice(0, 60)}${b.length > 60 ? '...' : ''}${c.reset}`
-        );
-        console.log(
-          `${c.green}  + ${a.slice(0, 60)}${a.length > 60 ? '...' : ''}${c.reset}`
-        );
-      }
-      diffCount++;
-    }
-  }
-
-  if (diffCount >= maxDiffs) {
-    console.log(`${c.dim}  ... and more changes${c.reset}`);
-  }
-}
-
-/**
- * Compare two versions
- */
-function compare(pathA, pathB) {
-  const contentA = fs.readFileSync(pathA, 'utf8');
-  const contentB = fs.readFileSync(pathB, 'utf8');
-
-  const analysisA = analyzeMarkdown(contentA);
-  const analysisB = analyzeMarkdown(contentB);
-
-  console.log(`\n${c.bold}${c.magenta}GEPA Comparison Report${c.reset}`);
-  console.log(`${c.dim}Before: ${pathA}${c.reset}`);
-  console.log(`${c.dim}After:  ${pathB}${c.reset}`);
-
-  formatComparison(analysisA, analysisB);
-  showSectionDiff(analysisA, analysisB);
-  showInlineDiff(contentA, contentB);
-
-  // Score summary
-  const tokenChange = analysisB.estimatedTokens - analysisA.estimatedTokens;
-  const ruleChange =
-    analysisB.mustCount +
-    analysisB.neverCount +
-    analysisB.alwaysCount -
-    (analysisA.mustCount + analysisA.neverCount + analysisA.alwaysCount);
-
-  console.log(`\n${c.bold}Summary:${c.reset}`);
-  console.log(
-    `  Token budget: ${tokenChange >= 0 ? c.yellow + '+' : c.green}${tokenChange}${c.reset} tokens`
-  );
-  console.log(
-    `  Rule density: ${ruleChange >= 0 ? c.green + '+' : c.red}${ruleChange}${c.reset} explicit rules`
-  );
-}
-
-/**
- * Watch for changes and auto-optimize
- */
-async function watch(targetPath) {
-  const claudeMdPath = targetPath || path.join(process.cwd(), 'CLAUDE.md');
-
-  if (!fs.existsSync(claudeMdPath)) {
-    console.error(`${c.red}Error: ${claudeMdPath} not found${c.reset}`);
-    process.exit(1);
-  }
-
-  let lastHash = hashContent(fs.readFileSync(claudeMdPath, 'utf8'));
-  let isOptimizing = false;
-  let optimizeQueue = false;
-
-  console.log(`${c.bold}${c.cyan}GEPA Auto-Optimizer${c.reset}`);
-  console.log(`${c.dim}Watching: ${claudeMdPath}${c.reset}`);
-  console.log(`${c.dim}Press Ctrl+C to stop${c.reset}\n`);
-
-  // Initial analysis
-  const initial = analyzeMarkdown(fs.readFileSync(claudeMdPath, 'utf8'));
-  console.log(`${c.bold}Current state:${c.reset}`);
-  console.log(
-    `  ${initial.totalLines} lines, ~${initial.estimatedTokens} tokens`
-  );
-  console.log(
-    `  ${initial.h2Count} sections, ${initial.mustCount + initial.neverCount + initial.alwaysCount} explicit rules\n`
-  );
-
-  // Watch loop
-  const checkInterval = setInterval(async () => {
-    try {
-      const content = fs.readFileSync(claudeMdPath, 'utf8');
-      const currentHash = hashContent(content);
-
-      if (currentHash !== lastHash) {
-        console.log(
-          `\n${c.yellow}⚡ Change detected!${c.reset} (${new Date().toLocaleTimeString()})`
-        );
-
-        // Save before state
-        const beforePath = path.join(GEPA_DIR, '.before-optimize.md');
-        const statePath = path.join(GEPA_DIR, 'state.json');
-
-        if (fs.existsSync(statePath)) {
-          const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-          const currentBest = path.join(
-            GENERATIONS_DIR,
-            `gen-${String(state.currentGeneration).padStart(3, '0')}`,
-            `${state.bestVariant}.md`
-          );
-          if (fs.existsSync(currentBest)) {
-            fs.copyFileSync(currentBest, beforePath);
-          }
-        }
-
-        lastHash = currentHash;
-
-        if (isOptimizing) {
-          optimizeQueue = true;
-          console.log(
-            `${c.dim}  Optimization in progress, queued for next run${c.reset}`
-          );
-          return;
-        }
-
-        isOptimizing = true;
-
-        // Run quick optimization (1 generation)
-        console.log(`${c.cyan}  Running GEPA optimization...${c.reset}`);
-
-        try {
-          // Re-init with new content
-          execSync(
-            `node ${path.join(GEPA_DIR, 'optimize.js')} init ${claudeMdPath}`,
-            {
-              stdio: 'pipe',
-            }
-          );
-
-          // Quick mutate + score
-          execSync(`node ${path.join(GEPA_DIR, 'optimize.js')} mutate`, {
-            stdio: 'pipe',
-          });
-
-          execSync(`node ${path.join(GEPA_DIR, 'optimize.js')} score`, {
-            stdio: 'pipe',
-          });
-
-          // Show comparison
-          const afterPath = path.join(GENERATIONS_DIR, 'current');
-          if (fs.existsSync(beforePath) && fs.existsSync(afterPath)) {
-            const resolvedAfter = fs.realpathSync(afterPath);
-            compare(beforePath, resolvedAfter);
-          }
-
-          // Load state for summary
-          const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-          console.log(`\n${c.green}✓ Optimization complete${c.reset}`);
-          console.log(
-            `  Best variant: ${c.bold}${state.bestVariant}${c.reset}`
-          );
-          console.log(
-            `  Score: ${c.bold}${(state.bestScore * 100).toFixed(1)}%${c.reset}`
-          );
-          console.log(
-            `\n${c.dim}  To apply: cp ${path.join(GENERATIONS_DIR, 'current')} ${claudeMdPath}${c.reset}`
-          );
-        } catch (e) {
-          console.error(
-            `${c.red}  Optimization failed: ${e.message}${c.reset}`
-          );
-        }
-
-        isOptimizing = false;
-
-        // Process queue
-        if (optimizeQueue) {
-          optimizeQueue = false;
-          lastHash = ''; // Force re-check
-        }
-      }
-    } catch (e) {
-      // File might be temporarily unavailable during write
-    }
-  }, 2000); // Check every 2 seconds
-
-  // Handle shutdown
-  process.on('SIGINT', () => {
-    clearInterval(checkInterval);
-    console.log(`\n${c.dim}Watcher stopped${c.reset}`);
-    process.exit(0);
-  });
-}
-
-/**
- * Generate optimization report
- */
-function report() {
-  const statePath = path.join(GEPA_DIR, 'state.json');
-
-  if (!fs.existsSync(statePath)) {
-    console.error(`${c.red}No GEPA state found. Run 'init' first.${c.reset}`);
-    return;
-  }
-
-  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-
-  console.log(
-    `\n${c.bold}${c.magenta}═══════════════════════════════════════════════════════════${c.reset}`
-  );
-  console.log(
-    `${c.bold}${c.magenta}                    GEPA OPTIMIZATION REPORT                ${c.reset}`
-  );
-  console.log(
-    `${c.bold}${c.magenta}═══════════════════════════════════════════════════════════${c.reset}\n`
-  );
-
-  console.log(`${c.bold}Current State:${c.reset}`);
-  console.log(`  Generation:    ${c.cyan}${state.currentGeneration}${c.reset}`);
-  console.log(`  Best Variant:  ${c.green}${state.bestVariant}${c.reset}`);
-  console.log(
-    `  Best Score:    ${c.bold}${(state.bestScore * 100).toFixed(1)}%${c.reset}`
-  );
-  console.log(`  Target File:   ${c.dim}${state.targetPath}${c.reset}`);
-
-  // History summary
-  if (state.history && state.history.length > 0) {
-    console.log(`\n${c.bold}Evolution History:${c.reset}`);
-
-    const scoreHistory = state.history
-      .filter((h) => h.action === 'select' && h.scores)
-      .map((h) => ({
-        gen: h.generation,
-        best: h.best,
-        score: h.scores.find((s) => s.variant === h.best)?.score || 0,
-      }));
-
-    if (scoreHistory.length > 0) {
-      // ASCII chart
-      const maxScore = Math.max(...scoreHistory.map((h) => h.score));
-      const chartWidth = 40;
-
-      scoreHistory.forEach((h) => {
-        const barLen = Math.round((h.score / maxScore) * chartWidth);
-        const bar = '█'.repeat(barLen) + '░'.repeat(chartWidth - barLen);
-        const pct = (h.score * 100).toFixed(0).padStart(3);
-        console.log(
-          `  Gen ${String(h.gen).padStart(2)}: ${c.green}${bar}${c.reset} ${pct}% (${h.best})`
-        );
-      });
-
-      // Improvement
-      if (scoreHistory.length > 1) {
-        const first = scoreHistory[0].score;
-        const last = scoreHistory[scoreHistory.length - 1].score;
-        const improvement = (((last - first) / first) * 100).toFixed(1);
-        console.log(
-          `\n  ${c.bold}Total improvement: ${improvement >= 0 ? c.green + '+' : c.red}${improvement}%${c.reset}`
-        );
-      }
-    }
-  }
-
-  // Show before/after if available
-  const beforePath = path.join(GEPA_DIR, '.before-optimize.md');
-  const currentPath = path.join(GENERATIONS_DIR, 'current');
-
-  if (fs.existsSync(beforePath) && fs.existsSync(currentPath)) {
-    console.log(`\n${c.bold}Latest Optimization:${c.reset}`);
-    compare(beforePath, fs.realpathSync(currentPath));
-  }
-
-  console.log(
-    `\n${c.dim}Run 'node auto-optimize.js watch' to auto-optimize on changes${c.reset}\n`
-  );
-}
-
-// CLI
-const command = process.argv[2];
-const arg1 = process.argv[3];
-const arg2 = process.argv[4];
-
-switch (command) {
-  case 'watch':
-    watch(arg1);
-    break;
-  case 'compare':
-    if (!arg1 || !arg2) {
-      console.error('Usage: compare <before.md> <after.md>');
-      process.exit(1);
-    }
-    compare(arg1, arg2);
-    break;
-  case 'report':
-    report();
-    break;
-  default:
-    console.log(`
-${c.bold}GEPA Auto-Optimizer${c.reset}
-
-Usage:
-  node auto-optimize.js watch [path]     Watch CLAUDE.md and auto-optimize
-  node auto-optimize.js compare <a> <b>  Compare two versions
-  node auto-optimize.js report           Show optimization report
-
-Examples:
-  node auto-optimize.js watch ./CLAUDE.md
-  node auto-optimize.js compare gen-000/baseline.md gen-001/variant-a.md
-  node auto-optimize.js report
-`);
-}
-
-export { compare, analyzeMarkdown, watch, report };

package/scripts/gepa/hooks/eval-tracker.js

@@ -1,203 +0,0 @@
-#!/usr/bin/env node
-/**
- * GEPA Eval Tracker Hook
- *
- * Captures agent behavior during sessions for evaluation.
- * Install in ~/.claude/settings.json under hooks.
- */
-
-import fs from 'fs';
-import path from 'path';
-
-const GEPA_DIR =
-  process.env.GEPA_DIR || path.join(process.env.HOME, '.claude', 'gepa');
-const RESULTS_DIR = path.join(GEPA_DIR, 'results');
-const SESSIONS_DIR = path.join(RESULTS_DIR, 'sessions');
-
-// Ensure directories exist
-[RESULTS_DIR, SESSIONS_DIR].forEach((dir) => {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-});
-
-/**
- * Session tracking state
- */
-class SessionTracker {
-  constructor() {
-    this.sessionId = process.env.CLAUDE_SESSION_ID || `session-${Date.now()}`;
-    this.variant = process.env.GEPA_VARIANT || 'baseline';
-    this.generation = parseInt(process.env.GEPA_GENERATION || '0');
-
-    this.data = {
-      sessionId: this.sessionId,
-      variant: this.variant,
-      generation: this.generation,
-      startTime: new Date().toISOString(),
-      endTime: null,
-      toolCalls: [],
-      errors: [],
-      userFeedback: [],
-      tokenUsage: { input: 0, output: 0 },
-      metrics: {},
-    };
-  }
-
-  trackToolCall(tool, input, output, duration) {
-    this.data.toolCalls.push({
-      tool,
-      input: this.sanitize(input),
-      output: this.summarize(output),
-      duration,
-      timestamp: new Date().toISOString(),
-      success: !output?.error,
-    });
-  }
-
-  trackError(error, context) {
-    this.data.errors.push({
-      error: error.message || String(error),
-      context,
-      timestamp: new Date().toISOString(),
-    });
-  }
-
-  trackFeedback(type, value) {
-    this.data.userFeedback.push({
-      type, // 'thumbs_up', 'thumbs_down', 'correction', 'retry'
-      value,
-      timestamp: new Date().toISOString(),
-    });
-  }
-
-  trackTokens(input, output) {
-    this.data.tokenUsage.input += input;
-    this.data.tokenUsage.output += output;
-  }
-
-  sanitize(obj) {
-    // Remove sensitive data
-    if (typeof obj !== 'object') return obj;
-    const sanitized = { ...obj };
-    const sensitiveKeys = ['apiKey', 'token', 'password', 'secret', 'key'];
-    for (const key of Object.keys(sanitized)) {
-      if (sensitiveKeys.some((s) => key.toLowerCase().includes(s))) {
-        sanitized[key] = '[REDACTED]';
-      }
-    }
-    return sanitized;
-  }
-
-  summarize(output) {
-    // Truncate long outputs
-    const str = typeof output === 'string' ? output : JSON.stringify(output);
-    return str.length > 1000 ? str.slice(0, 1000) + '...[truncated]' : str;
-  }
-
-  finalize() {
-    this.data.endTime = new Date().toISOString();
-    this.data.duration =
-      new Date(this.data.endTime) - new Date(this.data.startTime);
-
-    // Calculate basic metrics
-    this.data.metrics = {
-      totalToolCalls: this.data.toolCalls.length,
-      successfulToolCalls: this.data.toolCalls.filter((t) => t.success).length,
-      errorCount: this.data.errors.length,
-      avgToolDuration:
-        this.data.toolCalls.length > 0
-          ? this.data.toolCalls.reduce((sum, t) => sum + (t.duration || 0), 0) /
-            this.data.toolCalls.length
-          : 0,
-      positiveFeeback: this.data.userFeedback.filter(
-        (f) => f.type === 'thumbs_up'
-      ).length,
-      negativeFeeback: this.data.userFeedback.filter(
-        (f) => f.type === 'thumbs_down'
-      ).length,
-    };
-
-    return this.data;
-  }
-
-  save() {
-    const data = this.finalize();
-    const filename = `${this.generation}-${this.variant}-${this.sessionId}.json`;
-    const filepath = path.join(SESSIONS_DIR, filename);
-    fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
-
-    // Also append to scores.jsonl for quick analysis
-    const scoreLine = {
-      sessionId: this.sessionId,
-      variant: this.variant,
-      generation: this.generation,
-      metrics: data.metrics,
-      timestamp: data.endTime,
-    };
-    fs.appendFileSync(
-      path.join(RESULTS_DIR, 'scores.jsonl'),
-      JSON.stringify(scoreLine) + '\n'
-    );
-
-    return filepath;
-  }
-}
-
-// Global tracker instance
-let tracker = null;
-
-/**
- * Hook handlers
- */
-export function onSessionStart(context) {
-  tracker = new SessionTracker();
-  console.error(
-    `[GEPA] Tracking session: ${tracker.sessionId} (gen=${tracker.generation}, variant=${tracker.variant})`
-  );
-}
-
-export function onToolCall(tool, input) {
-  if (!tracker) return;
-  tracker._currentTool = { tool, input, startTime: Date.now() };
-}
-
-export function onToolResult(tool, result) {
-  if (!tracker || !tracker._currentTool) return;
-  const duration = Date.now() - tracker._currentTool.startTime;
-  tracker.trackToolCall(tool, tracker._currentTool.input, result, duration);
-  tracker._currentTool = null;
-}
-
-export function onError(error, context) {
-  if (!tracker) return;
-  tracker.trackError(error, context);
-}
-
-export function onUserFeedback(type, value) {
-  if (!tracker) return;
-  tracker.trackFeedback(type, value);
-}
-
-export function onSessionEnd() {
-  if (!tracker) return;
-  const filepath = tracker.save();
-  console.error(`[GEPA] Session data saved to: ${filepath}`);
-  tracker = null;
-}
-
-// CLI interface for testing
-if (process.argv[1] === import.meta.url.replace('file://', '')) {
-  const command = process.argv[2];
-
-  if (command === 'test') {
-    onSessionStart({});
-    onToolCall('Read', { file: '/test/file.ts' });
-    onToolResult('Read', { content: 'test content...' });
-    onToolCall('Edit', { file: '/test/file.ts', changes: '...' });
-    onToolResult('Edit', { success: true });
-    onUserFeedback('thumbs_up', 'good job');
-    onSessionEnd();
-    console.log('Test session recorded');
-  }
-}