Upload 149 files

hugging/td_fuse/grpo_reason.py

@@ -268,7 +268,10 @@ def verify_answer(problem: Dict, response: str) -> float:
             # Positive indicators anywhere in answer
             yes_words = ["yes", "do breathe", "does breathe", "does need", "do need",
                          "correct", "true", "indeed", "absolutely", "certainly",
-                         "they do", "it does", "they can", "it can"]
+                         "they do", "it does", "they can", "it can",
+                         "therefore,", "therefore ", "so yes", "the answer is yes",
+                         "breathe air", "have feathers", "have 4 sides",
+                         "need water"]
             # Negative indicators that would flip it
             no_words = ["no,", "no.", "not ", "cannot", "can't", "doesn't", "don't",
                         "is not", "are not", "do not"]

hugging/td_fuse/selfimprove.py

@@ -1,27 +1,26 @@
 """
 TD Self-Improvement Loop — the core of Time Dilation.
 
-This is the part that makes the model actually get smarter over time.
-Based on findings from test_1 through test_18 interviews:
-
-THE LOOP:
+THE LOOP (from test_1 through test_18 interviews):
 1. Ask the model "what are you bad at?" → it identifies weak spots
-2. Generate targeted synthetic training data for those weaknesses
-3. Train with GRPO (verified rewards only — no learned reward model)
-4. Re-benchmark → measure improvement
-5. Repeat — each cycle is small (1-5%) but compounds
-
-KEY PRINCIPLES (from interviews + dad's tests):
-- Verified rewards only: code compiles, math correct, logic valid
-- No learned reward model (saves VRAM, avoids reward hacking)
+2. Generate HARD problems targeting those weaknesses (stuff it fails 30-50%)
+3. Generate N candidates per problem, score with verified rewards
+4. Train on winners (STaR/GRPO approach)
+5. Benchmark → measure improvement
+6. Save → repeat
+
+KEY DIFFERENCE FROM GRPO CYCLE 2:
+- Problems are HARDER — designed so the model fails 30-50% of the time
+- This creates real contrast for learning (correct vs wrong chains)
+- Uses CoT (<think>...</think>) for all reasoning
+- Saves after every major step (diagnosis, generation, training)
+- Targets layers 16-28 specifically for reasoning improvement
+
+PRINCIPLES (from interviews + dad's tests):
+- Verified rewards only: math correct, logic valid, no learned reward model
 - Cherry_LLM perplexity filter prevents mode collapse
-- Mix external data to avoid "100 steps on own outputs → dumber" trap
-- Target mid-to-late layers (16-28 for 32-layer, ~20-30 for 36-layer)
-
-COST SPLIT (from test_16):
-- 70-80% inference scaling (generate many, pick best)
-- 10-20% short GRPO training
-- 5-10% tooling/evaluation
+- Mix problem types to avoid overfitting
+- Small nudges per cycle (1-5%), compounds over time
 """
 
 import torch
@@ -30,44 +29,52 @@ import json
 import math
 import random
 import gc
+import re
+import shutil
 from pathlib import Path
-from typing import Optional
-from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+from dataclasses import dataclass
 
 
 @dataclass
 class SelfImproveConfig:
     """Configuration for one self-improvement cycle."""
-    model_path: str = "td_fuse_outputs/healed_final"
-    output_dir: str = "td_fuse_outputs/improved"
+    model_path: str = "td_fuse_outputs/reasoning_healed"
+    output_dir: str = "td_fuse_outputs/self_improve"
+    progress_file: str = "td_fuse_outputs/self_improve/progress.json"
+
+    # Generation
+    num_candidates: int = 8        # Generate N answers per question, pick best
+    max_gen_tokens: int = 1024     # Long — CoT needs room
+    temperature: float = 0.8       # Higher than GRPO — we want diversity + some failures
 
-    # Generation settings
-    num_candidates: int = 8       # Generate N answers per question, pick best (inference scaling)
-    max_gen_tokens: int = 512
-    temperature: float = 0.7      # For diverse candidate generation
+    # Problems — more than GRPO, and harder
+    num_hard_math: int = 150       # Multi-step math (the model should fail ~30-50%)
+    num_hard_logic: int = 100      # Complex logic chains
+    num_hard_tricks: int = 50      # Tricky questions that trip up LLMs
+    num_hard_coding: int = 50      # Code reasoning problems
+    batch_save_every: int = 25     # Save progress more often
 
-    # Training settings
-    lora_r: int = 16
-    lora_alpha: int = 32
-    train_epochs: int = 2
-    train_batch: int = 4
-    train_grad_accum: int = 4
-    learning_rate: float = 2e-5   # Lower than healing — small nudges
+    # Training
+    lora_r: int = 32               # Higher rank — more capacity for reasoning
+    lora_alpha: int = 64
+    train_epochs: int = 3
+    train_batch: int = 2
+    train_grad_accum: int = 8      # Effective batch = 16
+    learning_rate: float = 1e-5    # Gentle
+    save_steps: int = 50
+    target_layers: str = "16-28"   # Reasoning circuit (from test_18)
 
-    # Data settings
-    num_reasoning_problems: int = 200   # Logic/reasoning problems to generate
-    num_math_problems: int = 200        # Math problems
-    num_code_problems: int = 100        # Code problems
 
-    # Quality filter
-    perplexity_threshold: float = 50.0  # Cherry_LLM: reject if perplexity > this
+# Import verify from grpo_reason
+from .grpo_reason import verify_answer as smart_verify
 
 
 # ============================================================
 # STEP 1: DIAGNOSE — Ask the model what it's bad at
 # ============================================================
 
-def diagnose_weaknesses(model, tokenizer, eos_id):
+def diagnose_weaknesses(model, tokenizer, eos_id, save_path=None):
     """
     Ask the model to identify its own weaknesses.
     All 3 AIs (ChatGPT, Grok, Gemini) confirmed models can do this.
@@ -75,244 +82,431 @@ def diagnose_weaknesses(model, tokenizer, eos_id):
     print("\n=== STEP 1: SELF-DIAGNOSIS ===")
 
     prompts = [
-        "What kinds of questions or tasks are you worst at? Be specific and honest. List your top 5 weaknesses.",
-        "Give me 5 examples of questions that would be hard for you to answer correctly.",
-        "What types of reasoning do you struggle with most? Give specific examples.",
+        ("What kinds of questions are you worst at? Be brutally honest. "
+         "List your top 5 weaknesses with specific examples of questions you'd get wrong."),
+        ("Give me 10 math or logic problems that would be genuinely hard for you. "
+         "Problems where you'd likely make mistakes. Be specific."),
+        ("What types of multi-step reasoning cause you to make errors? "
+         "Give 5 specific examples where you'd probably get the wrong answer."),
     ]
 
-    weaknesses = []
-    for prompt in prompts:
-        p = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    all_responses = []
+    for i, prompt in enumerate(prompts):
+        p = (f"<|im_start|>user\n{prompt}<|im_end|>\n"
+             f"<|im_start|>assistant\n<think>\nLet me think carefully about my actual weaknesses.\n")
         ids = tokenizer(p, return_tensors="pt").to(model.device)
         out = model.generate(
-            **ids, max_new_tokens=500, do_sample=True,
+            **ids, max_new_tokens=800, do_sample=True,
             temperature=0.7, eos_token_id=eos_id
         )
         response = tokenizer.decode(out[0][ids.input_ids.shape[1]:], skip_special_tokens=True)
-        weaknesses.append(response)
-        print(f"  Diagnosis: {response[:150]}...")
+        all_responses.append(response)
+        # Show the answer part (after </think>) if available
+        display = response.split("</think>")[-1].strip() if "</think>" in response else response
+        print(f"  Diagnosis {i+1}: {display[:200]}...")
 
-    return weaknesses
+    # Save diagnosis
+    if save_path:
+        with open(save_path, "w") as f:
+            json.dump({"diagnoses": all_responses, "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")}, f, indent=2)
+        print(f"  Saved diagnosis to {save_path}")
+
+    return all_responses
 
 
 # ============================================================
-# STEP 2: GENERATE — Create targeted training problems
+# STEP 2: GENERATE HARD PROBLEMS
 # ============================================================
 
-def generate_reasoning_problems():
+def generate_hard_problems(cfg: SelfImproveConfig) -> List[Dict]:
     """
-    Generate reasoning problems that target common weaknesses.
-    These have VERIFIABLE answers (the reward signal for GRPO).
+    Generate problems that are HARD enough for the model to fail 30-50%.
+    This is the key difference from GRPO cycle 2 (which was too easy at 97%).
     """
     problems = []
 
-    # Logic chain problems (model failed "yesterday Monday → tomorrow Wednesday")
-    days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-    for i in range(len(days)):
-        yesterday = days[i]
-        today = days[(i + 1) % 7]
-        tomorrow = days[(i + 2) % 7]
-        problems.append({
-            "question": f"If yesterday was {yesterday}, what day is tomorrow?",
-            "answer": tomorrow,
-            "type": "temporal_reasoning"
-        })
-        # Day after tomorrow
-        day_after = days[(i + 3) % 7]
-        problems.append({
-            "question": f"If today is {today}, what day is the day after tomorrow?",
-            "answer": day_after,
-            "type": "temporal_reasoning"
-        })
-
-    # Trick questions (model failed "pound of feathers vs bricks")
-    trick_qs = [
-        ("Which is heavier: a pound of feathers or a pound of bricks?", "same", "They weigh the same — both are one pound."),
-        ("Which is heavier: a ton of feathers or a ton of steel?", "same", "They weigh the same — both are one ton."),
-        ("Which weighs more: 1kg of cotton or 1kg of iron?", "same", "They weigh the same — both are 1 kilogram."),
-        ("If you have 5 apples and take away 3, how many do YOU have?", "3", "You have 3 apples — you took them."),
-        ("A farmer has 17 sheep. All but 9 die. How many are left?", "9", "9 sheep are left — 'all but 9' means 9 survive."),
-        ("How many times can you subtract 5 from 25?", "1", "Once — after that it's 20, not 25."),
-        ("If there are 3 apples and you take away 2, how many do you have?", "2", "You have 2 — you took them."),
-        ("What has a head and a tail but no body?", "coin", "A coin has a head and a tail but no body."),
-    ]
-    for q, key, full_answer in trick_qs:
-        problems.append({
-            "question": q,
-            "answer": full_answer,
-            "verify_key": key,
-            "type": "trick_question"
-        })
-
-    # Syllogism / deductive reasoning
-    syllogisms = [
-        ("All mammals are warm-blooded. A whale is a mammal. Is a whale warm-blooded?", "yes"),
-        ("All birds have feathers. A penguin is a bird. Does a penguin have feathers?", "yes"),
-        ("No reptiles are mammals. A snake is a reptile. Is a snake a mammal?", "no"),
-        ("All squares are rectangles. All rectangles have 4 sides. Do all squares have 4 sides?", "yes"),
-        ("Some dogs are brown. Max is a dog. Is Max definitely brown?", "no"),
-        ("All cats are animals. Some animals are pets. Are all cats pets?", "no"),
-    ]
-    for q, a in syllogisms:
-        problems.append({
-            "question": q + " Explain your reasoning.",
-            "answer": a,
-            "type": "syllogism"
-        })
-
-    # Multi-step reasoning
-    multi_step = [
-        ("If A is taller than B, and B is taller than C, who is the shortest?", "c"),
-        ("If X is older than Y, Y is older than Z, and Z is older than W, who is the youngest?", "w"),
-        ("In a race, Tom finished before Jerry but after Sam. Who won the race?", "sam"),
-        ("Amy is shorter than Bob. Bob is shorter than Carol. Carol is shorter than Dave. Who is the tallest?", "dave"),
-    ]
-    for q, a in multi_step:
-        problems.append({
-            "question": q,
-            "answer": a,
-            "type": "multi_step"
-        })
+    # --- HARD MATH: multi-step, carrying, fractions, negative numbers ---
+    for _ in range(cfg.num_hard_math):
+        ptype = random.choice([
+            "multi_step", "carrying", "negative", "fraction_word",
+            "percentage_chain", "rate_comparison", "sequence_hard"
+        ])
+
+        if ptype == "multi_step":
+            # 3-4 step word problems
+            items = random.choice(["books", "apples", "shirts", "tickets", "cookies"])
+            start = random.randint(20, 100)
+            buy = random.randint(5, 30)
+            give = random.randint(1, min(15, start + buy - 1))
+            lose = random.randint(1, min(5, start + buy - give - 1))
+            final = start + buy - give - lose
+            problems.append({
+                "question": (f"You have {start} {items}. You buy {buy} more. "
+                            f"You give {give} to a friend. You lose {lose}. "
+                            f"How many {items} do you have now?"),
+                "answer": str(final), "type": "hard_math",
+                "think_hint": f"{start} + {buy} - {give} - {lose} = {final}"
+            })
 
-    return problems
+        elif ptype == "carrying":
+            # Large number arithmetic that requires carrying
+            a = random.randint(500, 9999)
+            b = random.randint(500, 9999)
+            op = random.choice(["+", "-", "*"])
+            if op == "+": answer = a + b
+            elif op == "-": answer = a - b
+            else:
+                a = random.randint(20, 200)
+                b = random.randint(20, 200)
+                answer = a * b
+            problems.append({
+                "question": f"Calculate: {a} {op} {b}",
+                "answer": str(answer), "type": "hard_math",
+                "think_hint": f"{a} {op} {b} = {answer}"
+            })
 
+        elif ptype == "negative":
+            a = random.randint(-50, 50)
+            b = random.randint(-50, 50)
+            op = random.choice(["+", "-", "*"])
+            if op == "+": answer = a + b
+            elif op == "-": answer = a - b
+            else: answer = a * b
+            a_str = str(a) if a >= 0 else f"({a})"
+            b_str = str(b) if b >= 0 else f"({b})"
+            problems.append({
+                "question": f"What is {a_str} {op} {b_str}?",
+                "answer": str(answer), "type": "hard_math",
+                "think_hint": f"{a} {op} {b} = {answer}"
+            })
 
-def generate_math_problems(count=200):
-    """Generate math problems with verified correct answers."""
-    problems = []
+        elif ptype == "fraction_word":
+            total = random.choice([12, 16, 20, 24, 30, 36, 40, 48, 60])
+            frac_n = random.choice([1, 2, 3])
+            frac_d = random.choice([2, 3, 4, 5, 6])
+            while frac_n >= frac_d:
+                frac_n = random.choice([1, 2, 3])
+            first = total * frac_n // frac_d
+            remaining = total - first
+            second_frac = random.choice([2, 3, 4])
+            second = remaining // second_frac
+            final = remaining - second
+            problems.append({
+                "question": (f"A jar has {total} marbles. You take {frac_n}/{frac_d} of them. "
+                            f"Then you give away {second} of what's left. How many remain in the jar?"),
+                "answer": str(final), "type": "hard_math",
+                "think_hint": (f"Take {frac_n}/{frac_d} of {total} = {first}. "
+                              f"Left: {remaining}. Give {second}. Final: {final}")
+            })
 
-    for _ in range(count):
-        ptype = random.choice(["arithmetic", "word", "fraction", "percentage"])
+        elif ptype == "percentage_chain":
+            base = random.choice([100, 200, 400, 500, 800, 1000])
+            pct1 = random.choice([10, 20, 25, 30, 50])
+            after1 = base + base * pct1 // 100
+            pct2 = random.choice([10, 20, 25])
+            final = after1 - after1 * pct2 // 100
+            problems.append({
+                "question": (f"A stock is worth ${base}. It goes up {pct1}%, "
+                            f"then drops {pct2}%. What is it worth now?"),
+                "answer": str(final), "type": "hard_math",
+                "think_hint": (f"Up {pct1}%: {base} + {base*pct1//100} = {after1}. "
+                              f"Down {pct2}%: {after1} - {after1*pct2//100} = {final}")
+            })
 
-        if ptype == "arithmetic":
-            a, b = random.randint(10, 999), random.randint(10, 999)
-            op = random.choice(["+", "-", "*"])
-            if op == "+":
-                answer = a + b
-            elif op == "-":
-                answer = a - b
-            else:
-                a, b = random.randint(2, 50), random.randint(2, 50)
-                answer = a * b
+        elif ptype == "rate_comparison":
+            speed1 = random.randint(30, 80)
+            time1 = random.randint(2, 6)
+            speed2 = random.randint(40, 100)
+            time2 = random.randint(1, 5)
+            dist1 = speed1 * time1
+            dist2 = speed2 * time2
+            diff = abs(dist1 - dist2)
+            who = "first" if dist1 > dist2 else "second"
             problems.append({
-                "question": f"What is {a} {op} {b}?",
-                "answer": str(answer),
-                "type": "math_arithmetic"
+                "question": (f"Car A drives {speed1} mph for {time1} hours. "
+                            f"Car B drives {speed2} mph for {time2} hours. "
+                            f"How much further did the car that drove more go?"),
+                "answer": str(diff), "type": "hard_math",
+                "think_hint": f"Car A: {dist1}mi. Car B: {dist2}mi. Diff: {diff}mi."
             })
 
-        elif ptype == "word":
-            templates = [
-                lambda: (f"A store sells apples for ${(p:=random.randint(1,5))} each. If you buy {(n:=random.randint(3,20))} apples, how much do you spend?", str(p*n)),
-                lambda: (f"A train travels at {(s:=random.randint(30,120))} mph for {(h:=random.randint(1,8))} hours. How many miles does it travel?", str(s*h)),
-                lambda: (f"If {(n:=random.randint(4,12))} friends split a ${(t:=random.randint(2,20)*n)} bill equally, how much does each person pay?", str(t//n)),
-                lambda: (f"A rectangle has length {(l:=random.randint(3,20))} and width {(w:=random.randint(3,20))}. What is its area?", str(l*w)),
-            ]
-            q, a = random.choice(templates)()
-            problems.append({"question": q, "answer": a, "type": "math_word"})
-
-        elif ptype == "percentage":
-            base = random.choice([50, 100, 200, 250, 400, 500, 1000])
-            pct = random.choice([10, 15, 20, 25, 30, 50, 75])
-            answer = base * pct // 100
+        elif ptype == "sequence_hard":
+            # Non-obvious sequences
+            seq_type = random.choice(["quadratic", "fibonacci_like", "alternating"])
+            if seq_type == "quadratic":
+                a, b, c = random.randint(1, 3), random.randint(1, 5), random.randint(0, 10)
+                seq = [a*n*n + b*n + c for n in range(1, 6)]
+                next_val = a*36 + b*6 + c
+            elif seq_type == "fibonacci_like":
+                a, b = random.randint(1, 5), random.randint(1, 5)
+                seq = [a, b]
+                for _ in range(4):
+                    seq.append(seq[-1] + seq[-2])
+                next_val = seq[-1] + seq[-2]
+                seq = seq[:5]
+            else:  # alternating
+                start = random.randint(1, 10)
+                step1 = random.randint(2, 5)
+                step2 = random.randint(1, 3)
+                seq = [start]
+                for i in range(4):
+                    if i % 2 == 0:
+                        seq.append(seq[-1] + step1)
+                    else:
+                        seq.append(seq[-1] - step2)
+                # Next follows the pattern
+                next_val = seq[-1] + step1 if len(seq) % 2 == 1 else seq[-1] - step2
             problems.append({
-                "question": f"What is {pct}% of {base}?",
-                "answer": str(answer),
-                "type": "math_percentage"
+                "question": f"What comes next: {', '.join(map(str, seq))}?",
+                "answer": str(next_val), "type": "hard_math",
             })
 
-        elif ptype == "fraction":
-            n = random.randint(1, 10)
-            d = random.choice([2, 3, 4, 5, 8, 10])
-            total = d * random.randint(2, 10)
-            answer = total * n // d
+    # --- HARD LOGIC: longer chains, negations, misdirection ---
+    logic_templates = [
+        # 4+ entity ordering
+        ("Amy is taller than Bob. Carol is shorter than Bob but taller than Dave. "
+         "Eve is taller than Amy. Who is the shortest?",
+         "dave", "Eve > Amy > Bob > Carol > Dave. Dave is shortest."),
+        ("In a tournament: A beat B, C beat A, D beat C, B beat D. Who beat the most players?",
+         "1", "Each player beat exactly 1 other player (it's circular)."),
+        # Negation chains
+        ("If it's not true that all cats are black, and Fluffy is a cat, "
+         "can we conclude Fluffy is not black?",
+         "no", "We can't conclude either way — some cats might be black, some not."),
+        ("None of the winners cheated. Tom didn't cheat. Did Tom win?",
+         "no", "Not cheating is necessary but not sufficient for winning."),
+        # Conditional logic
+        ("If it rains, the ground is wet. The ground is wet. Did it rain?",
+         "no", "The ground could be wet for other reasons (sprinkler, etc). Affirming the consequent."),
+        ("If it rains, the ground is wet. It didn't rain. Is the ground dry?",
+         "no", "The ground could still be wet from other causes. Denying the antecedent."),
+        ("If A then B. If B then C. A is true. Is C true?",
+         "yes", "A→B→C. A is true, so B is true, so C is true. Modus ponens chain."),
+        ("If A then B. If B then C. C is false. Is A true?",
+         "no", "C is false means B must be false (contrapositive), which means A must be false."),
+        # Set theory
+        ("In a class of 30 students, 18 play soccer and 15 play basketball. "
+         "At least how many play both?",
+         "3", "18 + 15 = 33. Must overlap by at least 33 - 30 = 3."),
+        ("A group has 40 people. 25 speak English, 20 speak French, and 10 speak both. "
+         "How many speak neither?",
+         "5", "English or French: 25 + 20 - 10 = 35. Neither: 40 - 35 = 5."),
+    ]
+
+    for _ in range(cfg.num_hard_logic):
+        if logic_templates:
+            q, a, hint = random.choice(logic_templates)
             problems.append({
-                "question": f"What is {n}/{d} of {total}?",
-                "answer": str(answer),
-                "type": "math_fraction"
+                "question": q, "answer": a, "type": "hard_logic",
+                "think_hint": hint
             })
 
+    # Also generate parameterized ordering problems (harder: 5-6 entities)
+    for _ in range(cfg.num_hard_logic // 2):
+        names = random.sample(["Amy", "Bob", "Carol", "Dave", "Eve", "Frank"], 5)
+        # Create a random ordering
+        order = list(range(5))
+        random.shuffle(order)
+        # Generate comparison clues (not all pairs — make them work it out)
+        clues = []
+        for i in range(4):
+            a_idx = order[i]
+            b_idx = order[i + 1]
+            clues.append(f"{names[a_idx]} is taller than {names[b_idx]}")
+        random.shuffle(clues)
+        tallest = names[order[0]]
+        shortest = names[order[4]]
+        q_type = random.choice(["tallest", "shortest"])
+        answer = tallest.lower() if q_type == "tallest" else shortest.lower()
+        problems.append({
+            "question": f"{'. '.join(clues)}. Who is the {q_type}?",
+            "answer": answer, "type": "hard_logic",
+        })
+
+    # --- HARD TRICKS: LLM failure modes ---
+    tricks = [
+        ("How many times can you subtract 5 from 25?",
+         "once", "Only once — after that it's 20, not 25."),
+        ("How many months have 28 days?",
+         "all", "All 12 months have at least 28 days."),
+        ("I have 6 eggs. I broke 2, cooked 2, and ate 2. How many eggs do I have left?",
+         "4", "You broke 2 to cook them, and ate the cooked ones. Same 2 eggs through the process. 6-2=4."),
+        ("A doctor gives you 3 pills and says take one every 30 minutes. How long do they last?",
+         "60", "Take first at 0 min, second at 30 min, third at 60 min. Total: 60 minutes."),
+        ("How many times does the digit 9 appear between 1 and 100?",
+         "20", "9,19,29,39,49,59,69,79,89 (nine times in ones) + 90-99 (ten times in tens, plus 99 double-counts). Total: 20."),
+        ("If you overtake the last person in a race, what position are you in?",
+         "impossible", "You can't overtake the last person — if you're behind them, YOU are last."),
+        ("A bat and ball cost $1.10 total. The bat costs $1 more than the ball. How much is the ball?",
+         "5", "Ball = x, Bat = x+1.00. Total: 2x+1.00=1.10. x=0.05. Ball costs $0.05 or 5 cents."),
+        ("If 5 machines take 5 minutes to make 5 widgets, how long for 100 machines to make 100 widgets?",
+         "5", "Each machine makes 1 widget in 5 minutes. 100 machines make 100 widgets in 5 minutes."),
+        ("You're in a dark room with a candle, a wood stove, and a gas lamp. You have one match. What do you light first?",
+         "match", "You light the match first — you need it to light anything else."),
+        ("Is it legal for a man to marry his widow's sister?",
+         "no", "If he has a widow, he's dead. Dead people can't marry."),
+    ]
+    for _ in range(cfg.num_hard_tricks):
+        q, a, hint = random.choice(tricks)
+        problems.append({
+            "question": q, "answer": a, "type": "hard_trick",
+            "think_hint": hint
+        })
+
+    # --- CODE REASONING (no actual code execution, just logic) ---
+    code_problems = [
+        ("What does this print?\nx = 5\nx = x + 3\nprint(x)", "8",
+         "x starts at 5, then x = 5+3 = 8. Prints 8."),
+        ("What does this print?\nfor i in range(3): print(i)\n(List all numbers printed)", "0 1 2",
+         "range(3) gives 0, 1, 2."),
+        ("What's wrong with this code?\ndef add(a, b):\n  return a - b", "subtracts instead of adds",
+         "Function named 'add' but uses minus operator."),
+        ("What does this evaluate to?\nTrue and False or True", "true",
+         "(True and False) = False. False or True = True."),
+        ("After this code runs, what is x?\nx = [1,2,3]\ny = x\ny.append(4)\nprint(len(x))", "4",
+         "y = x makes y point to same list. Appending to y also changes x. len(x) = 4."),
+    ]
+    for _ in range(cfg.num_hard_coding):
+        q, a, hint = random.choice(code_problems)
+        problems.append({
+            "question": q, "answer": a.lower(), "type": "hard_coding",
+            "think_hint": hint
+        })
+
+    random.shuffle(problems)
+    print(f"  Generated {len(problems)} hard problems")
+    print(f"    Math: {cfg.num_hard_math}, Logic: {cfg.num_hard_logic + cfg.num_hard_logic//2}, "
+          f"Tricks: {cfg.num_hard_tricks}, Code: {cfg.num_hard_coding}")
+
     return problems
 
 
 # ============================================================
-# STEP 3: SCORE — Verified rewards (no learned reward model)
+# STEP 3: GENERATE & SCORE WITH COT
 # ============================================================
 
-def verify_answer(problem, model_answer):
-    """
-    Verified reward: uses the smart verify from grpo_reason.
-    Handles verify_key for trick questions.
-    """
-    # Use verify_key if available (trick questions have separate verify keys)
-    check_problem = dict(problem)
-    if "verify_key" in check_problem:
-        check_problem["answer"] = check_problem["verify_key"]
-    from .grpo_reason import verify_answer as smart_verify
-    return smart_verify(check_problem, model_answer)
+def build_cot_prompt(question: str) -> str:
+    """Build prompt that encourages chain-of-thought reasoning."""
+    return (
+        f"<|im_start|>user\n{question}\n"
+        f"Think step by step before giving your final answer.<|im_end|>\n"
+        f"<|im_start|>assistant\n<think>\n"
+    )
 
 
-def generate_and_score(model, tokenizer, problems, cfg, eos_id):
+def generate_and_score(model, tokenizer, problems, cfg, eos_id, resume_from=0):
     """
-    Inference scaling: generate N candidates per problem, keep the best.
-    This is the 70-80% of the cost budget (from test_16).
+    Generate CoT candidates, score them, return winning pairs.
+    Saves progress every batch_save_every problems.
     """
-    print(f"\n=== STEP 2-3: GENERATE & SCORE ({len(problems)} problems, {cfg.num_candidates} candidates each) ===")
+    print(f"\n=== STEP 3: GENERATE & SCORE ({len(problems)} problems, {cfg.num_candidates} candidates) ===")
+    gen_start = time.time()
+
+    progress_path = Path(cfg.progress_file)
+    progress_path.parent.mkdir(parents=True, exist_ok=True)
+
+    winning_pairs = []
+    losing_pairs = []
+
+    if resume_from > 0 and progress_path.exists():
+        with open(progress_path) as f:
+            saved = json.load(f)
+            winning_pairs = saved.get("winning_pairs", [])
+            losing_pairs = saved.get("losing_pairs", [])
+        print(f"  Resumed from problem {resume_from}, {len(winning_pairs)} winners loaded")
 
-    winning_pairs = []  # (question_chat, best_answer_chat) pairs for training
     total_correct = 0
+    total_attempted = resume_from
 
-    for i, prob in enumerate(problems):
-        question = prob["question"]
-        prompt = f"<|im_start|>user\n{question}<|im_end|>\n<|im_start|>assistant\n"
+    for i in range(resume_from, len(problems)):
+        prob = problems[i]
+        prompt = build_cot_prompt(prob["question"])
         ids = tokenizer(prompt, return_tensors="pt").to(model.device)
 
-        # Generate N candidates
-        candidates = []
+        correct_responses = []
+        wrong_responses = []
+
         for _ in range(cfg.num_candidates):
             out = model.generate(
                 **ids, max_new_tokens=cfg.max_gen_tokens,
                 do_sample=True, temperature=cfg.temperature,
                 eos_token_id=eos_id
             )
-            answer = tokenizer.decode(out[0][ids.input_ids.shape[1]:], skip_special_tokens=True)
-            score = verify_answer(prob, answer)
-            candidates.append((answer, score))
+            response = tokenizer.decode(out[0][ids.input_ids.shape[1]:], skip_special_tokens=True)
 
-        # Pick the best candidate (highest score, shortest if tied)
-        correct_candidates = [(a, s) for a, s in candidates if s > 0]
+            # Use verify_key if it exists (trick questions)
+            check_prob = dict(prob)
+            if "verify_key" in check_prob:
+                check_prob["answer"] = check_prob["verify_key"]
+            score = smart_verify(check_prob, response)
 
-        if correct_candidates:
-            # Among correct answers, prefer shorter ones (more concise)
-            best = min(correct_candidates, key=lambda x: len(x[0]))
-            total_correct += 1
-
-            # Format as chat for training
-            chat = f"<|im_start|>user\n{question}<|im_end|>\n<|im_start|>assistant\n{best[0]}<|im_end|>"
-            winning_pairs.append(chat)
+            if score > 0:
+                correct_responses.append(response)
+            else:
+                wrong_responses.append(response)
 
-        if (i + 1) % 50 == 0:
-            pct = total_correct / (i + 1) * 100
-            print(f"  [{i+1}/{len(problems)}] Correct so far: {total_correct}/{i+1} ({pct:.0f}%)")
+        total_attempted += 1
 
-    pct = total_correct / len(problems) * 100
-    print(f"  TOTAL: {total_correct}/{len(problems)} correct ({pct:.0f}%)")
-    print(f"  Training pairs: {len(winning_pairs)}")
+        if correct_responses:
+            total_correct += 1
+            best = min(correct_responses, key=len)  # Shortest correct = most concise
+            chat = (
+                f"<|im_start|>user\n{prob['question']}\n"
+                f"Think step by step before giving your final answer.<|im_end|>\n"
+                f"<|im_start|>assistant\n{best}<|im_end|>"
+            )
+            winning_pairs.append(chat)
 
-    return winning_pairs
+            if wrong_responses:
+                worst = max(wrong_responses, key=len)
+                losing_pairs.append(
+                    f"<|im_start|>user\n{prob['question']}<|im_end|>\n"
+                    f"<|im_start|>assistant\n{worst}<|im_end|>"
+                )
+
+        # Progress
+        if (i + 1) % cfg.batch_save_every == 0 or i == len(problems) - 1:
+            pct = total_correct / max(1, total_attempted) * 100
+            elapsed = time.time() - gen_start
+            rate = (i + 1 - resume_from) / max(1, elapsed)
+            eta = (len(problems) - i - 1) / max(0.001, rate) / 60
+            print(f"  [{i+1}/{len(problems)}] Correct: {total_correct}/{total_attempted} ({pct:.0f}%) "
+                  f"| Winners: {len(winning_pairs)} | ETA: {eta:.0f}min")
+
+            with open(progress_path, "w") as f:
+                json.dump({
+                    "winning_pairs": winning_pairs,
+                    "losing_pairs": losing_pairs,
+                    "problems_completed": i + 1,
+                    "total_correct": total_correct,
+                    "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+                }, f)
+
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+    fail_rate = 100 - (total_correct / max(1, total_attempted) * 100)
+    print(f"\n  FINAL: {total_correct}/{total_attempted} correct "
+          f"({total_correct/max(1,total_attempted)*100:.0f}%)")
+    print(f"  Failure rate: {fail_rate:.0f}% "
+          f"({'GOOD — enough contrast for learning' if 15 < fail_rate < 60 else 'WARNING — might be too easy or too hard'})")
+    print(f"  Winners: {len(winning_pairs)} | Losers: {len(losing_pairs)}")
+
+    return winning_pairs, losing_pairs
 
 
 # ============================================================
-# STEP 4: TRAIN — Short GRPO/SFT on winning answers
+# STEP 4: TRAIN — SFT on winning CoT chains
 # ============================================================
 
 def train_on_winners(model, tokenizer, winning_pairs, cfg):
     """
-    Train on the correct answers only (STaR approach).
-    Short training — we're making small nudges, not retraining.
+    Train on correct chain-of-thought responses (STaR approach).
+    Targets layers 16-28 for reasoning improvement.
     """
-    print(f"\n=== STEP 4: TRAIN ON WINNERS ({len(winning_pairs)} pairs) ===")
+    print(f"\n=== STEP 4: TRAIN ON WINNERS ({len(winning_pairs)} chains) ===")
 
-    if len(winning_pairs) < 10:
+    if len(winning_pairs) < 20:
         print("  Too few winning pairs — skipping training")
         return model
 
@@ -320,18 +514,22 @@ def train_on_winners(model, tokenizer, winning_pairs, cfg):
     from transformers import TrainingArguments, Trainer
     from torch.utils.data import Dataset
 
-    # LoRA — small rank for targeted improvement
+    # Parse target layers
+    layer_start, layer_end = map(int, cfg.target_layers.split("-"))
+    target_layers = list(range(layer_start, layer_end + 1))
+
     lora_config = LoraConfig(
         r=cfg.lora_r, lora_alpha=cfg.lora_alpha, lora_dropout=0.0,
         target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                         "gate_proj", "up_proj", "down_proj"],
+        layers_to_transform=target_layers,
         bias="none", task_type=TaskType.CAUSAL_LM,
     )
     model = get_peft_model(model, lora_config)
     model.print_trainable_parameters()
 
-    class WinnerDataset(Dataset):
-        def __init__(self, texts, tokenizer, max_len=512):
+    class CoTDataset(Dataset):
+        def __init__(self, texts, tokenizer, max_len=1024):
             self.data = []
             for t in texts:
                 e = tokenizer(t, truncation=True, max_length=max_len,
@@ -344,12 +542,13 @@ def train_on_winners(model, tokenizer, winning_pairs, cfg):
         def __len__(self): return len(self.data)
         def __getitem__(self, i): return self.data[i]
 
-    dataset = WinnerDataset(winning_pairs, tokenizer)
+    dataset = CoTDataset(winning_pairs, tokenizer)
 
     out_dir = Path(cfg.output_dir) / "train_output"
     out_dir.mkdir(parents=True, exist_ok=True)
 
     total_steps = (len(dataset) * cfg.train_epochs) // (cfg.train_batch * cfg.train_grad_accum)
+    print(f"  Steps: ~{total_steps} | Target layers: {cfg.target_layers}")
 
     args = TrainingArguments(
         output_dir=str(out_dir),
@@ -358,10 +557,10 @@ def train_on_winners(model, tokenizer, winning_pairs, cfg):
         gradient_accumulation_steps=cfg.train_grad_accum,
         learning_rate=cfg.learning_rate,
         bf16=True,
-        logging_steps=max(1, total_steps // 10),
+        logging_steps=max(1, total_steps // 20),
         save_strategy="steps",
-        save_steps=max(50, total_steps // 4),
-        save_total_limit=1,
+        save_steps=cfg.save_steps,
+        save_total_limit=2,
         warmup_ratio=0.05,
         lr_scheduler_type="cosine",
         optim="adamw_torch",
@@ -373,91 +572,120 @@ def train_on_winners(model, tokenizer, winning_pairs, cfg):
         train_dataset=dataset, args=args
     )
 
-    print(f"  Training: ~{total_steps} steps")
+    print("  Training...")
     trainer.train()
 
-    # Merge LoRA FIRST, then clean checkpoints (safer)
     print("  Merging LoRA...")
     merged = model.merge_and_unload()
     gc.collect()
 
-    import shutil
     shutil.rmtree(str(out_dir), ignore_errors=True)
+    gc.collect()
 
     return merged
 
 
 # ============================================================
-# STEP 5: BENCHMARK — Measure improvement
+# STEP 5: BENCHMARK
 # ============================================================
 
 def benchmark(model, tokenizer, eos_id):
-    """Run the standard benchmark to measure improvement."""
+    """Comprehensive reasoning benchmark."""
     print("\n=== STEP 5: BENCHMARK ===")
-
     results = {}
 
-    def ask(prompt):
-        p = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    def ask(prompt, use_cot=False):
+        if use_cot:
+            p = build_cot_prompt(prompt)
+        else:
+            p = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
         ids = tokenizer(p, return_tensors="pt").to(model.device)
-        out = model.generate(**ids, max_new_tokens=200, do_sample=False, eos_token_id=eos_id)
+        out = model.generate(**ids, max_new_tokens=500, do_sample=False, eos_token_id=eos_id)
         return tokenizer.decode(out[0][ids.input_ids.shape[1]:], skip_special_tokens=True)
 
-    # Math — using smart verify
-    math_tests = [("7+8", "15"), ("123+456", "579"), ("1000-387", "613"), ("12*13", "156"), ("144/12", "12")]
-    math_correct = sum(1 for q, e in math_tests if verify_answer({"answer": e}, ask(f"What is {q}? Give just the number.")) > 0)
-    results["basic_math"] = f"{math_correct}/5"
-    print(f"  Math: {math_correct}/5")
-
-    # Reasoning — using smart verify
+    # Basic math
+    math_tests = [("7+8", "15"), ("123+456", "579"), ("1000-387", "613"),
+                  ("12*13", "156"), ("144/12", "12")]
+    mc = sum(1 for q, e in math_tests
+             if smart_verify({"answer": e}, ask(f"What is {q}? Give just the number.")) > 0)
+    results["math"] = f"{mc}/5"
+    print(f"  Math: {mc}/5")
+
+    # Hard math (the stuff GRPO couldn't handle)
+    hard_math = [
+        ("A stock is worth $200. It goes up 25%, then drops 20%. What is it worth?", "200"),
+        ("You have 50 cookies. You eat 1/5, give 10 away, then split the rest equally among 4 friends. How many each?", "7"),
+        ("Car A drives 60mph for 3 hours. Car B drives 80mph for 2 hours. How much further did Car A go?", "20"),
+    ]
+    hmc = 0
+    for q, e in hard_math:
+        a = ask(q, use_cot=True)
+        correct = smart_verify({"answer": e}, a) > 0
+        hmc += correct
+        status = "OK" if correct else "FAIL"
+        answer_display = a.split("</think>")[-1].strip() if "</think>" in a else a
+        print(f"    {status}: {q[:55]}... -> {answer_display[:80]}")
+    results["hard_math"] = f"{hmc}/3"
+    print(f"  Hard math: {hmc}/3")
+
+    # Reasoning with CoT
     reason_tests = [
-        ("If all roses are flowers and all flowers need water, do roses need water?", "yes"),
         ("Which is heavier: a pound of feathers or a pound of bricks?", "same"),
         ("If yesterday was Monday, what day is tomorrow?", "wednesday"),
         ("A farmer has 17 sheep. All but 9 die. How many are left?", "9"),
-        ("If you have 5 apples and take away 3, how many do YOU have?", "3"),
+        ("If you're running and pass the person in 2nd place, what position are you in?", "2nd"),
+        ("How many times can you subtract 5 from 25?", "once"),
+        ("All mammals breathe air. Whales are mammals. Do whales breathe air?", "yes"),
+        ("How many months have 28 days?", "all"),
+        ("If A > B and B > C, who is smallest?", "c"),
+        ("A bat and ball cost $1.10. The bat costs $1 more than the ball. How much is the ball?", "5"),
+        ("5 machines take 5 min to make 5 widgets. How long for 100 machines to make 100 widgets?", "5"),
     ]
-    reason_correct = 0
+    rc = 0
     for q, expected in reason_tests:
-        a = ask(q)
-        correct = verify_answer({"answer": expected}, a) > 0
-        reason_correct += correct
-        print(f"    {'OK' if correct else 'FAIL'}: {q[:50]}... -> {a[:60]}")
-    results["reasoning"] = f"{reason_correct}/5"
-    print(f"  Reasoning: {reason_correct}/5")
-
-    # Word problems — using smart verify
-    wp_tests = [
-        ("A train travels 60 mph for 2.5 hours. How far does it go?", "150"),
-        ("If 3 shirts cost $45, how much do 7 shirts cost?", "105"),
-        ("I have 24 cookies split equally among 6 friends. How many each?", "4"),
+        a = ask(q, use_cot=True)
+        correct = smart_verify({"answer": expected}, a) > 0
+        rc += correct
+        status = "OK" if correct else "FAIL"
+        answer_display = a.split("</think>")[-1].strip() if "</think>" in a else a
+        print(f"    {status}: {q[:55]}... -> {answer_display[:80]}")
+    results["reasoning"] = f"{rc}/10"
+    print(f"  Reasoning: {rc}/10")
+
+    # Logic
+    logic_tests = [
+        ("If it rains, the ground is wet. The ground is wet. Did it rain?", "no"),
+        ("None of the winners cheated. Tom didn't cheat. Did Tom win?", "no"),
+        ("If A then B. If B then C. A is true. Is C true?", "yes"),
     ]
-    wp_correct = sum(1 for q, e in wp_tests if verify_answer({"answer": e}, ask(q)) > 0)
-    results["word_problems"] = f"{wp_correct}/3"
-    print(f"  Word problems: {wp_correct}/3")
+    lc = 0
+    for q, expected in logic_tests:
+        a = ask(q, use_cot=True)
+        correct = smart_verify({"answer": expected}, a) > 0
+        lc += correct
+        status = "OK" if correct else "FAIL"
+        answer_display = a.split("</think>")[-1].strip() if "</think>" in a else a
+        print(f"    {status}: {q[:55]}... -> {answer_display[:80]}")
+    results["logic"] = f"{lc}/3"
+    print(f"  Logic: {lc}/3")
 
     # Perplexity
     test_text = "The quick brown fox jumps over the lazy dog. Machine learning models can process natural language."
     enc = tokenizer(test_text, return_tensors="pt").to(model.device)
     with torch.no_grad():
         loss = model(**enc, labels=enc.input_ids).loss.item()
-    ppl = math.exp(loss)
-    results["perplexity"] = f"{ppl:.2f}"
-    print(f"  Perplexity: {ppl:.2f}")
+    results["perplexity"] = f"{math.exp(loss):.2f}"
+    print(f"  Perplexity: {results['perplexity']}")
 
     return results
 
 
 # ============================================================
-# MAIN: Run one self-improvement cycle
+# MAIN
 # ============================================================
 
 def run_cycle(cfg: SelfImproveConfig = None, cycle_num: int = 1):
-    """
-    Run one complete self-improvement cycle.
-
-    Returns path to improved model.
-    """
+    """Run one complete self-improvement cycle."""
     if cfg is None:
         cfg = SelfImproveConfig()
 
@@ -468,9 +696,16 @@ def run_cycle(cfg: SelfImproveConfig = None, cycle_num: int = 1):
     print(f"Started: {time.strftime('%H:%M:%S')}")
     print("=" * 60)
 
+    # Check for resume
+    progress_path = Path(cfg.progress_file)
+    resume_from = 0
+    if progress_path.exists():
+        with open(progress_path) as f:
+            saved = json.load(f)
+            resume_from = saved.get("problems_completed", 0)
+
     # Load model
     from transformers import AutoModelForImageTextToText, AutoTokenizer
-
     print("\nLoading model...")
     model = AutoModelForImageTextToText.from_pretrained(
         cfg.model_path, dtype=torch.bfloat16,
@@ -479,52 +714,71 @@ def run_cycle(cfg: SelfImproveConfig = None, cycle_num: int = 1):
     tokenizer = AutoTokenizer.from_pretrained(cfg.model_path, trust_remote_code=True)
     eos_id = tokenizer.convert_tokens_to_ids("<|im_end|>")
 
-    # Step 1: Diagnose
-    weaknesses = diagnose_weaknesses(model, tokenizer, eos_id)
-
-    # Step 2: Generate problems
-    print("\n=== STEP 2: GENERATING PROBLEMS ===")
-    problems = []
-    problems.extend(generate_reasoning_problems())
-    print(f"  Reasoning problems: {len(problems)}")
-    math_probs = generate_math_problems(cfg.num_math_problems)
-    problems.extend(math_probs)
-    print(f"  Math problems: {len(math_probs)}")
-    print(f"  Total: {len(problems)}")
+    # Pre-benchmark
+    print("\n--- PRE-TRAINING BENCHMARK ---")
+    pre_results = benchmark(model, tokenizer, eos_id)
 
-    random.shuffle(problems)
-
-    # Step 3: Generate candidates and score
-    winning_pairs = generate_and_score(model, tokenizer, problems, cfg, eos_id)
+    # Step 1: Diagnose
+    diagnosis_path = Path(cfg.output_dir) / "diagnosis.json"
+    diagnosis_path.parent.mkdir(parents=True, exist_ok=True)
+    weaknesses = diagnose_weaknesses(model, tokenizer, eos_id, save_path=str(diagnosis_path))
+
+    # Step 2: Generate hard problems
+    print("\n=== STEP 2: GENERATING HARD PROBLEMS ===")
+    random.seed(42 + cycle_num)  # Different problems each cycle
+    problems = generate_hard_problems(cfg)
+
+    # Step 3: Generate & score
+    if resume_from < len(problems):
+        winning_pairs, losing_pairs = generate_and_score(
+            model, tokenizer, problems, cfg, eos_id, resume_from=resume_from
+        )
+    else:
+        with open(progress_path) as f:
+            saved = json.load(f)
+            winning_pairs = saved["winning_pairs"]
+            losing_pairs = saved.get("losing_pairs", [])
 
-    # Step 4: Train on winners
+    # Step 4: Train
     model = train_on_winners(model, tokenizer, winning_pairs, cfg)
 
     # Save improved model
-    improved_dir = Path(cfg.output_dir) / f"cycle_{cycle_num}"
-    improved_dir.mkdir(parents=True, exist_ok=True)
-    print(f"\nSaving improved model to {improved_dir}...")
-    model.save_pretrained(str(improved_dir), safe_serialization=True)
-    tokenizer.save_pretrained(str(improved_dir))
-    sz = sum(f.stat().st_size for f in improved_dir.glob("*.safetensors")) / 1e9
-    print(f"SAVED: {improved_dir} ({sz:.1f} GB)")
-
-    # Step 5: Benchmark
-    results = benchmark(model, tokenizer, eos_id)
-
-    # Save results
-    results_file = improved_dir / "benchmark_results.json"
-    results["cycle"] = cycle_num
-    results["timestamp"] = time.strftime("%Y-%m-%d %H:%M:%S")
-    results["duration_min"] = (time.time() - start) / 60
-    with open(results_file, "w") as f:
-        json.dump(results, f, indent=2)
-
+    save_dir = Path(cfg.output_dir) / f"cycle_{cycle_num}"
+    save_dir.mkdir(parents=True, exist_ok=True)
+    print(f"\nSaving improved model to {save_dir}...")
+    model.save_pretrained(str(save_dir), safe_serialization=True)
+    tokenizer.save_pretrained(str(save_dir))
+    sz = sum(f.stat().st_size for f in save_dir.glob("*.safetensors")) / 1e9
+    print(f"SAVED: {save_dir} ({sz:.1f} GB)")
+
+    # Step 5: Post-benchmark
+    print("\n--- POST-TRAINING BENCHMARK ---")
+    post_results = benchmark(model, tokenizer, eos_id)
+
+    # Compare & save report
     elapsed = (time.time() - start) / 60
     print(f"\n{'=' * 60}")
     print(f"CYCLE {cycle_num} COMPLETE — {elapsed:.1f} min")
-    print(f"Results: {results}")
-    print(f"Model saved to: {improved_dir}")
+    print(f"PRE:  {pre_results}")
+    print(f"POST: {post_results}")
+    print(f"Model: {save_dir}")
     print(f"{'=' * 60}")
 
-    return str(improved_dir)
+    report = {
+        "cycle": cycle_num,
+        "pre_benchmark": pre_results,
+        "post_benchmark": post_results,
+        "problems_total": len(problems),
+        "winning_pairs": len(winning_pairs),
+        "losing_pairs": len(losing_pairs),
+        "duration_min": elapsed,
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    with open(save_dir / "cycle_report.json", "w") as f:
+        json.dump(report, f, indent=2)
+
+    return str(save_dir)
+
+
+if __name__ == "__main__":
+    run_cycle()