claude-turing 1.1.0 → 1.2.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "turing",
-  "version": "1.1.0",
-  "description": "Autonomous ML research harness — the autoresearch loop as a formal protocol. 16 commands, 2 specialized agents, cost-performance frontier analysis, model cards, model registry, hypothesis database with novelty guard, anti-cheating guardrails, and the taste-leverage loop. Inspired by Karpathy's autoresearch and the scientific method itself.",
+  "version": "1.2.0",
+  "description": "Autonomous ML research harness — the autoresearch loop as a formal protocol. 17 commands, 2 specialized agents, tree-search hypothesis exploration (TreeQuest AB-MCTS), cost-performance frontier analysis, model cards, model registry, hypothesis database with novelty guard, anti-cheating guardrails, and the taste-leverage loop. Inspired by Karpathy's autoresearch and the scientific method itself.",
   "author": {
     "name": "pragnition"
   },

package/README.md

@@ -313,6 +313,8 @@ The index (`hypotheses.yaml`) is the lightweight queue. The detail files (`hypot
 | `/turing:try <hypothesis>` | Inject a hypothesis — free text or `archetype:model_comparison` |
 | `/turing:brief [--deep]` | Research briefing — campaign summary, failure patterns, literature-grounded suggestions |
 | `/turing:suggest` | Literature-grounded model architecture suggestions with citations |
+| `/turing:suggest --strategy treequest` | Tree-search hypothesis exploration (alias for `/turing:explore`) |
+| `/turing:explore` | AB-MCTS tree search over critique-scored hypothesis space |
 | `/turing:design <hyp-id>` | Generate structured experiment design from a hypothesis |
 | `/turing:mode <explore\|exploit\|replicate>` | Set research strategy — drives novelty guard policy |
 
@@ -390,6 +392,39 @@ After N experiments with no meaningful improvement, the agent stops and reports
 
 For noisy metrics, `/turing:validate` runs the pipeline multiple times and measures variance. If the coefficient of variation exceeds 5%, it auto-configures multi-run evaluation so the agent can't be rewarded for lucky single runs.
 
+## Tree-Search Hypothesis Exploration
+
+> *"The learned coin-flipper weaves through the quadrillion-coin room with a preternatural air."*
+
+Sometimes the best experiment to try next isn't obvious from the literature or the agent's memory. `/turing:explore` uses [TreeQuest](https://github.com/SakanaAI/treequest)'s AB-MCTS (Adaptive Branching Monte Carlo Tree Search) to search the space of experiment *ideas* as a tree, scored by the critique engine (novelty x feasibility x impact).
+
+```
+/turing:explore                         # Run MCTS over hypothesis space
+/turing:explore --strategy greedy       # Greedy fallback (no TreeQuest needed)
+/turing:explore --iterations 50 --top 8 # Deeper search, more results
+/turing:suggest --strategy treequest    # Same thing via suggest
+```
+
+How it works:
+
+```
+         Seeds                    MCTS expands best-scoring branches
+           │
+    ┌──────┼──────┐               Each node is a hypothesis scored by:
+    ▼      ▼      ▼                 - Novelty (vs experiment history)
+  LightGBM Reg  Features            - Feasibility (hardware, deps)
+    │       │      │                - Expected impact (type success rate)
+    ▼       ▼      ▼
+  +dart   +L1   +poly             Top-K results queued as hypotheses
+    │              │              for the next /turing:train run
+    ▼              ▼
+  +subsamp      +target-enc
+```
+
+Unlike `/turing:suggest` (which searches the web for papers), `/turing:explore` searches the space of *refinement chains* — combinations and sequences of modifications that score well together. It discovers non-obvious experiment strategies that independent suggestions cannot find.
+
+Falls back to greedy best-first search when TreeQuest is not installed.
+
 ## Cost-Performance Frontier
 
 > *"This model is 2% better but takes 10x longer to train. Is that worth it?"*
@@ -451,11 +486,11 @@ Each project gets independent config, data, experiments, models, and agent memor
 
 ## Architecture of Turing Itself
 
-16 commands, 2 agents, 8 config files, 30 template scripts, model registry, artifact contract, cost-performance frontier, model cards, 345 tests, 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
+17 commands, 2 agents, 8 config files, 31 template scripts, model registry, artifact contract, cost-performance frontier, model cards, tree-search exploration, 379 tests, 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
 
 ```
 turing/
-├── commands/              15 skill files (core + taste-leverage + reporting)
+├── commands/              16 skill files (core + taste-leverage + reporting + exploration)
 ├── agents/                2 agents (researcher: read/write, evaluator: read-only)
 ├── config/                8 files (lifecycle, taxonomy, archetypes, novelty aliases)
 ├── templates/             Scaffolded into user projects by /turing:init
@@ -464,7 +499,7 @@ turing/
 │   ├── train.py           Training code (AGENT-EDITABLE)
 │   ├── model_contract.md  Artifact schema for production consumers
 │   ├── model_registry.yaml  Available model architectures + hyperparams
-│   └── scripts/           25 Python scripts (core loop + analysis + infra)
+│   └── scripts/           26 Python scripts (core loop + analysis + infra + tree search)
 ├── tests/                 338 tests (unit + integration + anti-pattern + manifest)
 ├── src/                   5 JS installer files (npm deployment)
 ├── bin/                   CLI entry points
@@ -482,6 +517,7 @@ turing/
 - **[Principle of Least Privilege](https://en.wikipedia.org/wiki/Principle_of_least_privilege)** (Saltzer & Schroeder, 1975) — each agent has exactly the capabilities needed for its role
 - **[Early Stopping](https://en.wikipedia.org/wiki/Early_stopping)** (Prechelt, 1998) — convergence detection as discrete early stopping
 - **[Multi-Armed Bandits](https://en.wikipedia.org/wiki/Multi-armed_bandit)** — the explore-exploit tradeoff
+- **[TreeQuest](https://github.com/SakanaAI/treequest)** (Sakana AI, 2025) — AB-MCTS for inference-time scaling; repurposed here for hypothesis-space exploration
 - **[Version Control as Lab Notebook](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1004668)** (Ram, 2013) — git as a scientific record-keeping system
 - **[Reproducibility Crisis](https://en.wikipedia.org/wiki/Replication_crisis)** — if the measurement can change between experiments, results are not reproducible
 

package/commands/explore.md

@@ -0,0 +1,107 @@
+---
+name: explore
+description: Tree-search-guided hypothesis exploration using AB-MCTS. Explores the space of experiment ideas as a search tree, scored by the critique engine. Discovers non-obvious refinement chains that linear suggestion cannot find.
+disable-model-invocation: true
+argument-hint: "[ml/project] [--iterations N] [--top N] [--strategy abmcts-a|abmcts-m|greedy]"
+allowed-tools: Read, Write, Bash(python scripts/*:*, source .venv/bin/activate:*), Grep, Glob
+---
+
+Explore the hypothesis space using tree search. Instead of suggesting independent ideas, this builds and searches a tree of refinement chains — each node is a hypothesis scored by novelty, feasibility, and expected impact.
+
+## Project Detection
+
+0. **Detect project directory:**
+   - If `$ARGUMENTS` contains a path (e.g., `ml/coding`), use that as the project directory
+   - Else if cwd contains `config.yaml` and `train.py`, use cwd
+   - Else search for `ml/*/` subdirectories containing `config.yaml`
+     - If exactly one found, use it
+     - If multiple found, list them and ask the user which to target
+   - All subsequent commands run from the detected project directory
+
+## Parse Options
+
+Extract from `$ARGUMENTS`:
+- `--iterations N` — search depth (default: 30)
+- `--top N` — number of results to return (default: 5)
+- `--strategy` — algorithm choice: `abmcts-a` (default), `abmcts-m` (Bayesian), or `greedy` (no TreeQuest needed)
+- `--seeds-only` — just show generated seeds without running search
+- `--json` — output as JSON for programmatic use
+
+## Steps
+
+### 1. Assess Current State
+
+```bash
+source .venv/bin/activate && python scripts/show_metrics.py --last 10 2>/dev/null || echo "No experiments yet"
+```
+
+Read `config.yaml` to understand the current model and metric.
+
+### 2. Run Tree Search
+
+```bash
+source .venv/bin/activate && python scripts/treequest_suggest.py \
+    --log experiments/log.jsonl \
+    --config config.yaml \
+    --top <N> \
+    --iterations <N> \
+    --strategy <strategy>
+```
+
+The script will:
+- Generate seed hypotheses from config and experiment history
+- Run AB-MCTS (or greedy fallback) over the hypothesis tree
+- Score each node using the critique engine
+- Return top-K ranked, deduplicated hypotheses
+
+### 3. Queue Best Hypotheses
+
+For each result, add to the hypothesis queue:
+
+```bash
+source .venv/bin/activate && python scripts/manage_hypotheses.py add "<description>" \
+    --priority medium --source treequest
+```
+
+### 4. Show Results
+
+Display the search output and confirm queuing:
+
+```
+TreeQuest Hypothesis Exploration (AB-MCTS-A)
+============================================
+Nodes explored: 35
+Top 5 hypotheses by critique score:
+
+  1. [PROCEED] (score: 7.8/10)
+     Switch to LightGBM with dart boosting; additionally add polynomial features
+     Novelty: 8  Feasibility: 9  Impact: 7
+     -> Queued as hyp-NNN
+
+  2. [PROCEED] (score: 7.2/10)
+     Use low learning rate (0.01) with 2000 estimators; additionally add L2 regularization
+     Novelty: 7  Feasibility: 8  Impact: 7
+     Depth: 1 (refined from parent)
+     -> Queued as hyp-NNN
+
+  ...
+
+Queued N hypotheses. Run /turing:train to test them.
+```
+
+## How It Differs From /turing:suggest
+
+| | `/turing:suggest` | `/turing:explore` |
+|---|---|---|
+| **Source** | Web literature search | Tree search over critique scores |
+| **Strategy** | Independent suggestions | Refinement chains (parent -> child) |
+| **Requires internet** | Yes | No |
+| **Discovers** | What papers recommend | What combinations score well |
+| **Best for** | Early-stage exploration | Mid-experiment optimization |
+
+## Integration
+
+- Results feed into `hypotheses.yaml` — the next `/turing:train` picks them up
+- `/turing:brief` shows queued treequest-sourced hypotheses
+- `/turing:suggest --strategy treequest` is an alias for this command
+- Human can override priority: `/turing:try` always takes precedence

package/commands/suggest.md

@@ -6,9 +6,16 @@ argument-hint: "[task description override]"
 allowed-tools: Read, Write, Bash(python scripts/*:*, source .venv/bin/activate:*), Grep, Glob, WebSearch, WebFetch
 ---
 
-Suggest model architectures for the current ML task, grounded in recent literature. Hypotheses backed by papers, not vibes.
+Suggest model architectures for the current ML task. Supports two strategies:
 
-## Steps
+- **literature** (default): Web search for recent papers, synthesize grounded suggestions with citations.
+- **treequest**: Tree-search-guided hypothesis exploration using AB-MCTS over the critique scoring function. Explores refinement chains that literature search cannot find.
+
+## Strategy Detection
+
+If `$ARGUMENTS` contains `--strategy treequest` or `treequest`, use the TreeQuest strategy below. Otherwise use the default literature strategy.
+
+## Steps (Literature Strategy — default)
 
 ### 1. Understand the Task
 
@@ -84,12 +91,69 @@ Sources consulted: <N papers/articles>
 Queued N hypotheses. Run /turing:train to test them.
 ```
 
-## Fallback
+## Fallback (Literature Strategy)
 
 If web search returns insufficient results, suggest model families from `config/taxonomy.toml` based on what hasn't been tried yet. Note that suggestions are taxonomy-based, not literature-backed, and queue with `--source taxonomy`.
 
+## Steps (TreeQuest Strategy)
+
+When using `--strategy treequest`:
+
+### 1. Detect Project Directory
+
+Same detection logic as the literature strategy — find `config.yaml` + `train.py`.
+
+### 2. Run Tree Search
+
+```bash
+source .venv/bin/activate && python scripts/treequest_suggest.py \
+    --log experiments/log.jsonl \
+    --config config.yaml \
+    --top 5 \
+    --iterations 30 \
+    --strategy abmcts-a
+```
+
+If TreeQuest is not installed, the script automatically falls back to greedy best-first search.
+
+### 3. Queue Results
+
+For each result from the tree search, queue as a hypothesis:
+
+```bash
+source .venv/bin/activate && python scripts/manage_hypotheses.py add "<description>" --priority medium --source treequest
+```
+
+### 4. Show Results
+
+Display the tree search output and confirm hypotheses were queued:
+
+```
+TreeQuest Hypothesis Exploration (AB-MCTS-A)
+============================================
+Nodes explored: 35
+Top 5 hypotheses by critique score:
+
+  1. [PROCEED] (score: 7.8/10)
+     Switch to LightGBM with dart boosting; additionally add polynomial features
+     Novelty: 8  Feasibility: 9  Impact: 7
+
+  ...
+
+Queued N hypotheses. Run /turing:train to test them.
+```
+
+### TreeQuest Options
+
+Pass additional flags via `$ARGUMENTS`:
+- `--iterations N` — search depth (default: 30)
+- `--top N` — number of results (default: 5)
+- `--strategy abmcts-m` — use Bayesian mixed model variant (requires PyMC)
+- `--greedy` — force greedy fallback without TreeQuest
+
 ## Integration
 
 - Suggestions feed into `hypotheses.yaml` — the next `/turing:train` picks them up
-- `/turing:brief` shows queued literature-sourced hypotheses
+- `/turing:brief` shows queued literature-sourced and treequest-sourced hypotheses
+- `/turing:explore` runs the TreeQuest search as a standalone command
 - Human can override priority: `/turing:try` always takes precedence

package/commands/turing.md

@@ -21,6 +21,7 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | "report", "write-up", "findings", "document results" | `/turing:report` | Document |
 | "validate", "stability", "check variance", "noisy" | `/turing:validate` | Validate |
 | "suggest", "what model", "recommend", "which architecture", "literature" | `/turing:suggest` | Research |
+| "explore hypotheses", "tree search", "treequest", "search hypothesis space", "MCTS" | `/turing:explore` | Research |
 | "design", "plan experiment", "how should I test", "experiment design" | `/turing:design` | Design |
 | "mode", "explore", "exploit", "replicate", "strategy" | `/turing:mode` | Strategy |
 | "preflight", "resources", "VRAM", "memory", "can I run", "OOM", "GPU" | `/turing:preflight` | Check |
@@ -39,6 +40,7 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | `/turing:init` | Scaffold a new ML project | (inline) |
 | `/turing:validate` | Check metric stability, auto-fix if noisy | (inline) |
 | `/turing:suggest` | Literature-grounded model architecture suggestions | (inline, uses WebSearch) |
+| `/turing:explore` | Tree-search hypothesis exploration via AB-MCTS | (inline) |
 | `/turing:design <hyp-id>` | Generate structured experiment design from hypothesis | (inline, uses WebSearch) |
 | `/turing:logbook` | HTML/markdown logbook with trajectory chart | (inline) |
 | `/turing:poster` | Single-page HTML research poster | (inline) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-turing",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "description": "Autonomous ML research harness for Claude Code. The autoresearch loop as a formal protocol — iteratively trains, evaluates, and improves ML models with structured experiment tracking, convergence detection, immutable evaluation infrastructure, and safety guardrails.",
   "bin": {

package/src/claude-md.js

@@ -21,6 +21,7 @@ Autonomous ML research harness. The autoresearch loop as a formal protocol.
 | \`/turing:validate\` | Check metric stability, auto-fix if noisy |
 | \`/turing:try <hypothesis>\` | Inject a hypothesis into the experiment queue |
 | \`/turing:brief\` | Generate research intelligence report |
+| \`/turing:explore\` | Tree-search hypothesis exploration (AB-MCTS) |
 | \`/turing:preflight\` | Pre-flight resource check (VRAM/RAM/disk) |
 
 ### Agents

package/src/install.js

@@ -21,7 +21,7 @@ const PLUGIN_ROOT = join(__dirname, "..");
 // Single source of truth for sub-commands (DRY — used for dirs and file copy)
 const SUB_COMMANDS = [
   "init", "train", "status", "compare", "sweep", "validate",
-  "try", "brief", "suggest", "design", "logbook", "poster",
+  "try", "brief", "suggest", "explore", "design", "logbook", "poster",
   "report", "mode", "preflight", "card",
 ];
 

package/src/verify.js

@@ -23,6 +23,7 @@ const EXPECTED_COMMANDS = [
   "try/SKILL.md",
   "brief/SKILL.md",
   "suggest/SKILL.md",
+  "explore/SKILL.md",
   "design/SKILL.md",
   "logbook/SKILL.md",
   "poster/SKILL.md",

package/templates/requirements.txt

@@ -6,3 +6,7 @@ numpy>=2.0
 joblib>=1.4
 pyyaml>=6.0
 pytest>=8.0
+
+# Optional: tree-search-guided hypothesis exploration
+# Install with: pip install "treequest[all]"
+# treequest>=0.1

package/templates/scripts/generate_brief.py

@@ -286,7 +286,8 @@ def format_brief(
         lines.append(f"**{len(queued)} queued:**")
         for h in queued:
             priority_marker = " (HIGH)" if h.get("priority") == "high" else ""
-            source_marker = " [human]" if h.get("source") == "human" else ""
+            source = h.get("source", "")
+            source_marker = f" [{source}]" if source in ("human", "treequest", "literature") else ""
             lines.append(f"- {h['id']}: {h.get('description', '?')}{priority_marker}{source_marker}")
     else:
         lines.append("No queued hypotheses. Use `/turing:try` to inject ideas.")
@@ -387,9 +388,9 @@ def format_brief(
 
         # Check if hypotheses are exhausted
         if not queued:
-            lines.append("- No hypotheses queued — inject ideas with `/turing:try`")
+            lines.append("- No hypotheses queued — inject ideas with `/turing:try` or explore with `/turing:explore`")
 
-    lines.extend(["", "---", "", "*Use `/turing:try` to inject hypotheses. Use `/turing:train` to execute.*"])
+    lines.extend(["", "---", "", "*Use `/turing:try` to inject hypotheses, `/turing:explore` for tree search, `/turing:train` to execute.*"])
 
     return "\n".join(lines)
 

package/templates/scripts/manage_hypotheses.py

@@ -277,7 +277,7 @@ def get_next_hypothesis(queue_path: str) -> dict | None:
         return None
 
     priority_order = {"high": 0, "medium": 1, "low": 2}
-    source_order = {"human": 0, "literature": 1, "taxonomy": 2, "agent": 3}
+    source_order = {"human": 0, "literature": 1, "treequest": 2, "taxonomy": 3, "agent": 4}
 
     queued.sort(key=lambda h: (
         priority_order.get(h.get("priority", "medium"), 1),
@@ -376,7 +376,7 @@ def main() -> None:
     add_parser.add_argument("description", nargs="?", default=None, help="What to try and why")
     add_parser.add_argument("--archetype", default=None, help="Expand from archetype (e.g., model_comparison)")
     add_parser.add_argument("--priority", default="high", choices=sorted(VALID_PRIORITIES))
-    add_parser.add_argument("--source", default="human", choices=["human", "agent", "literature", "taxonomy"])
+    add_parser.add_argument("--source", default="human", choices=["human", "agent", "literature", "treequest", "taxonomy"])
     add_parser.add_argument("--parent", default=None, help="Parent experiment ID")
     add_parser.add_argument("--parent-hyp", default=None, help="Parent hypothesis ID")
     add_parser.add_argument("--family", default=None, help="Experiment family (e.g., optimizer-sweep)")

package/templates/scripts/scaffold.py

@@ -89,6 +89,7 @@ TEMPLATE_DIRS = {
         "diff_configs.py",
         "export_results.py",
         "plot_trajectory.py",
+        "treequest_suggest.py",
     ],
     "tests": ["__init__.py", "conftest.py"],
 }

package/templates/scripts/treequest_suggest.py

@@ -0,0 +1,520 @@
+#!/usr/bin/env python3
+"""Tree-search-guided hypothesis exploration for the autoresearch pipeline.
+
+Uses TreeQuest's AB-MCTS (Adaptive Branching Monte Carlo Tree Search) to
+explore the space of experiment hypotheses. Each tree node is a hypothesis
+description + structured config. The generation function produces refinements
+of a parent hypothesis, and the scoring function uses the critique engine
+(novelty × feasibility × impact) as the reward signal.
+
+This is the search-driven complement to suggest_next.py's surrogate model:
+instead of fitting a Random Forest over hyperparameter space, we search
+the space of *ideas* using MCTS with the critique score as reward.
+
+Requires: pip install "treequest[all]"
+
+Usage:
+    python scripts/treequest_suggest.py \\
+        --log experiments/log.jsonl \\
+        --config config.yaml \\
+        --top 5 \\
+        --iterations 30 \\
+        --strategy abmcts-a
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from scripts.critique_hypothesis import critique_hypothesis
+from scripts.turing_io import load_experiments, load_config
+
+
+# ---------------------------------------------------------------------------
+# Node representation
+# ---------------------------------------------------------------------------
+
+@dataclass
+class HypothesisNode:
+    """A node in the hypothesis search tree.
+
+    Each node represents a concrete experiment hypothesis with both a
+    human-readable description and optional structured fields (model type,
+    hyperparameters, feature changes) that can be passed to the hypothesis
+    queue.
+    """
+    description: str
+    model_type: str | None = None
+    hyperparameters: dict | None = None
+    feature_changes: dict | None = None
+    parent_description: str | None = None
+    depth: int = 0
+    critique_scores: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        """Serialize for logging and queue integration."""
+        return {
+            "description": self.description,
+            "model_type": self.model_type,
+            "hyperparameters": self.hyperparameters,
+            "feature_changes": self.feature_changes,
+            "parent_description": self.parent_description,
+            "depth": self.depth,
+            "critique_scores": self.critique_scores,
+        }
+
+    @staticmethod
+    def from_dict(d: dict) -> "HypothesisNode":
+        return HypothesisNode(
+            description=d["description"],
+            model_type=d.get("model_type"),
+            hyperparameters=d.get("hyperparameters"),
+            feature_changes=d.get("feature_changes"),
+            parent_description=d.get("parent_description"),
+            depth=d.get("depth", 0),
+            critique_scores=d.get("critique_scores", {}),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Critique-based scoring
+# ---------------------------------------------------------------------------
+
+def score_hypothesis(
+    node: HypothesisNode,
+    log_path: str = "experiments/log.jsonl",
+    config_path: str = "config.yaml",
+) -> float:
+    """Score a hypothesis node using the critique engine.
+
+    Returns a float in [0, 10] — the weighted combination of
+    novelty (30%), feasibility (30%), and expected impact (40%).
+    """
+    result = critique_hypothesis(
+        description=node.description,
+        log_path=log_path,
+        config_path=config_path,
+    )
+    node.critique_scores = {
+        "overall": result["overall_score"],
+        "novelty": result["novelty"]["score"],
+        "feasibility": result["feasibility"]["score"],
+        "impact": result["impact"]["score"],
+        "verdict": result["verdict"],
+    }
+    return result["overall_score"]
+
+
+# ---------------------------------------------------------------------------
+# Seed hypothesis generation
+# ---------------------------------------------------------------------------
+
+def generate_seed_hypotheses(
+    config: dict,
+    experiments: list[dict],
+) -> list[HypothesisNode]:
+    """Generate initial seed hypotheses from config and experiment history.
+
+    These form the root nodes of the search tree. Each represents a
+    distinct direction worth exploring.
+    """
+    seeds: list[HypothesisNode] = []
+    current_model = config.get("model", {}).get("type", "xgboost")
+    metric = config.get("evaluation", {}).get("primary_metric", "accuracy")
+
+    # Seed 1: alternative model families
+    model_alternatives = {
+        "xgboost": ["LightGBM with dart boosting", "CatBoost with ordered boosting",
+                     "Random Forest with extra-trees"],
+        "lightgbm": ["XGBoost with hist method", "CatBoost with ordered boosting",
+                      "Random Forest with extra-trees"],
+        "catboost": ["XGBoost with hist method", "LightGBM with GOSS sampling",
+                      "Random Forest with extra-trees"],
+        "random_forest": ["XGBoost with hist method", "LightGBM with dart boosting",
+                          "CatBoost with ordered boosting"],
+    }
+    alternatives = model_alternatives.get(current_model.lower(), [
+        "XGBoost with hist method", "LightGBM with dart boosting",
+    ])
+    for alt in alternatives:
+        seeds.append(HypothesisNode(
+            description=f"Switch to {alt} for {metric} optimization",
+            model_type=alt.split(" with ")[0].lower().replace(" ", ""),
+        ))
+
+    # Seed 2: regularization exploration
+    seeds.append(HypothesisNode(
+        description=f"Increase regularization — add L2 penalty and reduce max_depth to combat potential overfitting",
+        hyperparameters={"reg_lambda": 1.0, "max_depth": 4},
+    ))
+
+    # Seed 3: feature engineering
+    seeds.append(HypothesisNode(
+        description="Add polynomial interaction features for the top-5 most important numeric columns",
+        feature_changes={"add": ["polynomial_interactions"]},
+    ))
+
+    # Seed 4: learning rate schedule
+    seeds.append(HypothesisNode(
+        description=f"Use low learning rate (0.01) with high n_estimators (2000) and early stopping for {metric}",
+        hyperparameters={"learning_rate": 0.01, "n_estimators": 2000},
+    ))
+
+    # Seed 5: based on experiment history — what's been working?
+    kept = [e for e in experiments if e.get("status") == "kept"]
+    if kept:
+        last_kept = kept[-1]
+        last_desc = last_kept.get("description", "")
+        if last_desc:
+            seeds.append(HypothesisNode(
+                description=f"Refine the approach from '{last_desc}' — try a more aggressive variant with doubled learning rate",
+                parent_description=last_desc,
+            ))
+
+    return seeds
+
+
+# ---------------------------------------------------------------------------
+# Perturbation-based child generation (non-LLM fallback)
+# ---------------------------------------------------------------------------
+
+_PERTURBATION_STRATEGIES = [
+    "increase learning rate by 2x",
+    "decrease learning rate by 2x",
+    "double n_estimators",
+    "halve max_depth",
+    "double max_depth",
+    "add L1 regularization (reg_alpha=1.0)",
+    "add L2 regularization (reg_lambda=1.0)",
+    "increase subsample ratio to 0.9",
+    "decrease subsample ratio to 0.6",
+    "add column sampling (colsample_bytree=0.7)",
+    "switch to dart boosting",
+    "switch to GOSS sampling",
+    "add polynomial features",
+    "add target encoding for categorical columns",
+    "remove low-importance features (bottom 20%)",
+    "try log-transform on skewed numeric features",
+    "add min_child_weight constraint",
+    "increase early stopping patience",
+]
+
+
+def generate_children(
+    parent: HypothesisNode,
+    n_children: int = 3,
+    rng_seed: int = 42,
+) -> list[HypothesisNode]:
+    """Generate child hypotheses by perturbing a parent.
+
+    Uses deterministic perturbation strategies. Each child is a refinement
+    or variation of the parent hypothesis.
+    """
+    import hashlib
+
+    # Deterministic but parent-dependent selection
+    parent_hash = int(hashlib.sha256(parent.description.encode()).hexdigest(), 16)
+    start_idx = (parent_hash + rng_seed) % len(_PERTURBATION_STRATEGIES)
+
+    children = []
+    for i in range(n_children):
+        idx = (start_idx + i * 7) % len(_PERTURBATION_STRATEGIES)  # stride of 7 for diversity
+        strategy = _PERTURBATION_STRATEGIES[idx]
+        child = HypothesisNode(
+            description=f"{parent.description}; additionally {strategy}",
+            model_type=parent.model_type,
+            hyperparameters=dict(parent.hyperparameters) if parent.hyperparameters else None,
+            feature_changes=dict(parent.feature_changes) if parent.feature_changes else None,
+            parent_description=parent.description,
+            depth=parent.depth + 1,
+        )
+        children.append(child)
+
+    return children
+
+
+# ---------------------------------------------------------------------------
+# TreeQuest integration
+# ---------------------------------------------------------------------------
+
+def run_treequest_search(
+    seeds: list[HypothesisNode],
+    log_path: str = "experiments/log.jsonl",
+    config_path: str = "config.yaml",
+    iterations: int = 30,
+    top_k: int = 5,
+    strategy: str = "abmcts-a",
+    children_per_node: int = 3,
+) -> list[HypothesisNode]:
+    """Run TreeQuest MCTS search over the hypothesis space.
+
+    Args:
+        seeds: Initial hypothesis nodes (tree roots).
+        log_path: Path to experiment log for critique scoring.
+        config_path: Path to config for critique scoring.
+        iterations: Number of MCTS iterations.
+        top_k: Number of best hypotheses to return.
+        strategy: TreeQuest algorithm — "abmcts-a" or "abmcts-m".
+        children_per_node: Branching factor for child generation.
+
+    Returns:
+        Top-K hypothesis nodes ranked by critique score.
+    """
+    try:
+        import treequest
+    except ImportError:
+        print(
+            "TreeQuest not installed. Install with: pip install 'treequest[all]'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Select algorithm
+    if strategy == "abmcts-m":
+        algo = treequest.ABMCTSM()
+    else:
+        algo = treequest.ABMCTSA()
+
+    # Track all scored nodes for final ranking
+    all_scored: list[HypothesisNode] = []
+
+    def generation_fn(parent_state: HypothesisNode | None) -> tuple[HypothesisNode, float]:
+        """TreeQuest generation function.
+
+        Given a parent node (or None for root), generate a child and score it.
+        """
+        if parent_state is None:
+            # Pick a seed
+            idx = len(all_scored) % len(seeds)
+            node = seeds[idx]
+        else:
+            children = generate_children(
+                parent_state,
+                n_children=1,
+                rng_seed=len(all_scored),
+            )
+            node = children[0]
+
+        score = score_hypothesis(node, log_path, config_path)
+        all_scored.append(node)
+        return node, score
+
+    # Initialize and run the tree search
+    algo.init_tree()
+    for i in range(iterations):
+        try:
+            algo.step(generation_fn)
+        except Exception as e:
+            print(f"Warning: iteration {i} failed: {e}", file=sys.stderr)
+            continue
+
+    # Rank all explored nodes by critique score
+    all_scored.sort(key=lambda n: n.critique_scores.get("overall", 0), reverse=True)
+
+    # Deduplicate by description similarity
+    seen_descriptions: set[str] = set()
+    unique_results: list[HypothesisNode] = []
+    for node in all_scored:
+        # Simple dedup: normalize and check
+        normalized = node.description.lower().strip()
+        if normalized not in seen_descriptions:
+            seen_descriptions.add(normalized)
+            unique_results.append(node)
+        if len(unique_results) >= top_k:
+            break
+
+    return unique_results
+
+
+# ---------------------------------------------------------------------------
+# Fallback: greedy search without TreeQuest
+# ---------------------------------------------------------------------------
+
+def run_greedy_search(
+    seeds: list[HypothesisNode],
+    log_path: str = "experiments/log.jsonl",
+    config_path: str = "config.yaml",
+    iterations: int = 30,
+    top_k: int = 5,
+    children_per_node: int = 3,
+) -> list[HypothesisNode]:
+    """Greedy best-first search fallback when TreeQuest is not installed.
+
+    Expands the highest-scoring node at each step, keeping a priority
+    queue of candidates. Less sophisticated than MCTS but requires no
+    external dependency.
+    """
+    import heapq
+
+    # Score seeds
+    scored_seeds: list[tuple[float, int, HypothesisNode]] = []
+    for i, seed in enumerate(seeds):
+        score = score_hypothesis(seed, log_path, config_path)
+        # Negate score for min-heap (we want max)
+        heapq.heappush(scored_seeds, (-score, i, seed))
+
+    frontier = scored_seeds
+    all_explored: list[HypothesisNode] = list(seeds)
+    counter = len(seeds)
+
+    for _ in range(iterations):
+        if not frontier:
+            break
+
+        # Expand best node
+        neg_score, _, best = heapq.heappop(frontier)
+        children = generate_children(best, n_children=children_per_node, rng_seed=counter)
+
+        for child in children:
+            score = score_hypothesis(child, log_path, config_path)
+            counter += 1
+            heapq.heappush(frontier, (-score, counter, child))
+            all_explored.append(child)
+
+    # Rank and deduplicate
+    all_explored.sort(key=lambda n: n.critique_scores.get("overall", 0), reverse=True)
+
+    seen: set[str] = set()
+    results: list[HypothesisNode] = []
+    for node in all_explored:
+        normalized = node.description.lower().strip()
+        if normalized not in seen:
+            seen.add(normalized)
+            results.append(node)
+        if len(results) >= top_k:
+            break
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Output formatting
+# ---------------------------------------------------------------------------
+
+def format_results(
+    results: list[HypothesisNode],
+    metric_name: str,
+    strategy_used: str,
+    total_explored: int,
+) -> str:
+    """Format search results for terminal display."""
+    lines = [
+        f"TreeQuest Hypothesis Exploration ({strategy_used})",
+        "=" * 60,
+        f"Nodes explored: {total_explored}",
+        f"Top {len(results)} hypotheses by critique score:",
+        "",
+    ]
+
+    for i, node in enumerate(results, 1):
+        scores = node.critique_scores
+        overall = scores.get("overall", 0)
+        verdict = scores.get("verdict", "?")
+        novelty = scores.get("novelty", 0)
+        feasibility = scores.get("feasibility", 0)
+        impact = scores.get("impact", 0)
+
+        lines.append(f"  {i}. [{verdict.upper()}] (score: {overall}/10)")
+        lines.append(f"     {node.description}")
+        lines.append(f"     Novelty: {novelty}  Feasibility: {feasibility}  Impact: {impact}")
+        if node.depth > 0:
+            lines.append(f"     Depth: {node.depth} (refined from parent)")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def results_to_json(results: list[HypothesisNode]) -> list[dict]:
+    """Serialize results for machine consumption."""
+    return [node.to_dict() for node in results]
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Tree-search-guided hypothesis exploration",
+    )
+    parser.add_argument("--log", default="experiments/log.jsonl",
+                        help="Path to experiment log")
+    parser.add_argument("--config", default="config.yaml",
+                        help="Path to project config")
+    parser.add_argument("--top", type=int, default=5,
+                        help="Number of top hypotheses to return")
+    parser.add_argument("--iterations", type=int, default=30,
+                        help="Number of search iterations")
+    parser.add_argument("--strategy", default="abmcts-a",
+                        choices=["abmcts-a", "abmcts-m", "greedy"],
+                        help="Search strategy (abmcts-a, abmcts-m, or greedy fallback)")
+    parser.add_argument("--children", type=int, default=3,
+                        help="Children per node expansion")
+    parser.add_argument("--json", action="store_true",
+                        help="Output as JSON")
+    parser.add_argument("--seeds-only", action="store_true",
+                        help="Only show generated seeds, don't run search")
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+    experiments = load_experiments(args.log)
+    metric = config.get("evaluation", {}).get("primary_metric", "accuracy")
+
+    # Generate seeds
+    seeds = generate_seed_hypotheses(config, experiments)
+
+    if args.seeds_only:
+        if args.json:
+            print(json.dumps([s.to_dict() for s in seeds], indent=2))
+        else:
+            print(f"Generated {len(seeds)} seed hypotheses:")
+            for i, s in enumerate(seeds, 1):
+                print(f"  {i}. {s.description}")
+        return
+
+    # Run search
+    if args.strategy == "greedy":
+        results = run_greedy_search(
+            seeds, args.log, args.config,
+            iterations=args.iterations,
+            top_k=args.top,
+            children_per_node=args.children,
+        )
+        strategy_label = "greedy best-first"
+    else:
+        try:
+            import treequest  # noqa: F401
+            results = run_treequest_search(
+                seeds, args.log, args.config,
+                iterations=args.iterations,
+                top_k=args.top,
+                strategy=args.strategy,
+                children_per_node=args.children,
+            )
+            strategy_label = f"TreeQuest {args.strategy.upper()}"
+        except ImportError:
+            print("TreeQuest not installed, falling back to greedy search.", file=sys.stderr)
+            results = run_greedy_search(
+                seeds, args.log, args.config,
+                iterations=args.iterations,
+                top_k=args.top,
+                children_per_node=args.children,
+            )
+            strategy_label = "greedy best-first (fallback)"
+
+    # Output
+    if args.json:
+        print(json.dumps(results_to_json(results), indent=2))
+    else:
+        total = args.iterations + len(seeds)
+        print(format_results(results, metric, strategy_label, total))
+
+
+if __name__ == "__main__":
+    main()