remem-mcp 0.5.17

package/scripts/cast-to-mp4.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""
+Render asciinema cast to MP4 directly using PIL.
+No frame cap — renders at true 30fps.
+"""
+import json, sys, os, re
+from PIL import Image, ImageDraw, ImageFont
+
+# Config
+FPS = 30
+FONT_SIZE = 18
+COLS = 80
+ROWS = 24
+CHAR_W = 11  # approx for JetBrains Mono 18px
+CHAR_H = 24
+MARGIN = 20
+WIDTH = COLS * CHAR_W + MARGIN * 2
+HEIGHT = ROWS * CHAR_H + MARGIN * 2
+
+# Monokai theme colors
+BG = (39, 40, 34)
+FG = (248, 248, 242)
+COLORS = {
+    30: (248, 248, 242),  # black
+    31: (255, 85, 85),    # red
+    32: (166, 226, 46),   # green
+    33: (230, 219, 116),  # yellow
+    34: (102, 217, 239),  # blue
+    35: (174, 129, 255),  # magenta
+    36: (161, 239, 239),  # cyan
+    37: (248, 248, 242),  # white
+    90: (150, 152, 150),  # bright black (gray)
+    91: (255, 85, 85),
+    92: (166, 226, 46),
+    93: (230, 219, 116),
+    94: (102, 217, 239),
+    95: (174, 129, 255),
+    96: (161, 239, 239),
+    97: (248, 248, 242),
+}
+
+def load_font():
+    # Menlo.ttc is a TrueType Collection — needs index parameter
+    # It has full box-drawing char support (┌─┐│└┘ etc.)
+    try:
+        return ImageFont.truetype("/System/Library/Fonts/Menlo.ttc", FONT_SIZE, index=0)
+    except:
+        pass
+    for p in [
+        "/System/Library/Fonts/SFNSMono.ttf",
+        "/System/Library/Fonts/Monaco.ttf",
+        "/Library/Fonts/JetBrains Mono Regular.ttf",
+    ]:
+        if os.path.exists(p):
+            try:
+                return ImageFont.truetype(p, FONT_SIZE)
+            except:
+                continue
+    return ImageFont.load_default()
+
+font = load_font()
+# Load bold variant for ANSI bold (code 1)
+try:
+    font_bold = ImageFont.truetype("/System/Library/Fonts/Menlo.ttc", FONT_SIZE, index=1)
+except:
+    font_bold = font
+
+# Measure actual char width from font
+try:
+    _bbox = font.getbbox("M")
+    CHAR_W = _bbox[2] - _bbox[0] + 1
+    _bbox_h = font.getbbox("M|")
+    CHAR_H = max(24, (_bbox_h[3] - _bbox_h[1]) + 8)
+except:
+    pass
+
+def parse_ansi(text):
+    """Parse ANSI escape sequences and return list of (char, color, bold) tuples.
+    Also returns control commands: ('clear',), ('home',), ('clearend',)"""
+    result = []
+    i = 0
+    color = FG
+    bold = False
+    while i < len(text):
+        if text[i] == '\x1b' and i + 1 < len(text) and text[i+1] == '[':
+            # Find end of escape sequence — could end in 'm' (SGR), 'J' (erase), 'H' (cursor), 'K', etc.
+            j = i + 2
+            while j < len(text) and text[j] not in 'mJHKABCDf':
+                j += 1
+            if j < len(text):
+                cmd = text[j]
+                params = text[i+2:j]
+                if cmd == 'm':
+                    # SGR — color/bold
+                    codes = params.split(';')
+                    for code in codes:
+                        if not code:
+                            continue
+                        c = int(code)
+                        if c == 0:
+                            color = FG
+                            bold = False
+                        elif c == 1:
+                            bold = True
+                        elif c in COLORS:
+                            color = COLORS[c]
+                elif cmd == 'J':
+                    # Erase display: 2J = clear all, 0J = clear from cursor to end
+                    result.append(('clear', color, bold))
+                elif cmd == 'H':
+                    # Cursor home
+                    result.append(('home', color, bold))
+                elif cmd == 'K':
+                    # Erase line: 0K = cursor to end, 2K = entire line
+                    result.append(('clearend', color, bold))
+                # Ignore other cursor movement (A,B,C,D,f)
+                i = j + 1
+                continue
+        if text[i] == '\r':
+            # Carriage return — reset cursor to start of line (for counter animation)
+            result.append(('\r', color, bold))
+            i += 1
+            continue
+        if text[i] == '\n':
+            result.append(('\n', color, bold))
+            i += 1
+            continue
+        result.append((text[i], color, bold))
+        i += 1
+    return result
+
+def render_frame(screen, cursor_row, cursor_col):
+    """Render screen state to PIL Image."""
+    img = Image.new('RGB', (WIDTH, HEIGHT), BG)
+    draw = ImageDraw.Draw(img)
+    
+    for row_idx, row in enumerate(screen[:ROWS]):
+        col_idx = 0
+        for char, color, bold in row:
+            if char == '\n':
+                break
+            if col_idx >= COLS:
+                break
+            x = MARGIN + col_idx * CHAR_W
+            y = MARGIN + row_idx * CHAR_H
+            if char != ' ':
+                f = font_bold if bold else font
+                draw.text((x, y), char, fill=color, font=f)
+            col_idx += 1
+    
+    return img
+
+def update_screen(screen, data, cursor_row, cursor_col):
+    """Update screen buffer with new data."""
+    chars = parse_ansi(data)
+    for item in chars:
+        char, color, bold = item[0], item[1], item[2]
+        # Handle control commands
+        if char == 'clear':
+            for r in range(ROWS):
+                screen[r] = []
+            cursor_row = 0
+            cursor_col = 0
+            continue
+        if char == 'home':
+            cursor_row = 0
+            cursor_col = 0
+            continue
+        if char == 'clearend':
+            if cursor_row < ROWS:
+                screen[cursor_row] = screen[cursor_row][:cursor_col]
+            continue
+        if char == '\n':
+            cursor_row += 1
+            cursor_col = 0
+            if cursor_row >= ROWS:
+                screen.pop(0)
+                screen.append([])
+                cursor_row = ROWS - 1
+            continue
+        if char == '\r':
+            cursor_col = 0
+            continue
+        if char == '\x08':  # backspace
+            cursor_col = max(0, cursor_col - 1)
+            continue
+        # Ensure row exists
+        while len(screen) <= cursor_row:
+            screen.append([])
+        # Ensure col exists
+        while len(screen[cursor_row]) <= cursor_col:
+            screen[cursor_row].append((' ', FG, False))
+        # Set char
+        screen[cursor_row][cursor_col] = (char, color, bold)
+        cursor_col += 1
+        if cursor_col >= COLS:
+            cursor_row += 1
+            cursor_col = 0
+            if cursor_row >= ROWS:
+                screen.pop(0)
+                screen.append([])
+                cursor_row = ROWS - 1
+    return cursor_row, cursor_col
+
+def main():
+    cast_path = sys.argv[1]
+    output_path = sys.argv[2]
+    
+    with open(cast_path) as f:
+        lines = f.readlines()
+    
+    events = []
+    for line in lines[1:]:
+        line = line.strip()
+        if not line: continue
+        parts = json.loads(line)
+        if isinstance(parts, list) and len(parts) >= 3 and parts[1] == 'o':
+            events.append((parts[0], parts[2]))
+    
+    total_duration = sum(t for t, _ in events)
+    total_frames = int(total_duration * FPS)
+    print(f"Duration: {total_duration:.1f}s, Frames: {total_frames}, FPS: {FPS}")
+    
+    # Process events and generate frames
+    screen = [[] for _ in range(ROWS)]
+    cursor_row, cursor_col = 0, 0
+    
+    frames = []
+    event_idx = 0
+    current_time = 0.0
+    frame_time = 1.0 / FPS
+    
+    for frame_num in range(total_frames):
+        # Process all events that occur before this frame
+        while event_idx < len(events) and current_time >= sum(e[0] for e in events[:event_idx+1]):
+            delay, data = events[event_idx]
+            cursor_row, cursor_col = update_screen(screen, data, cursor_row, cursor_col)
+            event_idx += 1
+        
+        # Render frame
+        img = render_frame(screen, cursor_row, cursor_col)
+        frames.append(img)
+        current_time += frame_time
+        
+        if frame_num % 100 == 0:
+            print(f"  Frame {frame_num}/{total_frames}...")
+    
+    # Save as MP4 using ffmpeg
+    print(f"Saving {len(frames)} frames to {output_path}...")
+    # Save frames as PNG sequence first
+    tmp_dir = "/tmp/demo-frames"
+    os.makedirs(tmp_dir, exist_ok=True)
+    for i, frame in enumerate(frames):
+        frame.save(f"{tmp_dir}/frame_{i:05d}.png")
+    
+    # Use ffmpeg to create MP4
+    os.system(f"ffmpeg -y -framerate {FPS} -i {tmp_dir}/frame_%05d.png -c:v libx264 -preset fast -pix_fmt yuv420p -movflags faststart {output_path} 2>/dev/null")
+    
+    # Cleanup
+    os.system(f"rm -rf {tmp_dir}")
+    print(f"Done: {output_path}")
+
+if __name__ == "__main__":
+    main()

package/scripts/loop-bench.sh

@@ -0,0 +1,179 @@
+#!/bin/bash
+# loop-bench.sh — Autonomous loop: run benchmark → if fail, call devin -p → repeat.
+# Usage: ./scripts/loop-bench.sh [max_iterations]
+#
+# No LoopX. File-based resume via last-iter.txt.
+#
+# Requirements:
+#   - devin CLI on PATH
+#   - AMB repo at /tmp/amb-repo
+#   - LoCoMo data at /tmp/locomo/data/locomo10.json (optional)
+
+set -uo pipefail
+
+# ─── Config ────────────────────────────────────────────────────
+MAX_ITER="${1:-50}"
+PROJECT_ROOT="/data/projects/tdai-memory-mcp"
+BENCH_SCRIPT="$PROJECT_ROOT/scripts/bench-all.sh"
+LOG_DIR="/tmp/bench-loop-logs"
+PROMPT_FILE="/tmp/bench-loop-prompt.md"
+LAST_ITER_FILE="$LOG_DIR/last-iter.txt"
+
+# Targets
+export TARGET_L1="${TARGET_L1:-100}"
+export TARGET_L2="${TARGET_L2:-100}"
+export TARGET_L3="${TARGET_L3:-100}"
+export TARGET_LOCOMO="${TARGET_LOCOMO:-76}"
+export TARGET_PERSONAMEM="${TARGET_PERSONAMEM:-76}"
+
+mkdir -p "$LOG_DIR"
+log() { echo "[loop] $(date '+%Y-%m-%d %H:%M:%S') $*"; }
+
+# ─── Resume logic (file-based) ─────────────────────────────────
+START_ITER=1
+if [ -f "$LAST_ITER_FILE" ]; then
+  START_ITER=$(($(cat "$LAST_ITER_FILE") + 1))
+  log "Resuming from iteration $START_ITER"
+fi
+
+# ─── Main loop ─────────────────────────────────────────────────
+for iter in $(seq $START_ITER $MAX_ITER); do
+  echo "$iter" > "$LAST_ITER_FILE"
+  log "══════════════════════════════════════════════════════"
+  log "  ITERATION $iter / $MAX_ITER"
+  log "══════════════════════════════════════════════════════"
+
+  # 1. Run benchmark (full mode — includes LoCoMo + PersonaMem)
+  BENCH_LOG="$LOG_DIR/iter-${iter}-bench.log"
+  log "Running benchmark..."
+  if bash "$BENCH_SCRIPT" > "$BENCH_LOG" 2>&1; then
+    log "ALL PASS ✓"
+    RESULT_LINE=$(grep "BENCH_RESULT" "$BENCH_LOG" || echo "")
+    log "$RESULT_LINE"
+    log "Done."
+    exit 0
+  fi
+
+  # 2. Parse scores
+  RESULT_LINE=$(grep "BENCH_RESULT" "$BENCH_LOG" || echo "BENCH_RESULT L1=0 L2=0 L3=0 LOCOMO=N/A PERSONAMEM=N/A")
+  L1=$(echo "$RESULT_LINE" | grep -oP 'L1=\K[0-9]+' || echo "0")
+  L2=$(echo "$RESULT_LINE" | grep -oP 'L2=\K[0-9]+' || echo "0")
+  L3=$(echo "$RESULT_LINE" | grep -oP 'L3=\K[0-9]+' || echo "0")
+  LOCOMO=$(echo "$RESULT_LINE" | grep -oP 'LOCOMO=\K[0-9]+' || echo "N/A")
+  PERSONAMEM=$(echo "$RESULT_LINE" | grep -oP 'PERSONAMEM=\K[0-9]+' || echo "N/A")
+
+  log "Scores: L1=$L1 L2=$L2 L3=$L3 LOCOMO=$LOCOMO PERSONAMEM=$PERSONAMEM"
+
+  # 3. Extract failures
+  FAILURES=$(grep "^FAIL:" "$BENCH_LOG" || echo "")
+  if [ -z "$FAILURES" ]; then
+    FAILURES="Benchmark exited non-zero. Check $BENCH_LOG."
+  fi
+
+  # 4. Extract detailed test failures
+  AMB_FAILURES=$(grep -E "FAIL|✗|failed|incorrect|wrong|Expected|Got" "$BENCH_LOG" | head -30 || echo "")
+
+  # 5. Find lowest-scoring layer to focus Devin
+  LOWEST_LAYER="L2"
+  LOWEST_SCORE=$L2
+  if [ "$L3" -lt "$LOWEST_SCORE" ] 2>/dev/null; then LOWEST_LAYER="L3"; LOWEST_SCORE=$L3; fi
+  if [ "$LOCOMO" != "N/A" ] && [ "$LOCOMO" -lt "$LOWEST_SCORE" ] 2>/dev/null; then LOWEST_LAYER="LOCOMO"; LOWEST_SCORE=$LOCOMO; fi
+  if [ "$PERSONAMEM" != "N/A" ] && [ "$PERSONAMEM" -lt "$LOWEST_SCORE" ] 2>/dev/null; then LOWEST_LAYER="PERSONAMEM"; LOWEST_SCORE=$PERSONAMEM; fi
+
+  # 6. Build prompt for Devin
+  cat > "$PROMPT_FILE" << EOF
+# Benchmark Fix Task — Iteration $iter
+
+You are working on tdai-memory-mcp at $PROJECT_ROOT.
+Goal: Pass ALL benchmarks with scores >= TencentDB.
+
+## Current Scores vs Targets
+| Benchmark  | Score | Target |
+|------------|-------|--------|
+| AMB L1     | $L1   | $TARGET_L1 |
+| AMB L2     | $L2   | $TARGET_L2 |
+| AMB L3     | $L3   | $TARGET_L3 |
+| LoCoMo     | $LOCOMO | $TARGET_LOCOMO |
+| PersonaMem | $PERSONAMEM | $TARGET_PERSONAMEM |
+
+## Focus: $LOWEST_LAYER is lowest at $LOWEST_SCORE / 100
+
+## Failures
+$FAILURES
+
+## Detailed Test Failures
+$AMB_FAILURES
+
+## Full Benchmark Log
+Read: $BENCH_LOG
+
+## Your Task
+1. Read $BENCH_LOG to see exactly which tests failed and why.
+2. Read the relevant source code in $PROJECT_ROOT/src/.
+3. Fix the root cause. Make minimal, surgical changes.
+4. Run \`npm run build\` — must pass.
+5. Run \`npm test\` — must pass.
+6. Do NOT break existing passing tests.
+7. Focus on $LOWEST_LAYER first (lowest score).
+
+## Architecture Context
+- Memory MCP server with hybrid search: BM25 + vector (sqlite-vec) + RRF fusion.
+- AMB L1 = basic recall (56 tests, 8 categories).
+- AMB L2 = multi-session scenarios (5 scenarios).
+- AMB L3 = scale testing (1K+ memories, distractors).
+- LoCoMo = long conversation QA (19 sessions, 400+ turns, multi-hop questions).
+- PersonaMem = personalization benchmark (588 questions, 20 personas, multiple-choice QA).
+  TencentDB scores 76% on PersonaMem. Our adapter at /tmp/personamem/personamem-bench.ts
+  ingests conversation context into tdai-memory-mcp, then searches with the question
+  and checks if search results contain unique keywords from the correct answer.
+  Current score: $PERSONAMEM/100. Target: 76.
+- AtomPipeline exists but only runs for decision/learning/error — NOT conversation.
+- Search does NOT join atoms table — atoms are stored but never searched.
+- TencentDB uses L1/L2/L3 extraction pipeline: extract facts → scenarios → knowledge graph.
+- To beat TencentDB: implement fact extraction for conversations + atom-aware search.
+
+## Key Files
+- src/pipeline/atom.ts — L1 fact extraction (extend to conversation type)
+- src/storage/sqlite.ts — search + vector + RRF (add atom search)
+- src/server.ts — recall/search handlers (join atoms into results)
+- src/pipeline/types.ts — pipeline interfaces
+- /tmp/personamem/personamem-bench.ts — PersonaMem adapter (scoring logic)
+- /tmp/personamem/data/questions_32k.csv — PersonaMem questions
+- /tmp/personamem/data/shared_contexts_32k.jsonl — PersonaMem contexts
+
+## Rules
+- ONE focused fix per iteration.
+- No unrelated refactoring.
+- Run build + tests before finishing.
+- If you're stuck after 3 attempts at the same fix, try a different approach.
+EOF
+
+  # 7. Call Devin to fix
+  DEVIN_LOG="$LOG_DIR/iter-${iter}-devin.log"
+  log "Calling Devin (dangerous mode) to fix $LOWEST_LAYER..."
+  log "Prompt: $PROMPT_FILE"
+  log "Devin log: $DEVIN_LOG"
+
+  devin -p "$(cat "$PROMPT_FILE")" \
+    --permission-mode dangerous \
+    > "$DEVIN_LOG" 2>&1 || true
+
+  log "Devin finished."
+
+  # 8. Summary
+  DEVIN_SUMMARY=$(tail -5 "$DEVIN_LOG" 2>/dev/null || echo "no output")
+  log "Devin output (last 5 lines):"
+  echo "$DEVIN_SUMMARY" | while read -r line; do log "  $line"; done
+
+  log "Iteration $iter complete."
+  log ""
+done
+
+# ─── Max iterations reached ────────────────────────────────────
+log "══════════════════════════════════════════════════════"
+log "  MAX ITERATIONS ($MAX_ITER) REACHED — target not met"
+log "══════════════════════════════════════════════════════"
+log "Last scores: L1=$L1 L2=$L2 L3=$L3 LOCOMO=$LOCOMO PERSONAMEM=$PERSONAMEM"
+log "Logs: $LOG_DIR/"
+log "Resume: bash scripts/loop-bench.sh $MAX_ITER"
+exit 1

package/scripts/loop-longmemeval.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+# loop-longmemeval.sh — Autonomous loop: run LongMemEval → if fail, call devin -p → repeat.
+# Usage: ./scripts/loop-longmemeval.sh [max_iterations] [--variant oracle|s]
+#
+# File-based resume via last-iter.txt.
+
+set -uo pipefail
+
+# ─── Config ────────────────────────────────────────────────────
+MAX_ITER="${1:-30}"
+VARIANT="${2:-oracle}"
+PROJECT_ROOT="/data/projects/tdai-memory-mcp"
+BENCH_SCRIPT="/tmp/longmemeval/longmemeval-bench.ts"
+LOG_DIR="/tmp/longmemeval-loop-logs"
+PROMPT_FILE="/tmp/longmemeval-loop-prompt.md"
+LAST_ITER_FILE="$LOG_DIR/last-iter.txt"
+SAMPLE_SIZE="${SAMPLE_SIZE:-100}"
+TARGET="${TARGET_LONGMEMEVAL:-80}"
+
+mkdir -p "$LOG_DIR"
+log() { echo "[loop] $(date '+%Y-%m-%d %H:%M:%S') $*"; }
+
+# ─── Resume logic ──────────────────────────────────────────────
+START_ITER=1
+if [ -f "$LAST_ITER_FILE" ]; then
+  START_ITER=$(($(cat "$LAST_ITER_FILE") + 1))
+  log "Resuming from iteration $START_ITER"
+fi
+
+# ─── Main loop ─────────────────────────────────────────────────
+for iter in $(seq $START_ITER $MAX_ITER); do
+  echo "$iter" > "$LAST_ITER_FILE"
+  log "══════════════════════════════════════════════════════"
+  log "  ITERATION $iter / $MAX_ITER  (variant: $VARIANT)"
+  log "══════════════════════════════════════════════════════"
+
+  # 1. Run benchmark
+  BENCH_LOG="$LOG_DIR/iter-${iter}-bench.log"
+  log "Running LongMemEval benchmark (sample=$SAMPLE_SIZE, variant=$VARIANT)..."
+  cd /tmp/longmemeval
+  npx tsx longmemeval-bench.ts --sample=$SAMPLE_SIZE --variant=$VARIANT > "$BENCH_LOG" 2>&1
+  BENCH_EXIT=$?
+
+  # 2. Parse score
+  SCORE=$(grep "LONGMEMEVAL_SCORE" "$BENCH_LOG" | grep -oP '\d+' || echo "0")
+  log "LongMemEval score: $SCORE / 100  (target: $TARGET)"
+
+  # 3. Check pass
+  if [ "$SCORE" -ge "$TARGET" ]; then
+    log "ALL PASS ✓ — LongMemEval=$SCORE >= $TARGET"
+    grep "LONGMEMEVAL_SCORE" "$BENCH_LOG"
+    log "Done."
+    exit 0
+  fi
+
+  # 4. Extract failures
+  FAILURES=$(grep "✗" "$BENCH_LOG" | head -20 || echo "")
+  BY_TYPE=$(grep "=" "$BENCH_LOG" | grep "%" || echo "")
+  RESULT_DETAIL=$(python3 -c "
+import json
+try:
+    data = json.load(open('/tmp/longmemeval/results.json'))
+    by_type = data.get('byType', {})
+    for t, s in sorted(by_type.items()):
+        pct = round(s['correct'] / s['total'] * 100) if s['total'] else 0
+        print(f'  {t}: {s[\"correct\"]}/{s[\"total\"]} = {pct}%')
+    # Show failed questions
+    failed = [r for r in data.get('results', []) if not r['predicted_correct']]
+    print(f'\\nFailed questions ({len(failed)}):')
+    for f in failed[:10]:
+        print(f'  [{f[\"question_type\"]}] Q: {f[\"question\"][:80]}')
+        print(f'    A: {f[\"answer\"][:80]}')
+        print(f'    Matched: {f[\"matched_keywords\"]}')
+        print()
+except Exception as e:
+    print(f'Error: {e}')
+" 2>/dev/null || echo "Could not parse results")
+
+  # 5. Build prompt
+  cat > "$PROMPT_FILE" << EOF
+# LongMemEval Fix Task — Iteration $iter
+
+You are working on tdai-memory-mcp at $PROJECT_ROOT.
+Goal: Pass LongMemEval benchmark with score >= $TARGET.
+
+## Current Score
+LongMemEval ($VARIANT variant): $SCORE / 100  (target: $TARGET)
+
+## Score by Question Type
+$BY_TYPE
+
+## Failed Questions Detail
+$RESULT_DETAIL
+
+## Full Benchmark Log
+Read: $BENCH_LOG
+
+## Your Task
+1. Read $BENCH_LOG to see which questions failed.
+2. Read /tmp/longmemeval/results.json for detailed results.
+3. Read the benchmark adapter at /tmp/longmemeval/longmemeval-bench.ts to understand scoring.
+4. Read the relevant source code in $PROJECT_ROOT/src/.
+5. Fix the root cause — improve search recall or scoring logic.
+6. Run \`npm run build\` — must pass.
+7. Run \`npm test\` — must pass.
+8. Do NOT break existing passing tests.
+
+## Architecture Context
+- Memory MCP server with hybrid search: BM25 + vector (sqlite-vec) + RRF fusion.
+- LongMemEval tests 5 long-term memory abilities:
+  - temporal-reasoning: when did something happen (133 questions)
+  - multi-session: combine info across sessions (133 questions)
+  - knowledge-update: track changed preferences (78 questions)
+  - single-session-user: recall user facts (70 questions)
+  - single-session-assistant: recall assistant suggestions (56 questions)
+  - single-session-preference: recall preferences (30 questions)
+- Each question has haystack_sessions (chat history) + answer (ground truth).
+- Adapter ingests sessions, searches with question, checks if search results
+  contain keywords from the ground-truth answer.
+- Scoring: correct if >= 40% of answer keywords found in top-5 search results.
+
+## Key Files
+- src/storage/sqlite.ts — search + vector + RRF (improve recall)
+- src/server.ts — search handler (check query expansion, filtering)
+- src/pipeline/atom.ts — fact extraction (may help recall)
+- /tmp/longmemeval/longmemeval-bench.ts — benchmark adapter (scoring logic)
+- /tmp/longmemeval/data/longmemeval_${VARIANT} — dataset
+
+## Rules
+- ONE focused fix per iteration.
+- No unrelated refactoring.
+- Run build + tests before finishing.
+- If stuck after 3 attempts, try a different approach.
+- You can modify the benchmark adapter scoring logic AND the search engine.
+EOF
+
+  # 6. Call Devin
+  DEVIN_LOG="$LOG_DIR/iter-${iter}-devin.log"
+  log "Calling Devin to fix LongMemEval (score=$SCORE < $TARGET)..."
+  cd "$PROJECT_ROOT"
+  devin -p "$(cat "$PROMPT_FILE")" \
+    --permission-mode dangerous \
+    > "$DEVIN_LOG" 2>&1 || true
+
+  log "Devin finished."
+  tail -5 "$DEVIN_LOG" 2>/dev/null | while read -r line; do log "  $line"; done
+
+  log "Iteration $iter complete."
+  echo ""
+done
+
+# ─── Max iterations ────────────────────────────────────────────
+log "══════════════════════════════════════════════════════"
+log "  MAX ITERATIONS ($MAX_ITER) REACHED — target $TARGET not met"
+log "══════════════════════════════════════════════════════"
+log "Last score: $SCORE / 100"
+log "Logs: $LOG_DIR/"
+log "Resume: bash scripts/loop-longmemeval.sh $MAX_ITER $VARIANT"
+exit 1