Upload 56 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 hugging/td_lang/__pycache__/compiler.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
+hugging/td_lang/__pycache__/compiler.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

hugging/td_lang/__init__.py

@@ -27,6 +27,11 @@ Phase 2: diagnose, synth, train, debate
 Phase 3: fork, reset, prune, edit
 Phase 4: snapshot, report, data_contract, reward_contract
 Phase 5: CLI polish, --version, info command, --verbose
+Phase 6: fuse, absorb (easy merge)
+Phase 7: repeat, if/else (loop control)
+Phase 8: setup, on_error, notify, save (autopilot)
+Phase 9: schedule (time-based execution)
+Engine upgrades: QLoRA training, self-contained eval, model-generated synth problems
 
 Designed from interviews test_14 (10 commands) and test_17 (ForgeSpec 2.0).
 """

hugging/td_lang/ast_nodes.py

@@ -304,6 +304,28 @@ class OnErrorBlock:
     notify: bool = True              # Send ntfy notification on error
 
 
+# ============================================================================
+# PHASE 9 — SCHEDULE (time-based execution)
+# ============================================================================
+
+@dataclass
+class ScheduleCmd:
+    """Schedule a block of commands to run at a specific time or interval. (Phase 9)
+
+    Examples:
+        schedule "every 6h" { diagnose base; train base ... }
+        schedule "at 02:00" { train base on "data.jsonl" using grpo }
+        schedule "after 30m" { eval base -> results.json }
+
+    Patterns:
+        "every Nh/Nm" — repeat every N hours/minutes
+        "at HH:MM"    — run once at that time
+        "after Nh/Nm" — delay then run once
+    """
+    timing: str                     # "every 6h", "at 02:00", "after 30m"
+    body: List[Any] = field(default_factory=list)  # Commands inside the block
+
+
 # ============================================================================
 # BLOCKS (gates, budget, contracts, etc.)
 # ============================================================================
@@ -417,5 +439,6 @@ __all__ = [
     "BudgetBlock",
     "DataContractBlock",
     "RewardContractBlock",
+    "ScheduleCmd",
     "TDProgram",
 ]

hugging/td_lang/cli.py

@@ -21,7 +21,7 @@ from .ast_nodes import (
     SynthCmd, TrainCmd, DebateCmd, DiagnoseCmd,
     ForkCmd, ResetCmd, PruneCmd, EditCmd,
     FuseCmd, AbsorbCmd, RepeatBlock, IfBlock,
-    NotifyCmd, SaveCmd,
+    NotifyCmd, SaveCmd, ScheduleCmd,
     SnapshotCmd, ReportCmd,
 )
 
@@ -49,6 +49,7 @@ _PHASE_MAP = {
     SaveCmd: ("8", "save"),
     SnapshotCmd: ("4", "snapshot"),
     ReportCmd: ("4", "report"),
+    ScheduleCmd: ("9", "schedule"),
 }
 
 

hugging/td_lang/compiler.py

@@ -1,5 +1,5 @@
 """
-TD Lang Compiler — turns a TDProgram AST into readable Python code that calls td_fuse.
+TD Lang Compiler - turns a TDProgram AST into readable Python code that calls td_fuse.
 
 Phase 1 commands: load, merge, heal, eval, commit.
 Phase 2 commands: synth, train, debate, diagnose.
@@ -38,6 +38,7 @@ from .ast_nodes import (
     ResetCmd,
     RewardContractBlock,
     SaveCmd,
+    ScheduleCmd,
     SetupBlock,
     SnapshotCmd,
     SynthCmd,
@@ -46,7 +47,7 @@ from .ast_nodes import (
 )
 from .errors import TDCompileError
 
-# All command types are now implemented (Phase 1 + 2 + 3)
+# All command types are now implemented (Phase 1 + 2 + 3 + ... + 9)
 
 
 class TDCompiler:
@@ -86,25 +87,25 @@ class TDCompiler:
             elif isinstance(cmd, MergeCmd):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't merge into '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't merge into '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "{cmd.source}" as {cmd.target}',
                     )
             elif isinstance(cmd, (HealCmd, EvalCmd, CommitCmd)):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't use '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't use '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.target}',
                     )
             elif isinstance(cmd, (SynthCmd, TrainCmd, DebateCmd, DiagnoseCmd)):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't use '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't use '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.target}',
                     )
             elif isinstance(cmd, ForkCmd):
                 if cmd.source not in seen:
                     raise TDCompileError(
-                        f"Can't fork '{cmd.source}' — it hasn't been loaded yet.",
+                        f"Can't fork '{cmd.source}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.source}',
                     )
                 if cmd.alias in seen:
@@ -115,21 +116,21 @@ class TDCompiler:
             elif isinstance(cmd, (ResetCmd, PruneCmd, EditCmd)):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't use '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't use '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.target}',
                     )
             elif isinstance(cmd, SnapshotCmd):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't snapshot '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't snapshot '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.target}',
                     )
             elif isinstance(cmd, ReportCmd):
-                pass  # report has no target — always valid
+                pass  # report has no target - always valid
             elif isinstance(cmd, FuseCmd):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't fuse into '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't fuse into '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.target}',
                     )
                 if len(cmd.sources) < 1:
@@ -140,9 +141,13 @@ class TDCompiler:
             elif isinstance(cmd, AbsorbCmd):
                 if cmd.target not in seen:
                     raise TDCompileError(
-                        f"Can't absorb into '{cmd.target}' — it hasn't been loaded yet.",
+                        f"Can't absorb into '{cmd.target}' - it hasn't been loaded yet.",
                         hint=f'Add: load "model/path" as {cmd.target}',
                     )
+            elif isinstance(cmd, (RepeatBlock, IfBlock, ScheduleCmd)):
+                pass  # block commands - body validation happens at emit time
+            elif isinstance(cmd, (NotifyCmd, SaveCmd)):
+                pass  # utility commands - always valid
 
     # ---------------------------------------------------------------- Build script
     def _build_script(self, program: TDProgram) -> None:
@@ -158,7 +163,7 @@ Source: {source_name}
 Compiled: {timestamp}
 Hash: {source_hash}
 
-DO NOT EDIT — regenerate from the .td file instead.
+DO NOT EDIT - regenerate from the .td file instead.
 """'''
         )
         self._emit(doc)
@@ -282,6 +287,8 @@ DO NOT EDIT — regenerate from the .td file instead.
                 self._emit_notify(cmd, program)
             elif isinstance(cmd, SaveCmd):
                 self._emit_save(cmd, program)
+            elif isinstance(cmd, ScheduleCmd):
+                self._emit_schedule(cmd, program)
             self._emit("")
 
         self._emit_summary()
@@ -311,7 +318,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit("except ImportError:")
         self._indent += 1
-        self._emit('print("[td_lang] huggingface_hub not installed. Storing ref only — download will happen at merge time.")')
+        self._emit('print("[td_lang] huggingface_hub not installed. Storing ref only - download will happen at merge time.")')
         self._emit("_local_path = _model_ref")
         self._indent -= 1
         self._emit("except Exception as e:")
@@ -381,7 +388,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit(f'checkpoint = models.get("{cmd.target}", {{}}).get("checkpoint")')
         self._emit("if not checkpoint:")
         self._indent += 1
-        self._emit('print("[td_lang] WARNING: No checkpoint to heal — run a merge first.")')
+        self._emit('print("[td_lang] WARNING: No checkpoint to heal - run a merge first.")')
         self._indent -= 1
         self._emit("else:")
         self._indent += 1
@@ -400,42 +407,144 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
 
     def _emit_eval(self, cmd: EvalCmd) -> None:
+        """Generate self-contained evaluation - math, code, reasoning, perplexity.
+
+        No dependency on td_fuse. Tests the model on real tasks and returns
+        pass/fail plus scores per category. Uses 'improved' flag to track
+        whether the model got better vs previous eval.
+        """
         self._emit(f'print("[td_lang] Evaluating {cmd.target}...")')
         self._emit(f'checkpoint = models.get("{cmd.target}", {{}}).get("checkpoint")')
         self._emit("if not checkpoint:")
         self._indent += 1
-        self._emit('print("[td_lang] WARNING: No checkpoint to evaluate.")')
+        self._emit(f'checkpoint = models["{cmd.target}"]["model_ref"]')
         self._indent -= 1
-        self._emit("else:")
-        self._indent += 1
         self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer")
-        self._emit("import torch")
+        self._emit("import torch, re, ast")
         self._emit("tok = AutoTokenizer.from_pretrained(checkpoint)")
         self._emit("model = AutoModelForCausalLM.from_pretrained(")
         self._indent += 1
         self._emit('checkpoint, torch_dtype=torch.bfloat16, device_map="auto"')
         self._indent -= 1
         self._emit(")")
-        self._emit("eval_result = validate_merged_model(")
+        self._emit("model.eval()")
+        self._emit("")
+        self._emit("# Mini-benchmark: math, code, reasoning, perplexity")
+        self._emit("eval_tests = {")
+        self._indent += 1
+        self._emit('"math": [')
         self._indent += 1
-        self._emit("model=model, tokenizer=tok,")
-        self._emit("merged_sources=merged_stages,")
-        self._emit("cfg=MergeConfig(),")
+        self._emit('{"prompt": "What is 17 * 23? Answer with just the number.", "answer": "391"},')
+        self._emit('{"prompt": "What is 144 / 12? Answer with just the number.", "answer": "12"},')
+        self._emit('{"prompt": "What is 256 + 789? Answer with just the number.", "answer": "1045"},')
+        self._emit('{"prompt": "What is 15 squared? Answer with just the number.", "answer": "225"},')
+        self._emit('{"prompt": "What is the square root of 81? Answer with just the number.", "answer": "9"},')
         self._indent -= 1
-        self._emit(")")
-        self._emit(f'results["{cmd.target}_eval"] = eval_result')
+        self._emit("],")
+        self._emit('"code": [')
+        self._indent += 1
+        self._emit('{"prompt": "Write a Python function that returns the sum of a list. Just the function, nothing else.", "check": "def"},')
+        self._emit('{"prompt": "Write a Python function to check if a number is prime. Just the function.", "check": "def"},')
+        self._emit('{"prompt": "Write a Python one-liner list comprehension that squares numbers 1-10.", "check": "["},')
+        self._indent -= 1
+        self._emit("],")
+        self._emit('"reasoning": [')
+        self._indent += 1
+        self._emit('{"prompt": "If all dogs are animals, and all animals breathe, do all dogs breathe? Answer yes or no.", "answer": "yes"},')
+        self._emit('{"prompt": "A bat and ball cost $1.10 together. The bat costs $1 more than the ball. How much does the ball cost? Answer with just the number.", "answer": "0.05"},')
+        self._emit('{"prompt": "If it takes 5 machines 5 minutes to make 5 widgets, how long would it take 100 machines to make 100 widgets? Answer in minutes.", "answer": "5"},')
+        self._indent -= 1
+        self._emit("],")
+        self._indent -= 1
+        self._emit("}")
+        self._emit("")
+        self._emit("eval_result = {'overall': True, 'scores': {}, 'details': {}}")
+        self._emit("total_correct = 0")
+        self._emit("total_tests = 0")
+        self._emit("")
+        self._emit("for category, tests in eval_tests.items():")
+        self._indent += 1
+        self._emit("cat_correct = 0")
+        self._emit("cat_details = []")
+        self._emit("for test in tests:")
+        self._indent += 1
+        self._emit("total_tests += 1")
+        self._emit('inputs = tok(test["prompt"], return_tensors="pt").to(model.device)')
+        self._emit("with torch.no_grad():")
+        self._indent += 1
+        self._emit("output = model.generate(**inputs, max_new_tokens=256, do_sample=False, temperature=0.0)")
+        self._indent -= 1
+        self._emit("response = tok.decode(output[0], skip_special_tokens=True)")
+        self._emit('# Strip the prompt from the response if model echoes it')
+        self._emit('if response.startswith(test["prompt"]):')
+        self._indent += 1
+        self._emit('response = response[len(test["prompt"]):].strip()')
+        self._indent -= 1
+        self._emit("passed = False")
+        self._emit('if "answer" in test:')
+        self._indent += 1
+        self._emit('passed = test["answer"].lower() in response.lower()')
+        self._indent -= 1
+        self._emit('elif "check" in test:')
+        self._indent += 1
+        self._emit('passed = test["check"] in response')
+        self._emit("# Also try to parse as valid Python")
+        self._emit("try:")
+        self._indent += 1
+        self._emit("ast.parse(response)")
+        self._indent -= 1
+        self._emit("except SyntaxError:")
+        self._indent += 1
+        self._emit("passed = False  # Code doesn't compile")
+        self._indent -= 2
+        self._emit("if passed:")
+        self._indent += 1
+        self._emit("cat_correct += 1")
+        self._emit("total_correct += 1")
+        self._indent -= 1
+        self._emit('cat_details.append({"prompt": test["prompt"][:60], "passed": passed})')
+        self._indent -= 1
+        self._emit("score = cat_correct / max(len(tests), 1)")
+        self._emit('eval_result["scores"][category] = round(score, 3)')
+        self._emit('eval_result["details"][category] = cat_details')
+        self._emit('print(f"  {category}: {cat_correct}/{len(tests)} ({score:.0%})")')
+        self._indent -= 1
+        self._emit("")
+        self._emit("# Perplexity test (lower = model is more confident/coherent)")
+        self._emit('ppl_text = "The capital of France is Paris. Water boils at 100 degrees Celsius."')
+        self._emit('ppl_inputs = tok(ppl_text, return_tensors="pt").to(model.device)')
+        self._emit("with torch.no_grad():")
+        self._indent += 1
+        self._emit('ppl_loss = model(**ppl_inputs, labels=ppl_inputs["input_ids"]).loss')
+        self._indent -= 1
+        self._emit("perplexity = torch.exp(ppl_loss).item()")
+        self._emit('eval_result["perplexity"] = round(perplexity, 2)')
+        self._emit('eval_result["scores"]["perplexity"] = "pass" if perplexity < 20.0 else "fail"')
+        self._emit('_ppl_label = "pass" if perplexity < 20.0 else "FAIL - too high"')
+        self._emit('print(f"  perplexity: {perplexity:.2f} ({_ppl_label})")')
+        self._emit("")
+        self._emit("# Overall score")
+        self._emit("overall_score = total_correct / max(total_tests, 1)")
+        self._emit('eval_result["overall_score"] = round(overall_score, 3)')
+        self._emit('eval_result["overall"] = overall_score >= 0.5 and perplexity < 20.0')
+        self._emit('_overall_label = "PASS" if eval_result["overall"] else "FAIL"')
+        self._emit('print(f"  OVERALL: {total_correct}/{total_tests} ({overall_score:.0%}) - {_overall_label}")')
+        self._emit("")
+        self._emit("# Track improvement over previous eval")
         self._emit(f'hist_key = "{cmd.target}_eval_history"')
         self._emit("if hist_key not in results:")
         self._indent += 1
         self._emit("results[hist_key] = []")
         self._indent -= 1
-        self._emit("metric = 1.0 if eval_result.get('overall', False) else 0.0")
-        self._emit("results[hist_key].append(metric)")
+        self._emit("results[hist_key].append(overall_score)")
+        self._emit('eval_result["improved"] = len(results[hist_key]) < 2 or results[hist_key][-1] >= results[hist_key][-2]')
+        self._emit(f'results["{cmd.target}_eval"] = eval_result')
         self._emit(f'lineage["{cmd.target}"]["operations"].append({{')
         self._indent += 1
         self._emit('"op": "eval",')
         self._emit('"timestamp": datetime.now().isoformat(),')
-        self._emit('"result": eval_result,')
+        self._emit('"overall_score": overall_score,')
+        self._emit('"perplexity": perplexity,')
         self._indent -= 1
         self._emit("})")
         if cmd.output:
@@ -450,7 +559,6 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit('print("[td_lang] Eval results:", json.dumps(eval_result, indent=2, default=str))')
         self._emit("del model, tok")
         self._emit("import gc; gc.collect()")
-        self._indent -= 1
 
     def _emit_commit(self, cmd: CommitCmd, global_gates: Optional[GateBlock]) -> None:
         gates = cmd.gates or (global_gates.must_pass if global_gates else None)
@@ -484,7 +592,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._indent -= 1
             self._emit("if failed:")
             self._indent += 1
-            self._emit('raise TDGateError(failed, message="Commit blocked — gates failed")')
+            self._emit('raise TDGateError(failed, message="Commit blocked - gates failed")')
             self._indent -= 1
             self._emit("else:")
             self._indent += 1
@@ -523,7 +631,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit(f'checkpoint = models.get("{cmd.target}", {{}}).get("checkpoint")')
         self._emit("if not checkpoint:")
         self._indent += 1
-        self._emit('print("[td_lang] WARNING: No checkpoint — using model_ref instead.")')
+        self._emit('print("[td_lang] WARNING: No checkpoint - using model_ref instead.")')
         self._emit(f'checkpoint = models["{cmd.target}"]["model_ref"]')
         self._indent -= 1
         self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer")
@@ -559,11 +667,66 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit('print(f"  Response: {response[:200]}...")')
         self._emit("print()")
         self._indent -= 1
-        self._emit(f'results["{cmd.target}_diagnose"] = diagnose_results')
+        self._emit("")
+        self._emit("# Parse responses into structured weakness categories")
+        self._emit("import re as _re")
+        self._emit("weakness_categories = {")
+        self._indent += 1
+        self._emit("'math': ['math', 'arithmetic', 'calculation', 'algebra', 'geometry', 'calculus'],")
+        self._emit("'code': ['code', 'coding', 'programming', 'debug', 'syntax', 'algorithm'],")
+        self._emit("'logic': ['logic', 'reasoning', 'inference', 'fallac', 'deduction', 'chain'],")
+        self._emit("'factual': ['factual', 'hallucin', 'accuracy', 'knowledge', 'recall', 'memory'],")
+        self._emit("'creativity': ['creative', 'creativity', 'imagination', 'novel', 'original'],")
+        self._emit("'instruction': ['instruction', 'follow', 'format', 'comply', 'understand'],")
+        self._indent -= 1
+        self._emit("}")
+        self._emit("")
+        self._emit("weakness_scores = {cat: 0 for cat in weakness_categories}")
+        self._emit("for d in diagnose_results:")
+        self._indent += 1
+        self._emit("resp_lower = d['response'].lower()")
+        self._emit("for cat, keywords in weakness_categories.items():")
+        self._indent += 1
+        self._emit("for kw in keywords:")
+        self._indent += 1
+        self._emit("if kw in resp_lower:")
+        self._indent += 1
+        self._emit("weakness_scores[cat] += 1")
+        self._emit("break")
+        self._indent -= 3
+        self._indent -= 1
+        self._emit("")
+        self._emit("# Rank weaknesses by how many prompts mentioned them")
+        self._emit("ranked = sorted(weakness_scores.items(), key=lambda x: x[1], reverse=True)")
+        self._emit("top_weaknesses = [cat for cat, score in ranked if score > 0][:4]")
+        self._emit("if not top_weaknesses:")
+        self._indent += 1
+        self._emit("top_weaknesses = ['math', 'logic', 'code']  # safe defaults")
+        self._indent -= 1
+        self._emit("")
+        self._emit("diagnosis = {")
+        self._indent += 1
+        self._emit("'raw_responses': diagnose_results,")
+        self._emit("'weakness_scores': weakness_scores,")
+        self._emit("'top_weaknesses': top_weaknesses,")
+        self._emit("'ranked': ranked,")
+        self._indent -= 1
+        self._emit("}")
+        self._emit("print('[td_lang] Weakness ranking:')")
+        self._emit("for cat, score in ranked:")
+        self._indent += 1
+        self._emit("if score > 0:")
+        self._indent += 1
+        self._emit("print(f'  {cat}: mentioned in {score}/{len(diag_prompts)} prompts')")
+        self._indent -= 2
+        self._emit("print(f'[td_lang] Top weaknesses to target: {top_weaknesses}')")
+        self._emit("")
+        self._emit(f'results["{cmd.target}_diagnose"] = diagnosis')
         self._emit(f'lineage["{cmd.target}"]["operations"].append({{')
         self._indent += 1
         self._emit('"op": "diagnose",')
         self._emit('"n_prompts": len(diag_prompts),')
+        self._emit('"top_weaknesses": top_weaknesses,')
         self._emit('"timestamp": datetime.now().isoformat(),')
         self._indent -= 1
         self._emit("})")
@@ -572,7 +735,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("diag_path.parent.mkdir(parents=True, exist_ok=True)")
             self._emit('with open(diag_path, "w") as f:')
             self._indent += 1
-            self._emit("json.dump(diagnose_results, f, indent=2, default=str)")
+            self._emit("json.dump(diagnosis, f, indent=2, default=str)")
             self._indent -= 1
             self._emit('print(f"[td_lang] Diagnosis saved to {diag_path}")')
         self._emit("del model, tok")
@@ -604,20 +767,30 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit(")")
         self._emit("model.eval()")
         self._emit("")
-        self._emit("# Weakness-aware topic selection from diagnosis (if available)")
-        self._emit(f'diag = results.get("{cmd.target}_diagnose", [])')
+        self._emit("# Use structured diagnosis if available (upgraded diagnose outputs top_weaknesses)")
+        self._emit(f'diag = results.get("{cmd.target}_diagnose", {{}})')
+        self._emit("if isinstance(diag, dict) and 'top_weaknesses' in diag:")
+        self._indent += 1
+        self._emit("weak_topics = diag['top_weaknesses']")
+        self._emit("print(f'[td_lang] Targeting weaknesses from diagnosis: {weak_topics}')")
+        self._indent -= 1
+        self._emit("else:")
+        self._indent += 1
+        self._emit("# Fallback: scan raw responses for weakness keywords")
         self._emit("weak_topics = []")
-        self._emit("for d in diag:")
+        self._emit("raw = diag if isinstance(diag, list) else diag.get('raw_responses', [])")
+        self._emit("for d in raw:")
         self._indent += 1
         self._emit("resp = d.get('response', '')")
-        self._emit("for topic in ['math', 'code', 'logic', 'factual', 'long chain', 'tools']:")
+        self._emit("for topic in ['math', 'code', 'logic', 'factual']:")
         self._indent += 1
-        self._emit("if topic in resp.lower():")
+        self._emit("if topic in resp.lower() and topic not in weak_topics:")
         self._indent += 1
         self._emit("weak_topics.append(topic)")
         self._indent -= 1
         self._indent -= 1
         self._indent -= 1
+        self._indent -= 1
         self._emit("if not weak_topics:")
         self._indent += 1
         self._emit("weak_topics = ['math', 'code', 'logic', 'factual']")
@@ -637,21 +810,81 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit("}")
         self._emit("")
-        self._emit("def make_problem(domain: str) -> str:")
+        self._emit("# Seed problems - model generates MORE from these (not just these 4)")
+        self._emit("seed_problems = {")
+        self._indent += 1
+        self._emit("'math': [")
+        self._indent += 1
+        self._emit("'Compute (17*19 - 121) / 3',")
+        self._emit("'Find the derivative of x^3 + 2x^2 - 5x + 7',")
+        self._emit("'Solve for x: 3x + 7 = 22',")
+        self._emit("'What is the sum of the first 20 positive integers?',")
+        self._emit("'A rectangle has area 48 and perimeter 28. Find its dimensions.',")
+        self._emit("'Calculate 15% of 240',")
+        self._indent -= 1
+        self._emit("],")
+        self._emit("'code': [")
+        self._indent += 1
+        self._emit("'Implement binary search in Python',")
+        self._emit("'Write a function to reverse a linked list',")
+        self._emit("'Parse a CSV file and compute column averages',")
+        self._emit("'Implement a LRU cache with O(1) get and put',")
+        self._emit("'Write a function to find all permutations of a string',")
+        self._emit("'Implement merge sort',")
+        self._indent -= 1
+        self._emit("],")
+        self._emit("'logic': [")
         self._indent += 1
-        self._emit("if domain == 'math':")
+        self._emit("'If all A are B and all B are C, are all A C? Explain your reasoning.',")
+        self._emit("'A says B is lying. B says C is lying. C says both A and B are lying. Who is telling the truth?',")
+        self._emit("'Three boxes: one has gold, one has silver, one is empty. Box A says gold is in B. Box B says gold is in B. Box C says gold is not in A. Only one tells truth. Where is the gold?',")
+        self._emit("'If it takes 5 machines 5 minutes to make 5 widgets, how long does it take 100 machines to make 100 widgets?',")
+        self._indent -= 1
+        self._emit("],")
+        self._emit("'factual': [")
         self._indent += 1
-        self._emit("return 'Compute (17*19 - 121) / 3' if random.random() < 0.5 else 'Integrate x^2 from 0 to 3'")
+        self._emit("'Explain the difference between TCP and UDP in networking',")
+        self._emit("'What are the three laws of thermodynamics?',")
+        self._emit("'Describe how transformers work in machine learning',")
+        self._emit("'What causes tides on Earth?',")
+        self._indent -= 1
+        self._emit("],")
         self._indent -= 1
-        self._emit("if domain == 'code':")
+        self._emit("}")
+        self._emit("")
+        self._emit("# Ask the model to generate MORE problems like the seeds")
+        self._emit("print('[td_lang] Generating problem bank from seeds...')")
+        self._emit("problem_bank = dict(seed_problems)  # start with seeds")
+        self._emit("for domain in weak_topics:")
+        self._indent += 1
+        self._emit("if domain not in seed_problems:")
+        self._indent += 1
+        self._emit("continue")
+        self._indent -= 1
+        self._emit("examples = '; '.join(seed_problems.get(domain, [])[:3])")
+        self._emit("gen_prompt = f'Generate 10 diverse {domain} problems similar to: {examples}. List them numbered 1-10, one per line.'")
+        self._emit('gen_inputs = tok(gen_prompt, return_tensors="pt").to(model.device)')
+        self._emit("with torch.no_grad():")
         self._indent += 1
-        self._emit("return 'Implement Dijkstra shortest path' if random.random() < 0.5 else 'Parse JSON safely in Python'")
+        self._emit("gen_out = model.generate(**gen_inputs, max_new_tokens=512, do_sample=True, temperature=0.9)")
         self._indent -= 1
-        self._emit("if domain == 'logic':")
+        self._emit("gen_text = tok.decode(gen_out[0], skip_special_tokens=True)")
+        self._emit("# Parse numbered lines as new problems")
+        self._emit("for line in gen_text.split(chr(10)):")
         self._indent += 1
-        self._emit("return 'Does the conclusion follow? If all A are B and all B are C, are all A C?'")
+        self._emit("line = re.sub(r'^\\d+[.)\\s]+', '', line.strip())")
+        self._emit("if len(line) > 15:")
+        self._indent += 1
+        self._emit("problem_bank.setdefault(domain, []).append(line)")
+        self._indent -= 2
         self._indent -= 1
-        self._emit("return 'Summarize the causes of the 2008 financial crisis in 3 bullet points.'")
+        self._emit("total_problems = sum(len(v) for v in problem_bank.values())")
+        self._emit("print(f'[td_lang] Problem bank: {total_problems} problems across {len(problem_bank)} domains')")
+        self._emit("")
+        self._emit("def make_problem(domain: str) -> str:")
+        self._indent += 1
+        self._emit("pool = problem_bank.get(domain, problem_bank.get('math', ['Solve 2+2']))")
+        self._emit("return random.choice(pool)")
         self._indent -= 1
         self._emit("")
         self._emit("synth_data = []")
@@ -738,18 +971,51 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
         if cmd.method == "grpo":
-            self._emit("# GRPO training (test_15: 64 steps sweet spot, eval every 16)")
+            self._emit("# GRPO training with QLoRA (test_15: 64 steps sweet spot)")
+            self._emit("# QLoRA = 4-bit base model + LoRA adapters = fits on 24GB 4090")
             self._emit("from trl import GRPOConfig, GRPOTrainer")
-            self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer")
+            self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig")
+            self._emit("from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training")
             self._emit("from datasets import load_dataset")
             self._emit("import torch")
             self._emit("")
             self._emit("tok = AutoTokenizer.from_pretrained(checkpoint)")
+            self._emit("if tok.pad_token is None:")
+            self._indent += 1
+            self._emit("tok.pad_token = tok.eos_token")
+            self._indent -= 1
+            self._emit("")
+            self._emit("# 4-bit quantization - shrinks 7B model from 14GB to ~4GB VRAM")
+            self._emit("bnb_config = BitsAndBytesConfig(")
+            self._indent += 1
+            self._emit("load_in_4bit=True,")
+            self._emit('bnb_4bit_quant_type="nf4",')
+            self._emit("bnb_4bit_compute_dtype=torch.bfloat16,")
+            self._emit("bnb_4bit_use_double_quant=True,")
+            self._indent -= 1
+            self._emit(")")
+            self._emit("")
             self._emit("model = AutoModelForCausalLM.from_pretrained(")
             self._indent += 1
-            self._emit('checkpoint, torch_dtype=torch.bfloat16, device_map="auto"')
+            self._emit("checkpoint,")
+            self._emit("quantization_config=bnb_config,")
+            self._emit('device_map="auto",')
             self._indent -= 1
             self._emit(")")
+            self._emit("model = prepare_model_for_kbit_training(model)")
+            self._emit("")
+            self._emit("# LoRA adapters on mid-to-late layers (test_12: layers 16-28 for 32-layer)")
+            self._emit("lora_config = LoraConfig(")
+            self._indent += 1
+            self._emit("r=32,")
+            self._emit("lora_alpha=64,")
+            self._emit("lora_dropout=0.05,")
+            self._emit('target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],')
+            self._emit('task_type="CAUSAL_LM",')
+            self._indent -= 1
+            self._emit(")")
+            self._emit("model = get_peft_model(model, lora_config)")
+            self._emit("model.print_trainable_parameters()  # Shows ~1-2% trainable vs total")
             self._emit("")
             self._emit(f'# Load training data')
             self._emit(f'dataset_path = "{cmd.dataset}"')
@@ -772,6 +1038,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit('output_dir="td_lang_outputs/grpo_training",')
             self._emit("save_steps=16,")
             self._emit('bf16=True,')
+            self._emit("gradient_checkpointing=True,  # saves VRAM at slight speed cost")
             self._indent -= 1
             self._emit(")")
             self._emit("")
@@ -875,7 +1142,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("if logs['kl'] > 3.1 * ma:")
             self._indent += 1
             self._emit("control.should_training_stop = True")
-            self._emit("print('[td_lang][early_stop] KL spike detected — stopping GRPO')")
+            self._emit("print('[td_lang][early_stop] KL spike detected - stopping GRPO')")
             self._indent -= 2
             self._indent -= 1
             self._emit("if 'eval/reward' in logs:")
@@ -884,7 +1151,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("if len(self.eval_rewards) >= 2 and self.eval_rewards[-1] < self.eval_rewards[-2]:")
             self._indent += 1
             self._emit("control.should_training_stop = True")
-            self._emit("print('[td_lang][early_stop] Validation reward drop — stopping GRPO')")
+            self._emit("print('[td_lang][early_stop] Validation reward drop - stopping GRPO')")
             self._indent -= 1
             self._indent -= 1
             self._emit("if 'policy_entropy' in logs:")
@@ -896,7 +1163,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("if self.entropy_history[-1] < 0.93 * baseline:")
             self._indent += 1
             self._emit("control.should_training_stop = True")
-            self._emit("print('[td_lang][early_stop] Diversity collapsed — stopping GRPO')")
+            self._emit("print('[td_lang][early_stop] Diversity collapsed - stopping GRPO')")
             self._indent -= 2
             self._indent -= 2
             self._indent -= 1
@@ -915,8 +1182,9 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit(f'models["{cmd.target}"]["checkpoint"] = "td_lang_outputs/grpo_trained"')
 
         elif cmd.method in ("sft", "dpo"):
-            self._emit(f"# {cmd.method.upper()} training")
-            self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments")
+            self._emit(f"# {cmd.method.upper()} training with QLoRA (fits on 24GB 4090)")
+            self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, BitsAndBytesConfig")
+            self._emit("from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training")
             if cmd.method == "sft":
                 self._emit("from trl import SFTTrainer")
             else:
@@ -925,11 +1193,29 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("import torch")
             self._emit("")
             self._emit("tok = AutoTokenizer.from_pretrained(checkpoint)")
+            self._emit("if tok.pad_token is None:")
+            self._indent += 1
+            self._emit("tok.pad_token = tok.eos_token")
+            self._indent -= 1
+            self._emit("")
+            self._emit("bnb_config = BitsAndBytesConfig(")
+            self._indent += 1
+            self._emit("load_in_4bit=True,")
+            self._emit('bnb_4bit_quant_type="nf4",')
+            self._emit("bnb_4bit_compute_dtype=torch.bfloat16,")
+            self._emit("bnb_4bit_use_double_quant=True,")
+            self._indent -= 1
+            self._emit(")")
             self._emit("model = AutoModelForCausalLM.from_pretrained(")
             self._indent += 1
-            self._emit('checkpoint, torch_dtype=torch.bfloat16, device_map="auto"')
+            self._emit("checkpoint, quantization_config=bnb_config, device_map='auto',")
             self._indent -= 1
             self._emit(")")
+            self._emit("model = prepare_model_for_kbit_training(model)")
+            self._emit("lora_config = LoraConfig(r=32, lora_alpha=64, lora_dropout=0.05,")
+            self._emit('    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],')
+            self._emit('    task_type="CAUSAL_LM")')
+            self._emit("model = get_peft_model(model, lora_config)")
             self._emit(f'dataset_path = "{cmd.dataset}"')
             self._emit("if dataset_path.endswith('.jsonl'):")
             self._indent += 1
@@ -1140,7 +1426,7 @@ DO NOT EDIT — regenerate from the .td file instead.
     # ---------------------------------------------------------------- Phase 3 emitters
 
     def _emit_edit(self, cmd: EditCmd) -> None:
-        """EDIT — surgical LoRA/DoRA on specific layers.
+        """EDIT - surgical LoRA/DoRA on specific layers.
 
         From test_18: all 3 AIs agree LoRA is safe default, DoRA beats by 1-4%.
         layers_to_transform supports targeting specific layers (e.g., 16-28).
@@ -1151,7 +1437,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         layers = cmd.layers  # "all", "16-28", or single number
         lr = cmd.learning_rate or 1e-4
 
-        self._emit(f'print("[td_lang] EDIT — surgical {method} on {alias}, layers={layers}")')
+        self._emit(f'print("[td_lang] EDIT - surgical {method} on {alias}, layers={layers}")')
         self._emit("from transformers import AutoModelForCausalLM, AutoTokenizer")
         self._emit("import torch")
         self._emit("from peft import LoraConfig, get_peft_model, PeftModel")
@@ -1207,7 +1493,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
         # Apply adapter
-        self._emit("# Inject adapter — base weights stay frozen")
+        self._emit("# Inject adapter - base weights stay frozen")
         self._emit("model = get_peft_model(model, edit_config)")
         self._emit("model.print_trainable_parameters()")
         self._emit("")
@@ -1226,7 +1512,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit("")
 
-        # "Try before buy" — actual eval with adapters on vs off
+        # "Try before buy" - actual eval with adapters on vs off
         self._emit('sample_prompts = ["What is 7+8?", "Explain photosynthesis in one paragraph.", "Write a Python function fib(n)."]')
         self._emit("def run_quick_eval(enable_adapters: bool):")
         self._indent += 1
@@ -1266,19 +1552,19 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit("")
 
-        # Save adapter (don't merge yet — let commit/gates decide)
+        # Save adapter (don't merge yet - let commit/gates decide)
         self._emit(f'edit_save_dir = os.path.join(output_dir, "{alias}_edit_{method}")')
         self._emit("os.makedirs(edit_save_dir, exist_ok=True)")
         self._emit("model.save_pretrained(edit_save_dir)")
         self._emit(f'print(f"[td_lang] EDIT adapter saved to {{edit_save_dir}}")')
-        self._emit(f'print("[td_lang] Adapter NOT merged — use commit with gates to merge permanently")')
+        self._emit(f'print("[td_lang] Adapter NOT merged - use commit with gates to merge permanently")')
         self._emit("")
 
         # Update models dict
         self._emit(f'models["{alias}"] = model')
 
     def _emit_fork(self, cmd: ForkCmd) -> None:
-        """FORK — branch current model weights for parallel experiments.
+        """FORK - branch current model weights for parallel experiments.
 
         From test_18: all 3 AIs say disk-based only on 4090.
         Cheap fork = copy manifest + adapter files, share base weights.
@@ -1287,7 +1573,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         source = cmd.source
         alias = cmd.alias
 
-        self._emit(f'print("[td_lang] FORK — branching {source} as {alias}")')
+        self._emit(f'print("[td_lang] FORK - branching {source} as {alias}")')
         self._emit(f'source_model = models["{source}"]')
         self._emit("import torch")
         self._emit("")
@@ -1300,7 +1586,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
         # Write manifest
-        self._emit("# Write fork manifest — tracks lineage")
+        self._emit("# Write fork manifest - tracks lineage")
         self._emit("import json")
         self._emit("fork_manifest = {")
         self._emit(f'    "fork_name": "{alias}",')
@@ -1315,7 +1601,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("is_peft = hasattr(source_model, 'peft_config')")
         self._emit("if is_peft:")
         self._indent += 1
-        self._emit("# PEFT model — save only adapter weights (small, fast)")
+        self._emit("# PEFT model - save only adapter weights (small, fast)")
         self._emit('adapter_dir = os.path.join(fork_dir, "adapters")')
         self._emit("source_model.save_pretrained(adapter_dir)")
         self._emit('fork_manifest["fork_type"] = "adapter"')
@@ -1324,7 +1610,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit("else:")
         self._indent += 1
-        self._emit("# Full model — clone tensors then save to safetensors")
+        self._emit("# Full model - clone tensors then save to safetensors")
         self._emit("from safetensors.torch import save_file")
         self._emit("state = {k: v.detach().cpu().clone() for k, v in source_model.state_dict().items()}")
         self._emit('ckpt_path = os.path.join(fork_dir, "model.safetensors")')
@@ -1364,7 +1650,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit(f'lineage["{alias}"] = {{"forked_from": "{source}", "operations": []}}')
 
     def _emit_reset(self, cmd: ResetCmd) -> None:
-        """RESET — revert model to a previous checkpoint.
+        """RESET - revert model to a previous checkpoint.
 
         From test_18: del model, clear CUDA cache, reload.
         Must also reset optimizer state. Use assign=True to avoid doubling VRAM.
@@ -1372,7 +1658,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         alias = cmd.target
         checkpoint = cmd.checkpoint
 
-        self._emit(f'print("[td_lang] RESET — reverting {alias} to {checkpoint}")')
+        self._emit(f'print("[td_lang] RESET - reverting {alias} to {checkpoint}")')
         self._emit("")
 
         # Delete current model and clear CUDA
@@ -1397,7 +1683,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
         self._emit("if fork_manifest_path and os.path.exists(fork_manifest_path):")
         self._indent += 1
-        self._emit("# Loading from a fork — read manifest")
+        self._emit("# Loading from a fork - read manifest")
         self._emit("import json")
         self._emit("with open(fork_manifest_path) as f:")
         self._indent += 1
@@ -1421,7 +1707,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("# Loading from a safetensors file")
         self._emit("from safetensors.torch import load_file")
         self._emit("state = load_file(ckpt_path, device='cpu')")
-        self._emit("# Need base model architecture — reload from original")
+        self._emit("# Need base model architecture - reload from original")
         self._emit(f'base_ref = models.get("__base_ref_{alias}", ckpt_path)')
         self._emit("model = AutoModelForCausalLM.from_pretrained(base_ref, torch_dtype=torch.float16, device_map='cuda')")
         self._emit("try:")
@@ -1438,7 +1724,7 @@ DO NOT EDIT — regenerate from the .td file instead.
 
         # Re-register in models dict
         self._emit(f'models["{alias}"] = model')
-        self._emit(f'print(f"[td_lang] RESET complete — {alias} restored from {checkpoint}")')
+        self._emit(f'print(f"[td_lang] RESET complete - {alias} restored from {checkpoint}")')
         self._emit("")
 
         # Optimizer/cache handling and quick smoke eval
@@ -1460,7 +1746,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
 
     def _emit_prune(self, cmd: PruneCmd) -> None:
-        """PRUNE — structural pruning of language backbone.
+        """PRUNE - structural pruning of language backbone.
 
         From test_18: 20% structured max (LLM-Pruner). Wanda metric (Grok).
         Language backbone only, never vision encoder. Recovery: 200-800 steps LoRA.
@@ -1470,7 +1756,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         aggressiveness = cmd.aggressiveness
 
         self._emit("import torch")
-        self._emit(f'print("[td_lang] PRUNE — {method} pruning on {alias}, {aggressiveness*100:.0f}% removal")')
+        self._emit(f'print("[td_lang] PRUNE - {method} pruning on {alias}, {aggressiveness*100:.0f}% removal")')
         self._emit(f'model = models["{alias}"]')
         self._emit("")
 
@@ -1484,7 +1770,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
         # Identify language-only layers (skip vision)
-        self._emit("# Target language backbone ONLY — never prune vision encoder")
+        self._emit("# Target language backbone ONLY - never prune vision encoder")
         self._emit("# Filter for language model linear layers")
         self._emit("target_modules = []")
         self._emit("for name, module in model.named_modules():")
@@ -1598,8 +1884,8 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._indent -= 1
             self._indent -= 1
         else:  # taylor
-            self._emit("# Taylor: gradient-based importance (needs backprop — VRAM heavy)")
-            self._emit("# Falling back to magnitude as MVP — Taylor needs calibration + backprop")
+            self._emit("# Taylor: gradient-based importance (needs backprop - VRAM heavy)")
+            self._emit("# Falling back to magnitude as MVP - Taylor needs calibration + backprop")
             self._emit(f'print("[td_lang] WARNING: Taylor pruning falls back to magnitude on single GPU")')
             self._emit("import torch.nn.utils.prune as prune")
             self._emit("")
@@ -1651,7 +1937,7 @@ DO NOT EDIT — regenerate from the .td file instead.
     # ---------------------------------------------------------------- Phase 7: Loop Control emitters
 
     def _emit_cmd(self, cmd, program: TDProgram) -> None:
-        """Emit a single command — used by repeat/if to emit body commands."""
+        """Emit a single command - used by repeat/if to emit body commands."""
         if isinstance(cmd, LoadCmd):
             self._emit_load(cmd)
         elif isinstance(cmd, MergeCmd):
@@ -1694,15 +1980,17 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit_repeat(cmd, program)
         elif isinstance(cmd, IfBlock):
             self._emit_if(cmd, program)
+        elif isinstance(cmd, ScheduleCmd):
+            self._emit_schedule(cmd, program)
 
     def _emit_repeat(self, cmd: RepeatBlock, program: TDProgram) -> None:
-        """REPEAT — run a block of commands N times.
+        """REPEAT - run a block of commands N times.
 
         This is the core of td_loop: the self-improvement cycle.
         Each iteration runs the body commands in order.
         """
         n = cmd.count
-        self._emit(f'print("[td_lang] REPEAT — running {n} iterations")')
+        self._emit(f'print("[td_lang] REPEAT - running {n} iterations")')
         self._emit(f"for _loop_iter in range({n}):")
         self._indent += 1
         self._emit(f'print(f"[td_lang] === Iteration {{_loop_iter + 1}}/{n} ===")')
@@ -1712,7 +2000,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("elapsed_hours = (time.time() - start_time) / 3600")
             self._emit(f"if elapsed_hours >= {program.budget.max_gpu_hours}:")
             self._indent += 1
-            self._emit('print("[td_lang] Budget exceeded inside repeat — stopping loop.")')
+            self._emit('print("[td_lang] Budget exceeded inside repeat - stopping loop.")')
             self._emit("break")
             self._indent -= 1
         self._emit("")
@@ -1721,10 +2009,10 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("")
         self._emit(f'print(f"[td_lang] Iteration {{_loop_iter + 1}}/{n} complete.")')
         self._indent -= 1
-        self._emit(f'print("[td_lang] REPEAT complete — {n} iterations done.")')
+        self._emit(f'print("[td_lang] REPEAT complete - {n} iterations done.")')
 
     def _emit_if(self, cmd: IfBlock, program: TDProgram) -> None:
-        """IF/ELSE — conditional execution based on eval results.
+        """IF/ELSE - conditional execution based on eval results.
 
         Conditions:
         - eval_passed: last eval for target had no failures
@@ -1734,7 +2022,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         condition = cmd.condition
         target = cmd.target
 
-        self._emit(f'print("[td_lang] IF — checking {condition} for {target}")')
+        self._emit(f'print("[td_lang] IF - checking {condition} for {target}")')
         self._emit("")
 
         # Emit condition check
@@ -1777,7 +2065,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._indent -= 1
 
     def _emit_break_if(self, cmd: BreakIfCmd) -> None:
-        """BREAK_IF — early exit from repeat based on condition."""
+        """BREAK_IF - early exit from repeat based on condition."""
         condition = cmd.condition
         target = cmd.target or ""
         self._emit(f'_brk_eval = results.get("{target}_eval", {{}})')
@@ -1790,17 +2078,17 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit(f"_brk_met = bool(results.get('{target}_{condition}', False))")
         self._emit("if _brk_met:")
         self._indent += 1
-        self._emit('print("[td_lang] break_if triggered — exiting loop")')
+        self._emit('print("[td_lang] break_if triggered - exiting loop")')
         self._emit("break")
         self._indent -= 1
 
     # ---------------------------------------------------------------- Phase 6: Easy Merge emitters
 
     def _emit_fuse(self, cmd: FuseCmd) -> None:
-        """FUSE — merge multiple models into target in one command.
+        """FUSE - merge multiple models into target in one command.
 
         From TD merge strategy: Transport and Merge (optimal transport cross-arch merging).
-        All 5 source models have different architectures — Transport and Merge handles this.
+        All 5 source models have different architectures - Transport and Merge handles this.
         Merge into language backbone only, vision encoder stays untouched.
         """
         target = cmd.target
@@ -1809,7 +2097,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         strategy = cmd.strategy
         n = len(sources)
 
-        self._emit(f'print("[td_lang] FUSE — merging {n} models into {target} using {method}")')
+        self._emit(f'print("[td_lang] FUSE - merging {n} models into {target} using {method}")')
         self._emit(f'print("[td_lang] Strategy: {strategy}")')
         self._emit(f"fuse_sources = {sources}")
         self._emit(f'prev_ckpt = models.get("{target}", {{}}).get("checkpoint")')
@@ -1825,7 +2113,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit(f"strengths = [round(0.5 * (0.8 ** i), 3) for i in range({n})]")
             self._emit('print(f"[td_lang] Sequential strategy: strengths = {strengths}")')
         else:
-            # weighted — default to equal if no weights specified
+            # weighted - default to equal if no weights specified
             self._emit(f"per_model_strength = round(1.0 / ({n} + 1), 3)")
         self._emit("")
 
@@ -1914,10 +2202,10 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit('"timestamp": datetime.now().isoformat(),')
         self._indent -= 1
         self._emit("})")
-        self._emit(f'print("[td_lang] FUSE complete — {n} models merged into {target}")')
+        self._emit(f'print("[td_lang] FUSE complete - {n} models merged into {target}")')
 
     def _emit_absorb(self, cmd: AbsorbCmd) -> None:
-        """ABSORB — simplified single-model merge.
+        """ABSORB - simplified single-model merge.
 
         One-liner shortcut: absorb "model" into target [strength 0.5]
         Wraps the merge logic with sensible defaults.
@@ -1926,7 +2214,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         target = cmd.target
         strength = cmd.strength
 
-        self._emit(f'print("[td_lang] ABSORB — merging {source} into {target} (strength={strength})")')
+        self._emit(f'print("[td_lang] ABSORB - merging {source} into {target} (strength={strength})")')
         self._emit(f'prev_ckpt = models.get("{target}", {{}}).get("checkpoint")')
         self._emit("")
 
@@ -2020,12 +2308,12 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit('"timestamp": datetime.now().isoformat(),')
         self._indent -= 1
         self._emit("})")
-        self._emit(f'print("[td_lang] ABSORB complete — {source} merged into {target}")')
+        self._emit(f'print("[td_lang] ABSORB complete - {source} merged into {target}")')
 
     # ---------------------------------------------------------------- Phase 4 emitters
 
     def _emit_data_contract(self, dc: DataContractBlock) -> None:
-        """Emit data contract validation — checked at synth/train time.
+        """Emit data contract validation - checked at synth/train time.
 
         From ForgeSpec 2.0 (test_17): data contracts enforce schema on training data.
         Required fields, minimum samples, max perplexity.
@@ -2093,7 +2381,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
     def _emit_reward_contract(self, rc: RewardContractBlock) -> None:
-        """Emit reward contract — enforced during GRPO training.
+        """Emit reward contract - enforced during GRPO training.
 
         From test_16: verified rewards only, no learned reward model.
         """
@@ -2109,7 +2397,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
     def _emit_snapshot(self, cmd: SnapshotCmd, program: TDProgram) -> None:
-        """SNAPSHOT — content-hashed model state for artifact lineage.
+        """SNAPSHOT - content-hashed model state for artifact lineage.
 
         From ForgeSpec 2.0 (test_17): every model state gets a content-addressed hash.
         Directory contains: model weights/adapters, eval report, prune spec, manifest.
@@ -2117,7 +2405,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         alias = cmd.target
         output_dir = cmd.output or "td_lang_outputs/snapshots"
 
-        self._emit(f'print("[td_lang] SNAPSHOT — saving content-hashed state for {alias}")')
+        self._emit(f'print("[td_lang] SNAPSHOT - saving content-hashed state for {alias}")')
         self._emit("import hashlib, json, time")
         self._emit(f'snap_model = models["{alias}"]')
         self._emit("")
@@ -2147,7 +2435,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
         # Write manifest
-        self._emit("# Snapshot manifest — full provenance record")
+        self._emit("# Snapshot manifest - full provenance record")
         self._emit("snap_manifest = {")
         self._indent += 1
         self._emit(f'"alias": "{alias}",')
@@ -2198,14 +2486,14 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("})")
 
     def _emit_report(self, cmd: ReportCmd, program: TDProgram) -> None:
-        """REPORT — economics report for the run.
+        """REPORT - economics report for the run.
 
         Tracks GPU hours, cost, tokens, time per command.
         From test_17 ForgeSpec 2.0: economics reports for cost tracking.
         """
         output = cmd.output or "economics_report.json"
 
-        self._emit('print("[td_lang] REPORT — generating economics report")')
+        self._emit('print("[td_lang] REPORT - generating economics report")')
         self._emit("elapsed = time.time() - start_time")
         self._emit("")
         self._emit("report = {")
@@ -2281,12 +2569,12 @@ DO NOT EDIT — regenerate from the .td file instead.
     # ---------------------------------------------------------------- Phase 8: Autopilot emitters
 
     def _emit_setup(self, setup: SetupBlock) -> None:
-        """SETUP — auto-install dependencies and configure environment.
+        """SETUP - auto-install dependencies and configure environment.
 
         Runs at script start: pip install, HF token, ntfy config.
         """
-        self._emit("# ========== SETUP (Phase 8 — Autopilot) ==========")
-        self._emit('print("[td_lang] SETUP — configuring environment...")')
+        self._emit("# ========== SETUP (Phase 8 - Autopilot) ==========")
+        self._emit('print("[td_lang] SETUP - configuring environment...")')
         self._emit("")
 
         # pip install
@@ -2305,7 +2593,7 @@ DO NOT EDIT — regenerate from the .td file instead.
             self._emit("except Exception as e:")
             self._indent += 1
             self._emit('print(f"[td_lang] WARNING: pip install failed: {e}")')
-            self._emit('print("[td_lang] Continuing anyway — packages may already be installed.")')
+            self._emit('print("[td_lang] Continuing anyway - packages may already be installed.")')
             self._indent -= 1
             self._emit("")
 
@@ -2374,14 +2662,14 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
     def _emit_on_error(self, on_error: OnErrorBlock, program: TDProgram) -> None:
-        """ON_ERROR — wrap each step in retry/fallback logic.
+        """ON_ERROR - wrap each step in retry/fallback logic.
 
         Emits a td_safe_run() helper that wraps any function call with:
         - Retry N times on failure
         - Fallback strategies (reduce batch, skip, snapshot+stop)
         - Optional ntfy notification on error
         """
-        self._emit("# ========== ON_ERROR (Phase 8 — Crash Recovery) ==========")
+        self._emit("# ========== ON_ERROR (Phase 8 - Crash Recovery) ==========")
         self._emit(f"TD_MAX_RETRIES = {on_error.retry}")
         self._emit(f'TD_FALLBACK = "{on_error.fallback}"')
         self._emit(f"TD_NOTIFY_ON_ERROR = {on_error.notify}")
@@ -2413,10 +2701,10 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit('elif TD_FALLBACK == "snapshot_and_stop":')
         self._indent += 1
-        self._emit('print(f"[td_lang] OOM — saving snapshot and stopping.")')
+        self._emit('print(f"[td_lang] OOM - saving snapshot and stopping.")')
         self._emit("if TD_NOTIFY_ON_ERROR:")
         self._indent += 1
-        self._emit('td_notify(f"OOM on {step_name} — snapshot saved, stopping.")')
+        self._emit('td_notify(f"OOM on {step_name} - snapshot saved, stopping.")')
         self._indent -= 1
         self._emit("raise")
         self._indent -= 2
@@ -2428,7 +2716,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent += 1
         self._emit("if TD_NOTIFY_ON_ERROR:")
         self._indent += 1
-        self._emit('td_notify(f"FAILED: {step_name} after {TD_MAX_RETRIES} retries — {e}")')
+        self._emit('td_notify(f"FAILED: {step_name} after {TD_MAX_RETRIES} retries - {e}")')
         self._indent -= 1
         self._emit('if TD_FALLBACK == "skip":')
         self._indent += 1
@@ -2441,19 +2729,19 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._emit("")
 
     def _emit_notify(self, cmd: NotifyCmd, program: TDProgram) -> None:
-        """NOTIFY — send message via ntfy.sh."""
+        """NOTIFY - send message via ntfy.sh."""
         msg = cmd.message.replace('"', '\\"')
         self._emit(f'td_notify("{msg}")')
 
     def _emit_save(self, cmd: SaveCmd, program: TDProgram) -> None:
-        """SAVE — upload model to cloud storage via rclone.
+        """SAVE - upload model to cloud storage via rclone.
 
         Uses rclone to copy model checkpoint/adapters to Google Drive or any remote.
         """
         alias = cmd.target
         dest = cmd.destination
 
-        self._emit(f'print("[td_lang] SAVE — uploading {alias} to {dest}")')
+        self._emit(f'print("[td_lang] SAVE - uploading {alias} to {dest}")')
         self._emit("")
 
         # Find the model's checkpoint directory
@@ -2484,7 +2772,7 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent += 1
         self._emit("import subprocess as _sp")
         self._emit("_sp.check_call(_rclone_cmd)")
-        self._emit(f'print("[td_lang] SAVE complete — {alias} uploaded to {dest}")')
+        self._emit(f'print("[td_lang] SAVE complete - {alias} uploaded to {dest}")')
         self._emit(f'td_notify("Model {alias} saved to {dest}")')
         self._indent -= 1
         self._emit("except FileNotFoundError:")
@@ -2515,6 +2803,93 @@ DO NOT EDIT — regenerate from the .td file instead.
         self._indent -= 1
         self._emit("})")
 
+    # ---------------------------------------------------------------- Phase 9: Schedule
+    def _emit_schedule(self, cmd: ScheduleCmd, program: TDProgram) -> None:
+        """SCHEDULE - time-based command execution.
+
+        Patterns:
+            "every 6h"  → loop with time.sleep(6*3600)
+            "every 30m" → loop with time.sleep(30*60)
+            "at 02:00"  → wait until that time, run once
+            "after 30m" → sleep then run once
+        """
+        timing = cmd.timing.strip()
+        self._emit(f'print("[td_lang] SCHEDULE - timing: {timing}")')
+        self._emit("import time as _time")
+        self._emit("from datetime import datetime as _dt, timedelta as _td")
+        self._emit("")
+
+        if timing.startswith("every "):
+            # Parse interval: "every 6h" or "every 30m"
+            interval_str = timing[6:].strip()
+            self._emit(f'_interval_str = "{interval_str}"')
+            self._emit("if _interval_str.endswith('h'):")
+            self._indent += 1
+            self._emit("_interval_secs = int(_interval_str[:-1]) * 3600")
+            self._indent -= 1
+            self._emit("elif _interval_str.endswith('m'):")
+            self._indent += 1
+            self._emit("_interval_secs = int(_interval_str[:-1]) * 60")
+            self._indent -= 1
+            self._emit("else:")
+            self._indent += 1
+            self._emit("_interval_secs = int(_interval_str) * 3600  # default to hours")
+            self._indent -= 1
+            self._emit('print(f"[td_lang] Running every {_interval_secs}s ({_interval_str}). Ctrl+C to stop.")')
+            self._emit("_sched_iter = 0")
+            self._emit("while True:")
+            self._indent += 1
+            self._emit("_sched_iter += 1")
+            self._emit('print(f"[td_lang] Schedule iteration {_sched_iter} starting at {_dt.now()}")')
+            for body_cmd in cmd.body:
+                self._emit_cmd(body_cmd, program)
+            self._emit('print(f"[td_lang] Iteration {_sched_iter} done. Sleeping {_interval_secs}s...")')
+            self._emit("_time.sleep(_interval_secs)")
+            self._indent -= 1
+
+        elif timing.startswith("at "):
+            # Parse time: "at 02:00"
+            time_str = timing[3:].strip()
+            self._emit(f'_target_time = _dt.strptime("{time_str}", "%H:%M").time()')
+            self._emit("_now = _dt.now()")
+            self._emit("_target = _dt.combine(_now.date(), _target_time)")
+            self._emit("if _target <= _now:")
+            self._indent += 1
+            self._emit("_target += _td(days=1)  # schedule for tomorrow if time already passed")
+            self._indent -= 1
+            self._emit("_wait = (_target - _now).total_seconds()")
+            self._emit('print(f"[td_lang] Waiting {_wait:.0f}s until {_target}...")')
+            self._emit("_time.sleep(_wait)")
+            self._emit('print(f"[td_lang] Scheduled time reached: {_dt.now()}")')
+            for body_cmd in cmd.body:
+                self._emit_cmd(body_cmd, program)
+
+        elif timing.startswith("after "):
+            # Parse delay: "after 30m" or "after 2h"
+            delay_str = timing[6:].strip()
+            self._emit(f'_delay_str = "{delay_str}"')
+            self._emit("if _delay_str.endswith('h'):")
+            self._indent += 1
+            self._emit("_delay_secs = int(_delay_str[:-1]) * 3600")
+            self._indent -= 1
+            self._emit("elif _delay_str.endswith('m'):")
+            self._indent += 1
+            self._emit("_delay_secs = int(_delay_str[:-1]) * 60")
+            self._indent -= 1
+            self._emit("else:")
+            self._indent += 1
+            self._emit("_delay_secs = int(_delay_str) * 3600")
+            self._indent -= 1
+            self._emit('print(f"[td_lang] Waiting {_delay_secs}s before running...")')
+            self._emit("_time.sleep(_delay_secs)")
+            self._emit('print(f"[td_lang] Delay complete. Running scheduled commands...")')
+            for body_cmd in cmd.body:
+                self._emit_cmd(body_cmd, program)
+
+        else:
+            self._emit(f'print("[td_lang] WARNING: Unknown schedule pattern: {timing}")')
+            self._emit('print("[td_lang] Supported: every Nh/Nm, at HH:MM, after Nh/Nm")')
+
     # ---------------------------------------------------------------- Budget + summary
     def _emit_budget_check(self, program: TDProgram) -> None:
         budget = program.budget or BudgetBlock()
@@ -2585,6 +2960,11 @@ DO NOT EDIT — regenerate from the .td file instead.
                 est_gpu += 0.05  # mostly disk I/O + hashing
             elif isinstance(cmd, ReportCmd):
                 est_gpu += 0.01  # just JSON output
+            elif isinstance(cmd, ScheduleCmd):
+                body_est = 1.0 * len(cmd.body)
+                est_gpu += body_est  # at least one run
+            elif isinstance(cmd, (NotifyCmd, SaveCmd)):
+                est_gpu += 0.01
 
         est_cost = est_gpu * self.GPU_HOURLY
 

hugging/td_lang/errors.py

@@ -87,6 +87,7 @@ COMMON_FIXES = {
     "report": "Format: report [-> economics.json]",
     "fuse": 'Format: fuse ["model1", "model2"] into target [strategy equal]',
     "absorb": 'Format: absorb "model" into target [strength 0.5]',
+    "schedule": 'Format: schedule "every 6h" { commands... } or schedule "at 02:00" { ... }',
 }
 
 

hugging/td_lang/examples/demo_schedule.td

@@ -0,0 +1,33 @@
+# Demo: Schedule command (Phase 9)
+# Run training at specific times or on repeat
+
+setup {
+    pip = [torch, transformers, peft, bitsandbytes, trl]
+    hf_token = env
+    notify = "ntfy.sh/my_ai"
+}
+
+on_error {
+    retry = 3
+    fallback = reduce_batch
+    notify = true
+}
+
+load "Qwen/Qwen3-VL-8B-Instruct" as base
+
+# Run training loop every 6 hours (overnight training)
+schedule "every 6h" {
+    diagnose base -> weaknesses.json
+    synth base from base filter cherry_llm -> training_data.jsonl
+    train base on "training_data.jsonl" using grpo steps 64 lr 5e-5
+    eval base -> eval_results.json
+    if eval_passed base {
+        commit base
+        snapshot base -> snapshots/
+        save base to "gdrive:TD/models/latest"
+        notify "Training cycle passed! Model improved."
+    } else {
+        reset base to "snapshots/"
+        notify "Training cycle failed. Reset to last good."
+    }
+}

hugging/td_lang/grammar.py

@@ -32,6 +32,7 @@ from .ast_nodes import (
     ResetCmd,
     RewardContractBlock,
     SaveCmd,
+    ScheduleCmd,
     SetupBlock,
     SnapshotCmd,
     SynthCmd,
@@ -78,6 +79,7 @@ TD_GRAMMAR = r"""
               | reward_contract_block
               | setup_block
               | on_error_block
+              | schedule_cmd
 
     // ======================== PHASE 1 COMMANDS ========================
 
@@ -151,7 +153,7 @@ TD_GRAMMAR = r"""
               | fork_cmd | reset_cmd | prune_cmd | edit_cmd
               | fuse_cmd | absorb_cmd | snapshot_cmd | report_cmd
               | notify_cmd | save_cmd
-              | repeat_block_cmd | if_block_cmd) _NL*
+              | repeat_block_cmd | if_block_cmd | schedule_cmd) _NL*
 
     // ======================== PHASE 6 — EASY MERGE COMMANDS ========================
 
@@ -224,6 +226,13 @@ TD_GRAMMAR = r"""
     onerr_fallback: "fallback" "=" IDENT
     onerr_notify: "notify" "=" IDENT
 
+    // ======================== PHASE 9 — SCHEDULE ========================
+
+    // schedule "every 6h" { commands... }
+    // schedule "at 02:00" { commands... }
+    // schedule "after 30m" { commands... }
+    schedule_cmd: "schedule" string "{" _NL* body_cmd+ _NL* "}"
+
     // ======================== SHARED RULES ========================
 
     // List of names: [name1, name2, name3]
@@ -454,6 +463,11 @@ class TDTransformer(Transformer):
     def else_clause(self, *body_cmds) -> list:
         return list(body_cmds)
 
+    # --- Phase 9: Schedule ---
+
+    def schedule_cmd(self, timing: str, *body_cmds) -> ScheduleCmd:
+        return ScheduleCmd(timing=timing, body=list(body_cmds))
+
     # --- Phase 6: Easy Merge Commands ---
 
     def fuse_cmd(self, sources: list[str], target: str, *opts) -> FuseCmd: