claude-turing 3.2.0 → 3.4.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "turing",
-  "version": "3.2.0",
-  "description": "Autonomous ML research harness — the autoresearch loop as a formal protocol. 47 commands, 2 specialized agents, model debugging (xray + sensitivity + calibration), pre-training intelligence (sanity checks + baseline generation + leakage detection), meta-intelligence (cross-project knowledge transfer + methodology audit), scaling & efficiency (scaling laws + compute budget + model distillation), model composition (ensemble + pipeline stitch + warm-start), deep analysis (experiment diff + live training monitor + regression gate), experiment orchestration (batch queue + smart retry + branching), literature integration + paper drafting, production model export, performance profiling, smart checkpoints, experiment intelligence, statistical rigor, tree-search hypothesis exploration, cost-performance frontier, 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": "3.4.0",
+  "description": "Autonomous ML research harness — the autoresearch loop as a formal protocol. 53 commands, 2 specialized agents, model surgery (pruning + quantization + merging + architecture modification), feature & training intelligence (feature selection + curriculum optimization), model debugging (xray + sensitivity + calibration), pre-training intelligence (sanity checks + baseline generation + leakage detection), meta-intelligence (cross-project knowledge transfer + methodology audit), scaling & efficiency (scaling laws + compute budget + model distillation), model composition (ensemble + pipeline stitch + warm-start), deep analysis (experiment diff + live training monitor + regression gate), experiment orchestration (batch queue + smart retry + branching), literature integration + paper drafting, production model export, performance profiling, smart checkpoints, experiment intelligence, statistical rigor, tree-search hypothesis exploration, cost-performance frontier, 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

@@ -358,6 +358,12 @@ The index (`hypotheses.yaml`) is the lightweight queue. The detail files (`hypot
 | `/turing:xray [exp-id]` | Internal model diagnostics — gradient flow, dead neurons, weight distributions, tree analysis |
 | `/turing:sensitivity [exp-id]` | Hyperparameter sensitivity — rank parameters by impact, detect non-monotonic responses |
 | `/turing:calibrate [exp-id]` | Probability calibration — ECE/MCE, reliability diagrams, Platt/isotonic/temperature scaling |
+| `/turing:feature [--method]` | Automated feature selection — multi-method consensus ranking, redundancy, interactions |
+| `/turing:curriculum [exp-id]` | Training curriculum optimization — difficulty scoring, strategy comparison, mislabeled sample detection |
+| `/turing:prune <exp-id>` | Weight pruning — magnitude/structured/lottery, sparsity sweep, knee point detection |
+| `/turing:quantize <exp-id>` | Post-training quantization — FP16/INT8, accuracy-latency comparison |
+| `/turing:merge <exp-ids...>` | Model merging — uniform/greedy soup, TIES, DARE, zero latency cost |
+| `/turing:surgery <exp-id>` | Architecture modification — add/remove layer, widen/narrow, swap activation |
 
 And for fully hands-off operation:
 
@@ -542,11 +548,11 @@ Each project gets independent config, data, experiments, models, and agent memor
 
 ## Architecture of Turing Itself
 
-47 commands, 2 agents, 10 config files, 66 template scripts, model registry, artifact contract, cost-performance frontier, model cards, tree-search exploration, statistical rigor, experiment intelligence, performance profiling, smart checkpoints, production model export, literature integration, paper section drafting, experiment orchestration (queue + retry + fork), deep analysis (diff + watch + regress), model composition (ensemble + stitch + warm), scaling & efficiency (scale + budget + distill), meta-intelligence (transfer + audit), pre-training intelligence (sanity + baseline + leak), model debugging (xray + sensitivity + calibrate), 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
+53 commands, 2 agents, 10 config files, 72 template scripts, model registry, artifact contract, cost-performance frontier, model cards, tree-search exploration, statistical rigor, experiment intelligence, performance profiling, smart checkpoints, production model export, literature integration, paper section drafting, experiment orchestration (queue + retry + fork), deep analysis (diff + watch + regress), model composition (ensemble + stitch + warm), scaling & efficiency (scale + budget + distill), meta-intelligence (transfer + audit), pre-training intelligence (sanity + baseline + leak), model debugging (xray + sensitivity + calibrate), feature & training intelligence (feature + curriculum), model surgery (prune + quantize + merge + surgery), 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
 
 ```
 turing/
-├── commands/              46 skill files (core + taste-leverage + reporting + exploration + statistical rigor + experiment intelligence + performance + deployment + research workflow + orchestration + deep analysis + model composition + scaling & efficiency + meta-intelligence + pre-training intelligence + model debugging)
+├── commands/              52 skill files (core + taste-leverage + reporting + exploration + statistical rigor + experiment intelligence + performance + deployment + research workflow + orchestration + deep analysis + model composition + scaling & efficiency + meta-intelligence + pre-training intelligence + model debugging + feature & training intelligence + model surgery)
 ├── 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

package/commands/curriculum.md

@@ -0,0 +1,43 @@
+---
+name: curriculum
+description: Training curriculum optimization — order data by difficulty, compare easy-to-hard vs hard-to-easy vs self-paced strategies.
+disable-model-invocation: true
+argument-hint: "[exp-id] [--strategies easy-to-hard,random]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Does the order your model sees data matter? Find out systematically.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - Optional experiment ID
+   - `--strategies "easy_to_hard,hard_to_easy,self_paced,random"` — strategies to test
+   - `--json` — raw JSON output
+
+3. **Run curriculum analysis:**
+   ```bash
+   python scripts/curriculum_optimizer.py $ARGUMENTS
+   ```
+
+4. **Strategies tested:**
+   - **Random:** standard shuffling (control)
+   - **Easy-to-hard:** classic curriculum learning
+   - **Hard-to-easy:** anti-curriculum
+   - **Self-paced:** start easy, gradually include harder samples
+
+5. **Report includes:** strategy comparison table with metric, convergence epoch, and speedup vs random; impossible sample detection (likely mislabeled)
+
+6. **Saved output:** report in `experiments/curriculum/<exp-id>-curriculum.yaml`
+
+## Examples
+
+```
+/turing:curriculum exp-042                      # All strategies
+/turing:curriculum --strategies easy_to_hard,random  # Specific strategies
+```

package/commands/feature.md

@@ -0,0 +1,42 @@
+---
+name: feature
+description: Automated feature selection — multi-method importance consensus, redundancy detection, and interaction feature generation.
+disable-model-invocation: true
+argument-hint: "[--method all|importance] [--top-k 20]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Systematically evaluate which features matter and which are noise.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - `--method all|importance|selection|generation` — analysis type (default: all)
+   - `--top-k 20` — number of top features to consider
+   - `--json` — raw JSON output
+
+3. **Run feature analysis:**
+   ```bash
+   python scripts/feature_intelligence.py $ARGUMENTS
+   ```
+
+4. **Report includes:**
+   - Consensus ranking: features ranked by number of methods placing them in top-K
+   - Per-method ranks: mutual information, L1, tree-based
+   - Redundant pairs: features with |r| > 0.95
+   - Candidate interaction features from top consensus set
+   - Drop recommendation for zero-consensus features
+
+5. **Saved output:** report in `experiments/features/features-*.yaml`
+
+## Examples
+
+```
+/turing:feature                      # Full analysis
+/turing:feature --top-k 10           # Top-10 consensus
+```

package/commands/merge.md

@@ -0,0 +1,24 @@
+---
+name: merge
+description: Model merging — average weights from multiple checkpoints into a single model (soups, TIES, DARE). Free accuracy, zero latency cost.
+disable-model-invocation: true
+argument-hint: "<exp-ids...> [--method uniform|greedy|ties|dare]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Combine model weights (not predictions) into a single, better model with no latency overhead.
+
+## Steps
+
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/model_merger.py $ARGUMENTS`
+3. **Methods:** uniform soup (simple average), greedy soup (include only if improves), TIES (trim+elect+merge), DARE (drop+rescale)
+4. **Report:** compatibility check, per-model metrics, method comparison, improvement delta
+5. **Saved output:** `experiments/merges/merge-*.yaml`
+
+## Examples
+
+```
+/turing:merge exp-042 exp-053 exp-067              # All methods
+/turing:merge exp-042 exp-053 --method greedy      # Greedy soup only
+```

package/commands/prune.md

@@ -0,0 +1,26 @@
+---
+name: prune
+description: Weight pruning — measure accuracy at different sparsity levels, find the knee point, produce a smaller/faster model.
+disable-model-invocation: true
+argument-hint: "<exp-id> [--sparsity 0.5,0.75,0.9] [--method magnitude|structured|lottery]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Remove redundant weights for faster inference and smaller models.
+
+## Steps
+
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/model_pruning.py $ARGUMENTS`
+3. **Methods:** magnitude (zero small weights), structured (remove neurons), lottery (iterative with rewind)
+4. **For tree models:** progressively reduces n_estimators
+5. **Report:** sparsity sweep table, knee point, recommended sparsity
+6. **Saved output:** `experiments/pruning/<exp-id>-pruning.yaml`
+
+## Examples
+
+```
+/turing:prune exp-042                              # Default: magnitude, 5 levels
+/turing:prune exp-042 --method structured          # Remove entire neurons
+/turing:prune exp-042 --sparsity 0.5,0.75,0.9     # Custom levels
+```

package/commands/quantize.md

@@ -0,0 +1,24 @@
+---
+name: quantize
+description: Post-training quantization — FP32→INT8/FP16, measure accuracy loss, 2-4x speedup with <0.5% accuracy loss.
+disable-model-invocation: true
+argument-hint: "<exp-id> [--precision int8|fp16|dynamic]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Quantize for production. Lowest-effort optimization: 2-4x speedup, 2-4x memory reduction.
+
+## Steps
+
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/model_quantization.py $ARGUMENTS`
+3. **Precision levels:** FP32 (baseline), FP16 (GPU), INT8 dynamic (simplest), INT8 static (best accuracy)
+4. **Report:** precision comparison table, recommended level, QAT suggestion if needed
+5. **Saved output:** `experiments/quantization/<exp-id>-quantization.yaml`
+
+## Examples
+
+```
+/turing:quantize exp-042                    # Compare all precision levels
+/turing:quantize exp-042 --precision int8   # INT8 specifically
+```

package/commands/surgery.md

@@ -0,0 +1,27 @@
+---
+name: surgery
+description: Architecture modification — add/remove layers, widen/narrow, swap activations, inject skip connections. Specify what to change, system handles how.
+disable-model-invocation: true
+argument-hint: "<exp-id> --op <operation> [args...]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Programmatic architecture changes with auto warm-start from existing weights.
+
+## Steps
+
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/architecture_surgery.py $ARGUMENTS`
+3. **Operations:** add-layer, remove-layer, widen, narrow, swap-activation, add-skip, add-norm, deepen, swap-objective
+4. **For tree models:** deepen (increase max_depth), widen (more estimators), swap-objective
+5. **Report:** operation details, config changes, parameter count delta, warm-start source
+6. **Saved output:** `experiments/surgery/<exp-id>-<op>.yaml`
+
+## Examples
+
+```
+/turing:surgery exp-042 --op widen 2             # 2x wider hidden layers
+/turing:surgery exp-042 --op add-layer           # Insert a layer
+/turing:surgery exp-042 --op swap-activation relu gelu  # ReLU → GELU
+/turing:surgery exp-042 --op deepen              # Deeper trees
+```

package/commands/turing.md

@@ -56,6 +56,12 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | "xray", "model internals", "dead neurons", "gradient flow", "weight distribution", "inside the model" | `/turing:xray` | Analyze |
 | "sensitivity", "which params matter", "hyperparameter importance", "parameter ranking" | `/turing:sensitivity` | Analyze |
 | "calibrate", "calibration", "ECE", "reliability diagram", "overconfident", "probability calibration" | `/turing:calibrate` | Analyze |
+| "feature", "features", "feature selection", "feature importance", "which features matter", "redundant features" | `/turing:feature` | Analyze |
+| "curriculum", "training order", "easy to hard", "data ordering", "curriculum learning" | `/turing:curriculum` | Optimize |
+| "prune", "pruning", "sparsity", "remove weights", "smaller model", "weight pruning" | `/turing:prune` | Optimize |
+| "quantize", "quantization", "int8", "fp16", "reduce precision", "faster inference" | `/turing:quantize` | Optimize |
+| "merge", "model soup", "merge weights", "average models", "TIES", "DARE" | `/turing:merge` | Compose |
+| "surgery", "architecture", "add layer", "widen", "modify model", "swap activation" | `/turing:surgery` | Modify |
 
 ## Sub-commands
 
@@ -108,6 +114,12 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | `/turing:xray [exp-id]` | Internal model diagnostics: gradient flow, dead neurons, weight distributions, tree analysis | (inline) |
 | `/turing:sensitivity [exp-id]` | Hyperparameter sensitivity analysis: rank parameters by impact, detect non-monotonic responses | (inline) |
 | `/turing:calibrate [exp-id]` | Probability calibration: ECE/MCE, reliability diagrams, Platt/isotonic/temperature scaling | (inline) |
+| `/turing:feature [--method]` | Automated feature selection: multi-method consensus ranking, redundancy, interaction generation | (inline) |
+| `/turing:curriculum [exp-id]` | Training curriculum optimization: difficulty scoring, strategy comparison, impossible sample detection | (inline) |
+| `/turing:prune <exp-id>` | Weight pruning: magnitude/structured/lottery, sparsity sweep, knee point detection | (inline) |
+| `/turing:quantize <exp-id>` | Post-training quantization: FP16/INT8, accuracy-latency comparison, QAT suggestion | (inline) |
+| `/turing:merge <exp-ids...>` | Model merging: uniform/greedy soup, TIES, DARE — free accuracy, zero latency cost | (inline) |
+| `/turing:surgery <exp-id>` | Architecture modification: add/remove layer, widen/narrow, swap activation, skip connections | (inline) |
 
 ## Proactive Detection
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-turing",
-  "version": "3.2.0",
+  "version": "3.4.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/install.js

@@ -31,6 +31,8 @@ const SUB_COMMANDS = [
   "transfer", "audit",
   "sanity", "baseline", "leak",
   "xray", "sensitivity", "calibrate",
+  "feature", "curriculum",
+  "prune", "quantize", "merge", "surgery",
 ];
 
 export async function install(opts = {}) {

package/src/verify.js

@@ -61,6 +61,12 @@ const EXPECTED_COMMANDS = [
   "xray/SKILL.md",
   "sensitivity/SKILL.md",
   "calibrate/SKILL.md",
+  "feature/SKILL.md",
+  "curriculum/SKILL.md",
+  "prune/SKILL.md",
+  "quantize/SKILL.md",
+  "merge/SKILL.md",
+  "surgery/SKILL.md",
 ];
 
 const EXPECTED_AGENTS = ["ml-researcher.md", "ml-evaluator.md"];

package/templates/scripts/architecture_surgery.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""Architecture modification for the autoresearch pipeline.
+
+Programmatic architecture changes: add/remove layers, widen/narrow,
+swap activation functions, inject skip connections, change normalization.
+Produces a modified config and instructions for the modified experiment.
+
+Usage:
+    python scripts/architecture_surgery.py exp-042 --op widen 2
+    python scripts/architecture_surgery.py exp-042 --op add-layer
+    python scripts/architecture_surgery.py exp-042 --op swap-activation relu gelu
+    python scripts/architecture_surgery.py --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+
+from scripts.turing_io import load_config, load_experiments
+
+DEFAULT_LOG_PATH = "experiments/log.jsonl"
+OPERATIONS = ["add-layer", "remove-layer", "widen", "narrow", "swap-activation",
+              "add-skip", "add-norm", "deepen", "swap-objective"]
+
+
+def plan_operation(
+    operation: str,
+    config: dict,
+    hyperparams: dict,
+    model_type: str,
+    args: list[str] | None = None,
+) -> dict:
+    """Plan an architecture modification.
+
+    Returns a plan dict with new config, parameter count change, and instructions.
+    """
+    args = args or []
+    plan = {
+        "operation": operation,
+        "model_type": model_type,
+        "original_config": hyperparams.copy(),
+        "new_config": hyperparams.copy(),
+        "instructions": [],
+        "param_change": None,
+    }
+
+    is_tree = any(t in model_type.lower() for t in ("xgboost", "lightgbm", "forest", "gbm", "catboost"))
+    is_neural = any(t in model_type.lower() for t in ("mlp", "nn", "pytorch", "tensorflow", "transformer"))
+
+    if operation == "widen":
+        factor = float(args[0]) if args else 2.0
+        if is_neural:
+            hs = hyperparams.get("hidden_size", 256)
+            new_hs = int(hs * factor)
+            plan["new_config"]["hidden_size"] = new_hs
+            plan["instructions"].append(f"Multiply hidden dimensions: {hs} → {new_hs} ({factor}x)")
+            plan["param_change"] = f"+{(factor**2 - 1)*100:.0f}% parameters (quadratic in width)"
+        elif is_tree:
+            n = hyperparams.get("n_estimators", 100)
+            new_n = int(n * factor)
+            plan["new_config"]["n_estimators"] = new_n
+            plan["instructions"].append(f"Increase estimators: {n} → {new_n}")
+            plan["param_change"] = f"+{(factor - 1)*100:.0f}% trees"
+        else:
+            plan["instructions"].append(f"Widen by {factor}x — adjust model-specific width parameters")
+
+    elif operation == "narrow":
+        factor = float(args[0]) if args else 0.5
+        if is_neural:
+            hs = hyperparams.get("hidden_size", 256)
+            new_hs = max(8, int(hs * factor))
+            plan["new_config"]["hidden_size"] = new_hs
+            plan["instructions"].append(f"Reduce hidden dimensions: {hs} → {new_hs} ({factor}x)")
+        elif is_tree:
+            n = hyperparams.get("n_estimators", 100)
+            new_n = max(1, int(n * factor))
+            plan["new_config"]["n_estimators"] = new_n
+            plan["instructions"].append(f"Reduce estimators: {n} → {new_n}")
+
+    elif operation == "add-layer":
+        if is_neural:
+            n_layers = hyperparams.get("n_layers", hyperparams.get("layers", 3))
+            plan["new_config"]["n_layers"] = n_layers + 1
+            plan["instructions"].extend([
+                f"Add layer: {n_layers} → {n_layers + 1}",
+                "New layer initialized with default weights",
+                "Auto warm-start: existing layers loaded from source",
+            ])
+            plan["param_change"] = f"+1 layer ({n_layers} → {n_layers + 1})"
+        else:
+            plan["instructions"].append("add-layer not applicable for non-neural models")
+
+    elif operation == "remove-layer":
+        if is_neural:
+            n_layers = hyperparams.get("n_layers", hyperparams.get("layers", 3))
+            if n_layers > 1:
+                plan["new_config"]["n_layers"] = n_layers - 1
+                plan["instructions"].append(f"Remove layer: {n_layers} → {n_layers - 1}")
+            else:
+                plan["instructions"].append("Cannot remove — only 1 layer remaining")
+        else:
+            plan["instructions"].append("remove-layer not applicable for non-neural models")
+
+    elif operation == "deepen":
+        if is_tree:
+            depth = hyperparams.get("max_depth", 6)
+            new_depth = depth + 2
+            plan["new_config"]["max_depth"] = new_depth
+            plan["instructions"].append(f"Increase max depth: {depth} → {new_depth}")
+        elif is_neural:
+            n_layers = hyperparams.get("n_layers", 3)
+            plan["new_config"]["n_layers"] = n_layers + 2
+            plan["instructions"].append(f"Add 2 layers: {n_layers} → {n_layers + 2}")
+
+    elif operation == "swap-activation":
+        if len(args) >= 2:
+            from_act, to_act = args[0], args[1]
+        else:
+            from_act, to_act = "relu", "gelu"
+        plan["new_config"]["activation"] = to_act
+        plan["instructions"].append(f"Swap activation: {from_act} → {to_act}")
+
+    elif operation == "add-skip":
+        plan["new_config"]["skip_connections"] = True
+        plan["instructions"].append("Inject residual/skip connections between layers")
+
+    elif operation == "add-norm":
+        norm_type = args[0] if args else "batch_norm"
+        plan["new_config"]["normalization"] = norm_type
+        plan["instructions"].append(f"Add {norm_type} after each layer")
+
+    elif operation == "swap-objective":
+        if len(args) >= 2:
+            from_obj, to_obj = args[0], args[1]
+        else:
+            from_obj, to_obj = hyperparams.get("objective", "logloss"), "focal"
+        plan["new_config"]["objective"] = to_obj
+        plan["instructions"].append(f"Swap objective: {from_obj} → {to_obj}")
+
+    else:
+        plan["instructions"].append(f"Unknown operation: {operation}")
+
+    return plan
+
+
+def surgery_report(
+    exp_id: str,
+    operation: str,
+    op_args: list[str] | None = None,
+    config_path: str = "config.yaml",
+    log_path: str = DEFAULT_LOG_PATH,
+) -> dict:
+    """Generate a surgery report."""
+    experiments = load_experiments(log_path)
+    exp = next((e for e in experiments if e.get("experiment_id") == exp_id), None)
+
+    if not exp:
+        return {"error": f"Experiment {exp_id} not found"}
+
+    config = exp.get("config", {})
+    model_type = config.get("model_type", "unknown")
+    hyperparams = config.get("hyperparams", {})
+
+    plan = plan_operation(operation, config, hyperparams, model_type, op_args)
+
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "experiment_id": exp_id,
+        "plan": plan,
+        "warm_start_from": exp_id,
+    }
+
+
+def save_surgery_report(report: dict, output_dir: str = "experiments/surgery") -> Path:
+    out = Path(output_dir); out.mkdir(parents=True, exist_ok=True)
+    exp_id = report.get("experiment_id", "unknown")
+    op = report.get("plan", {}).get("operation", "unknown")
+    fp = out / f"{exp_id}-{op}.yaml"
+    with open(fp, "w") as f: yaml.dump(report, f, default_flow_style=False, sort_keys=False)
+    return fp
+
+
+def format_surgery_report(report: dict) -> str:
+    if "error" in report: return f"ERROR: {report['error']}"
+
+    plan = report.get("plan", {})
+    exp_id = report.get("experiment_id", "?")
+    op = plan.get("operation", "?")
+
+    lines = [f"# Surgery: {op} ({exp_id})", "",
+             f"*Generated {report.get('generated_at', 'N/A')[:19]}*",
+             f"**Model:** {plan.get('model_type', '?')}", ""]
+
+    lines.extend(["## Instructions", ""])
+    for i, inst in enumerate(plan.get("instructions", []), 1):
+        lines.append(f"{i}. {inst}")
+    lines.append("")
+
+    if plan.get("param_change"):
+        lines.append(f"**Parameter change:** {plan['param_change']}")
+        lines.append("")
+
+    orig = plan.get("original_config", {})
+    new = plan.get("new_config", {})
+    changed = {k: (orig.get(k), new[k]) for k in new if orig.get(k) != new.get(k)}
+    if changed:
+        lines.extend(["## Config Changes", ""])
+        for k, (old, new_v) in changed.items():
+            lines.append(f"- `{k}`: {old} → {new_v}")
+        lines.append("")
+
+    lines.append(f"**Warm-start from:** {report.get('warm_start_from', '?')}")
+
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Architecture modification")
+    parser.add_argument("exp_id")
+    parser.add_argument("--op", required=True, help="Operation name")
+    parser.add_argument("op_args", nargs="*", help="Operation arguments")
+    parser.add_argument("--config", default="config.yaml")
+    parser.add_argument("--log", default=DEFAULT_LOG_PATH)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    report = surgery_report(args.exp_id, args.op, args.op_args, args.config, args.log)
+    if "error" not in report:
+        fp = save_surgery_report(report); print(f"Saved to {fp}", file=sys.stderr)
+    print(json.dumps(report, indent=2, default=str) if args.json else format_surgery_report(report))
+
+if __name__ == "__main__": main()