claude-turing 3.3.0 → 3.4.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "turing",
-  "version": "3.3.0",
-  "description": "Autonomous ML research harness — the autoresearch loop as a formal protocol. 49 commands, 2 specialized agents, 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.",
+  "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

@@ -360,6 +360,10 @@ The index (`hypotheses.yaml`) is the lightweight queue. The detail files (`hypot
 | `/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:
 
@@ -544,11 +548,11 @@ Each project gets independent config, data, experiments, models, and agent memor
 
 ## Architecture of Turing Itself
 
-49 commands, 2 agents, 10 config files, 68 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), 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/              48 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)
+├── 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/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

@@ -58,6 +58,10 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | "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
 
@@ -112,6 +116,10 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | `/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.3.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

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

package/src/verify.js

@@ -63,6 +63,10 @@ const EXPECTED_COMMANDS = [
   "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()

package/templates/scripts/model_merger.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Model merging for the autoresearch pipeline.
+
+Average or merge weights from multiple fine-tuned checkpoints into a
+single model (model soups, TIES, DARE, greedy soup). Often beats any
+individual model with zero additional training cost and no latency overhead.
+
+Usage:
+    python scripts/model_merger.py exp-042 exp-053 exp-067
+    python scripts/model_merger.py exp-042 exp-053 --method greedy
+    python scripts/model_merger.py --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+from scripts.turing_io import load_config, load_experiments
+
+DEFAULT_LOG_PATH = "experiments/log.jsonl"
+MERGE_METHODS = ["uniform", "greedy", "ties", "dare"]
+
+
+def check_compatibility(experiments: list[dict]) -> dict:
+    """Check that all models share the same architecture."""
+    model_types = {e.get("config", {}).get("model_type", "?") for e in experiments}
+    compatible = len(model_types) == 1
+    return {
+        "compatible": compatible,
+        "model_types": list(model_types),
+        "n_models": len(experiments),
+        "reason": "All models share same architecture" if compatible else f"Mixed architectures: {model_types}",
+    }
+
+
+def plan_uniform_merge(
+    experiments: list[dict],
+    primary_metric: str,
+) -> dict:
+    """Plan uniform weight averaging (model soup)."""
+    metrics = [e.get("metrics", {}).get(primary_metric, 0) for e in experiments]
+    return {
+        "method": "uniform",
+        "description": "Simple average of all model weights",
+        "n_models": len(experiments),
+        "individual_metrics": [{"exp_id": e.get("experiment_id"), primary_metric: m} for e, m in zip(experiments, metrics)],
+        "weights": [round(1.0 / len(experiments), 4)] * len(experiments),
+    }
+
+
+def plan_greedy_merge(
+    experiments: list[dict],
+    primary_metric: str,
+    merge_results: list[dict] | None = None,
+) -> dict:
+    """Plan greedy soup — iteratively add models only if they improve the merge."""
+    sorted_exps = sorted(experiments, key=lambda e: e.get("metrics", {}).get(primary_metric, 0), reverse=True)
+    included = [sorted_exps[0].get("experiment_id")]
+    excluded = []
+
+    if merge_results:
+        # Use actual results to determine inclusion
+        for r in merge_results[1:]:
+            if r.get("improved", True):
+                included.append(r.get("exp_id"))
+            else:
+                excluded.append(r.get("exp_id"))
+    else:
+        # Plan: include all by default, actual filtering done at execution
+        included = [e.get("experiment_id") for e in sorted_exps]
+
+    return {
+        "method": "greedy",
+        "description": "Iteratively add models only if they improve the merged result",
+        "included": included,
+        "excluded": excluded,
+        "n_included": len(included),
+        "n_excluded": len(excluded),
+    }
+
+
+def plan_ties_merge(experiments: list[dict]) -> dict:
+    """Plan TIES merging (Trim, Elect sign, disjoint Merge)."""
+    return {
+        "method": "ties",
+        "description": "Trim redundant params, elect sign consensus, disjoint merge",
+        "n_models": len(experiments),
+        "steps": [
+            "1. Compute task vectors (delta from base) for each model",
+            "2. Trim: zero out smallest magnitude deltas",
+            "3. Elect: resolve sign conflicts by majority vote",
+            "4. Merge: average the surviving, sign-consistent deltas",
+        ],
+    }
+
+
+def plan_dare_merge(experiments: list[dict]) -> dict:
+    """Plan DARE merging (Drop And REscale)."""
+    return {
+        "method": "dare",
+        "description": "Randomly drop parameters and rescale survivors to reduce interference",
+        "n_models": len(experiments),
+        "drop_rate": 0.5,
+        "steps": [
+            "1. Compute task vectors for each model",
+            "2. Randomly drop 50% of parameters per model",
+            "3. Rescale surviving parameters by 1/(1-drop_rate)",
+            "4. Average the rescaled task vectors",
+        ],
+    }
+
+
+def compare_merge_methods(
+    method_results: dict[str, dict] | None = None,
+    experiments: list[dict] | None = None,
+    primary_metric: str = "accuracy",
+) -> dict:
+    """Compare merge method results."""
+    if not experiments:
+        return {"error": "No experiments provided"}
+
+    # Best single model
+    best_single = max(experiments, key=lambda e: e.get("metrics", {}).get(primary_metric, 0))
+    best_metric = best_single.get("metrics", {}).get(primary_metric, 0)
+
+    results = [{
+        "method": "best_single",
+        "metric_value": best_metric,
+        "delta": 0.0,
+        "experiment_id": best_single.get("experiment_id"),
+    }]
+
+    if method_results:
+        for method_name, data in method_results.items():
+            metric = data.get("metric_value", data.get(primary_metric, 0))
+            results.append({
+                "method": method_name,
+                "metric_value": metric,
+                "delta": round(metric - best_metric, 6),
+            })
+
+    best_merge = max(results, key=lambda r: r.get("metric_value", 0))
+
+    return {
+        "results": results,
+        "best_method": best_merge.get("method"),
+        "best_metric": best_merge.get("metric_value"),
+        "improvement": best_merge.get("delta", 0),
+    }
+
+
+def merge_analysis(
+    exp_ids: list[str] | None = None,
+    method_results: dict[str, dict] | None = None,
+    config_path: str = "config.yaml",
+    log_path: str = DEFAULT_LOG_PATH,
+) -> dict:
+    """Run merge analysis."""
+    config = load_config(config_path)
+    primary_metric = config.get("evaluation", {}).get("primary_metric", "accuracy")
+    experiments = load_experiments(log_path)
+
+    if exp_ids:
+        selected = [e for e in experiments if e.get("experiment_id") in exp_ids]
+    else:
+        # Default: top 3 kept experiments
+        kept = sorted(
+            [e for e in experiments if e.get("status") == "kept"],
+            key=lambda e: e.get("metrics", {}).get(primary_metric, 0), reverse=True,
+        )
+        selected = kept[:3]
+
+    if len(selected) < 2:
+        return {"error": "Need at least 2 experiments for model merging"}
+
+    compat = check_compatibility(selected)
+
+    plans = {
+        "uniform": plan_uniform_merge(selected, primary_metric),
+        "greedy": plan_greedy_merge(selected, primary_metric),
+        "ties": plan_ties_merge(selected),
+        "dare": plan_dare_merge(selected),
+    }
+
+    comparison = compare_merge_methods(method_results, selected, primary_metric) if method_results else None
+
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "primary_metric": primary_metric,
+        "compatibility": compat,
+        "base_models": [{"exp_id": e.get("experiment_id"),
+                        "model_type": e.get("config", {}).get("model_type"),
+                        primary_metric: e.get("metrics", {}).get(primary_metric)}
+                       for e in selected],
+        "plans": plans,
+        "comparison": comparison,
+    }
+
+
+def save_merge_report(report: dict, output_dir: str = "experiments/merges") -> Path:
+    out = Path(output_dir); out.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+    fp = out / f"merge-{ts}.yaml"
+    with open(fp, "w") as f: yaml.dump(json.loads(json.dumps(report, default=str)), f, default_flow_style=False, sort_keys=False)
+    return fp
+
+
+def format_merge_report(report: dict) -> str:
+    if "error" in report: return f"ERROR: {report['error']}"
+
+    metric = report.get("primary_metric", "metric")
+    lines = ["# Model Merge Analysis", "",
+             f"*Generated {report.get('generated_at', 'N/A')[:19]}*", ""]
+
+    # Compatibility
+    compat = report.get("compatibility", {})
+    lines.append(f"**Compatibility:** {'✓' if compat.get('compatible') else '✗'} {compat.get('reason', '')}")
+    lines.append("")
+
+    # Base models
+    lines.extend(["## Base Models", "",
+                  f"| Experiment | Model Type | {metric} |",
+                  "|------------|------------|--------|"])
+    for m in report.get("base_models", []):
+        val = m.get(metric, "N/A")
+        val_str = f"{val:.4f}" if isinstance(val, float) else str(val)
+        lines.append(f"| {m.get('exp_id', '?')} | {m.get('model_type', '?')} | {val_str} |")
+    lines.append("")
+
+    # Methods
+    plans = report.get("plans", {})
+    if plans:
+        lines.extend(["## Available Methods", ""])
+        for name, plan in plans.items():
+            lines.append(f"- **{name}:** {plan.get('description', '')}")
+        lines.append("")
+
+    # Comparison (if results available)
+    comparison = report.get("comparison")
+    if comparison:
+        lines.extend(["## Results", "",
+                      f"| Method | {metric} | Δ vs Best Single |",
+                      "|--------|--------|------------------|"])
+        for r in comparison.get("results", []):
+            val = f"{r.get('metric_value', 0):.4f}"
+            delta = f"{r.get('delta', 0):+.4f}" if r.get("delta") is not None else "—"
+            marker = " ← BEST" if r["method"] == comparison.get("best_method") and r["method"] != "best_single" else ""
+            lines.append(f"| {r['method']} | {val} | {delta} |{marker}")
+        lines.append("")
+        imp = comparison.get("improvement", 0)
+        if imp > 0:
+            lines.append(f"**{comparison['best_method']} improves by {imp:+.4f} over best single model — zero latency cost.**")
+
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Model merging")
+    parser.add_argument("exp_ids", nargs="*", help="Experiment IDs to merge")
+    parser.add_argument("--method", choices=MERGE_METHODS, help="Specific merge method")
+    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 = merge_analysis(exp_ids=args.exp_ids or None, config_path=args.config, log_path=args.log)
+    if "error" not in report:
+        fp = save_merge_report(report); print(f"Saved to {fp}", file=sys.stderr)
+    print(json.dumps(report, indent=2, default=str) if args.json else format_merge_report(report))
+
+if __name__ == "__main__": main()

package/templates/scripts/model_pruning.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Weight pruning for the autoresearch pipeline.
+
+Structured and unstructured weight pruning. Measures accuracy at different
+sparsity levels, finds the knee point, and plans pruned model production.
+
+Usage:
+    python scripts/model_pruning.py exp-042
+    python scripts/model_pruning.py exp-042 --sparsity 0.5,0.75,0.9
+    python scripts/model_pruning.py exp-042 --method magnitude
+    python scripts/model_pruning.py --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+from scripts.turing_io import load_config, load_experiments
+
+DEFAULT_LOG_PATH = "experiments/log.jsonl"
+DEFAULT_SPARSITY_LEVELS = [0.0, 0.50, 0.75, 0.90, 0.95]
+PRUNING_METHODS = ["magnitude", "structured", "lottery"]
+
+
+def plan_sparsity_sweep(
+    sparsity_levels: list[float] | None = None,
+) -> list[dict]:
+    if sparsity_levels is None:
+        sparsity_levels = DEFAULT_SPARSITY_LEVELS
+    return [{"sparsity": s, "description": f"{s*100:.0f}% weights removed"} for s in sparsity_levels]
+
+
+def compute_pruning_plan(
+    model_type: str,
+    hyperparams: dict,
+    method: str,
+    sparsity: float,
+) -> dict:
+    plan = {"method": method, "sparsity": sparsity, "config_changes": {}}
+    if "xgboost" in model_type.lower() or "lightgbm" in model_type.lower() or "forest" in model_type.lower():
+        n_est = hyperparams.get("n_estimators", 100)
+        plan["config_changes"]["n_estimators"] = max(1, int(n_est * (1 - sparsity)))
+        plan["strategy"] = "reduce_estimators"
+    elif method == "magnitude":
+        plan["strategy"] = "zero_small_weights"
+        plan["description"] = f"Zero out smallest {sparsity*100:.0f}% of weights by absolute value"
+    elif method == "structured":
+        plan["strategy"] = "remove_neurons"
+        plan["description"] = f"Remove {sparsity*100:.0f}% of neurons/filters by importance"
+    elif method == "lottery":
+        plan["strategy"] = "iterative_magnitude_with_rewind"
+        plan["description"] = f"Iterative pruning to {sparsity*100:.0f}% with weight rewinding"
+    return plan
+
+
+def find_knee_point(sweep_results: list[dict], metric_key: str = "accuracy") -> dict | None:
+    if len(sweep_results) < 3:
+        return None
+    sparsities = [r["sparsity"] for r in sweep_results]
+    metrics = [r.get(metric_key, 0) for r in sweep_results]
+    max_drop = 0
+    knee_idx = None
+    for i in range(1, len(metrics)):
+        drop = metrics[i - 1] - metrics[i]
+        if drop > max_drop:
+            max_drop = drop
+            knee_idx = i
+    if knee_idx and knee_idx > 0:
+        return {"sparsity": sparsities[knee_idx - 1],
+                "metric_before_knee": round(metrics[knee_idx - 1], 6),
+                "metric_after_knee": round(metrics[knee_idx], 6),
+                "drop_at_knee": round(max_drop, 6)}
+    return None
+
+
+def estimate_speedup(sparsity: float) -> float:
+    if sparsity <= 0:
+        return 1.0
+    return round(1.0 / (1.0 - sparsity * 0.7), 2)
+
+
+def estimate_size_reduction(sparsity: float) -> float:
+    return round(sparsity * 100, 1)
+
+
+def analyze_pruning(
+    sweep_results: list[dict] | None = None,
+    exp_id: str | None = None,
+    method: str = "magnitude",
+    config_path: str = "config.yaml",
+    log_path: str = DEFAULT_LOG_PATH,
+) -> dict:
+    config = load_config(config_path)
+    primary_metric = config.get("evaluation", {}).get("primary_metric", "accuracy")
+
+    if sweep_results:
+        knee = find_knee_point(sweep_results, primary_metric)
+        for r in sweep_results:
+            r["speedup"] = estimate_speedup(r["sparsity"])
+            r["size_reduction_pct"] = estimate_size_reduction(r["sparsity"])
+        recommended = None
+        for r in sweep_results:
+            delta = abs(r.get(primary_metric, 0) - sweep_results[0].get(primary_metric, 0))
+            if delta < 0.005 and r["sparsity"] > 0:
+                recommended = r
+        return {
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "experiment_id": exp_id, "method": method, "primary_metric": primary_metric,
+            "sweep_results": sweep_results, "knee_point": knee,
+            "recommended": recommended,
+        }
+
+    experiments = load_experiments(log_path)
+    exp = next((e for e in experiments if e.get("experiment_id") == exp_id), None) if exp_id else None
+    model_type = exp.get("config", {}).get("model_type", "unknown") if exp else "unknown"
+    hyperparams = exp.get("config", {}).get("hyperparams", {}) if exp else {}
+
+    levels = plan_sparsity_sweep()
+    plans = [compute_pruning_plan(model_type, hyperparams, method, s["sparsity"]) for s in levels]
+    return {
+        "action": "plan", "generated_at": datetime.now(timezone.utc).isoformat(),
+        "experiment_id": exp_id, "model_type": model_type, "method": method,
+        "sparsity_levels": levels, "plans": plans,
+        "message": f"Run {len(levels)} experiments at sparsity levels: {', '.join(s['description'] for s in levels)}",
+    }
+
+
+def save_pruning_report(report: dict, output_dir: str = "experiments/pruning") -> Path:
+    out = Path(output_dir); out.mkdir(parents=True, exist_ok=True)
+    exp_id = report.get("experiment_id", "unknown")
+    fp = out / f"{exp_id}-pruning.yaml"
+    with open(fp, "w") as f: yaml.dump(json.loads(json.dumps(report, default=str)), f, default_flow_style=False, sort_keys=False)
+    return fp
+
+
+def format_pruning_report(report: dict) -> str:
+    if "error" in report: return f"ERROR: {report['error']}"
+    if report.get("action") == "plan":
+        lines = ["# Pruning Plan", "", f"**Model:** {report.get('model_type', '?')}", f"**Method:** {report.get('method', '?')}", ""]
+        for p in report.get("plans", []):
+            lines.append(f"- {p.get('sparsity', 0)*100:.0f}%: {p.get('strategy', '?')}")
+        return "\n".join(lines)
+
+    metric = report.get("primary_metric", "metric")
+    lines = [f"# Pruning Results: {report.get('experiment_id', '?')}", "",
+             f"| Sparsity | {metric} | Speedup | Size Reduction |",
+             "|----------|--------|---------|----------------|"]
+    for r in report.get("sweep_results", []):
+        val = f"{r.get(metric, 0):.4f}" if isinstance(r.get(metric), (int, float)) else "N/A"
+        lines.append(f"| {r['sparsity']*100:.0f}% | {val} | {r.get('speedup', '?')}x | {r.get('size_reduction_pct', '?')}% |")
+    knee = report.get("knee_point")
+    if knee:
+        lines.extend(["", f"**Knee point:** {knee['sparsity']*100:.0f}% sparsity (accuracy drops {knee['drop_at_knee']:.4f})"])
+    rec = report.get("recommended")
+    if rec:
+        lines.extend(["", f"**Recommended:** {rec['sparsity']*100:.0f}% sparsity ({rec.get('speedup', '?')}x speedup, <0.5% accuracy loss)"])
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Weight pruning")
+    parser.add_argument("exp_id", nargs="?")
+    parser.add_argument("--sparsity", help="Comma-separated sparsity levels")
+    parser.add_argument("--method", choices=PRUNING_METHODS, default="magnitude")
+    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 = analyze_pruning(exp_id=args.exp_id, method=args.method, config_path=args.config, log_path=args.log)
+    if "error" not in report:
+        fp = save_pruning_report(report); print(f"Saved to {fp}", file=sys.stderr)
+    print(json.dumps(report, indent=2, default=str) if args.json else format_pruning_report(report))
+
+if __name__ == "__main__": main()

package/templates/scripts/model_quantization.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Post-training quantization for the autoresearch pipeline.
+
+Quantize model weights from FP32 to INT8/FP16, measure accuracy loss
+per precision level, and plan quantization-aware training if needed.
+
+Usage:
+    python scripts/model_quantization.py exp-042
+    python scripts/model_quantization.py exp-042 --precision int8
+    python scripts/model_quantization.py --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+from scripts.turing_io import load_config, load_experiments
+
+DEFAULT_LOG_PATH = "experiments/log.jsonl"
+PRECISION_LEVELS = ["fp32", "fp16", "int8_dynamic", "int8_static"]
+QAT_THRESHOLD = 0.01  # If PTQ accuracy loss > 1%, suggest QAT
+
+
+def compute_quantization_plan(
+    precision: str,
+    model_size_bytes: int | None = None,
+    latency_ms: float | None = None,
+) -> dict:
+    size_factors = {"fp32": 1.0, "fp16": 0.5, "int8_dynamic": 0.25, "int8_static": 0.25}
+    latency_factors = {"fp32": 1.0, "fp16": 0.58, "int8_dynamic": 0.39, "int8_static": 0.37}
+
+    factor_s = size_factors.get(precision, 1.0)
+    factor_l = latency_factors.get(precision, 1.0)
+
+    plan = {
+        "precision": precision,
+        "size_factor": factor_s,
+        "latency_factor": factor_l,
+        "estimated_size_bytes": int(model_size_bytes * factor_s) if model_size_bytes else None,
+        "estimated_latency_ms": round(latency_ms * factor_l, 2) if latency_ms else None,
+        "size_reduction_pct": round((1 - factor_s) * 100, 1),
+        "speedup": round(1 / factor_l, 2) if factor_l > 0 else None,
+    }
+
+    if precision == "fp16":
+        plan["description"] = "Half-precision floating point — GPU inference"
+        plan["method"] = "cast_to_fp16"
+    elif precision == "int8_dynamic":
+        plan["description"] = "Dynamic INT8 — weights quantized, activations at runtime"
+        plan["method"] = "dynamic_quantization"
+    elif precision == "int8_static":
+        plan["description"] = "Static INT8 — calibrated activation ranges, best accuracy"
+        plan["method"] = "static_quantization"
+        plan["requires_calibration"] = True
+    else:
+        plan["description"] = "Full precision (baseline)"
+        plan["method"] = "none"
+
+    return plan
+
+
+def compare_precision_levels(
+    sweep_results: list[dict] | None = None,
+    model_size_bytes: int | None = None,
+    latency_ms: float | None = None,
+    primary_metric: str = "accuracy",
+) -> dict:
+    """Compare quantization results across precision levels."""
+    if sweep_results:
+        baseline = next((r for r in sweep_results if r.get("precision") == "fp32"), sweep_results[0])
+        baseline_metric = baseline.get(primary_metric, 0)
+
+        for r in sweep_results:
+            r["delta"] = round(r.get(primary_metric, 0) - baseline_metric, 6)
+            plan = compute_quantization_plan(r["precision"], model_size_bytes, latency_ms)
+            r.update({k: v for k, v in plan.items() if k not in r})
+
+        best = min(
+            [r for r in sweep_results if r["precision"] != "fp32"],
+            key=lambda r: abs(r.get("delta", 0)) + (1 - r.get("speedup", 1)) * 0.1,
+            default=None,
+        )
+
+        needs_qat = any(abs(r.get("delta", 0)) > QAT_THRESHOLD for r in sweep_results if "int8" in r.get("precision", ""))
+
+        return {
+            "sweep_results": sweep_results,
+            "recommended": best,
+            "needs_qat": needs_qat,
+        }
+
+    # Plan mode
+    plans = [compute_quantization_plan(p, model_size_bytes, latency_ms) for p in PRECISION_LEVELS]
+    return {"action": "plan", "plans": plans}
+
+
+def analyze_quantization(
+    sweep_results: list[dict] | None = None,
+    exp_id: str | None = None,
+    config_path: str = "config.yaml",
+    log_path: str = DEFAULT_LOG_PATH,
+) -> dict:
+    config = load_config(config_path)
+    primary_metric = config.get("evaluation", {}).get("primary_metric", "accuracy")
+
+    experiments = load_experiments(log_path)
+    exp = next((e for e in experiments if e.get("experiment_id") == exp_id), None) if exp_id else None
+
+    model_size = exp.get("metrics", {}).get("model_size_bytes") if exp else None
+    latency = exp.get("metrics", {}).get("latency_ms", exp.get("metrics", {}).get("inference_ms")) if exp else None
+
+    comparison = compare_precision_levels(sweep_results, model_size, latency, primary_metric)
+
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "experiment_id": exp_id,
+        "primary_metric": primary_metric,
+        **comparison,
+    }
+
+
+def save_quantization_report(report: dict, output_dir: str = "experiments/quantization") -> Path:
+    out = Path(output_dir); out.mkdir(parents=True, exist_ok=True)
+    exp_id = report.get("experiment_id", "unknown")
+    fp = out / f"{exp_id}-quantization.yaml"
+    with open(fp, "w") as f: yaml.dump(json.loads(json.dumps(report, default=str)), f, default_flow_style=False, sort_keys=False)
+    return fp
+
+
+def format_quantization_report(report: dict) -> str:
+    if "error" in report: return f"ERROR: {report['error']}"
+
+    if report.get("action") == "plan":
+        lines = ["# Quantization Plan", ""]
+        for p in report.get("plans", []):
+            lines.append(f"- **{p['precision']}**: {p['description']} (size: {p['size_reduction_pct']}% reduction, speedup: {p.get('speedup', '?')}x)")
+        return "\n".join(lines)
+
+    metric = report.get("primary_metric", "metric")
+    lines = [f"# Quantization Results: {report.get('experiment_id', '?')}", "",
+             f"| Precision | {metric} | Delta | Speedup | Size Reduction |",
+             "|-----------|--------|-------|---------|----------------|"]
+    for r in report.get("sweep_results", []):
+        val = f"{r.get(metric, 0):.4f}" if isinstance(r.get(metric), (int, float)) else "N/A"
+        delta = f"{r.get('delta', 0):+.4f}" if r.get("delta") is not None else "—"
+        lines.append(f"| {r['precision']} | {val} | {delta} | {r.get('speedup', '?')}x | {r.get('size_reduction_pct', '?')}% |")
+
+    rec = report.get("recommended")
+    if rec:
+        lines.extend(["", f"**Recommended:** {rec['precision']} ({rec.get('delta', 0):+.4f} accuracy, {rec.get('speedup', '?')}x speedup)"])
+    if report.get("needs_qat"):
+        lines.extend(["", "**Note:** INT8 accuracy loss > 1% — consider quantization-aware training (QAT)"])
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Post-training quantization")
+    parser.add_argument("exp_id", nargs="?")
+    parser.add_argument("--precision", help="Specific precision level")
+    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 = analyze_quantization(exp_id=args.exp_id, config_path=args.config, log_path=args.log)
+    if "error" not in report:
+        fp = save_quantization_report(report); print(f"Saved to {fp}", file=sys.stderr)
+    print(json.dumps(report, indent=2, default=str) if args.json else format_quantization_report(report))
+
+if __name__ == "__main__": main()

package/templates/scripts/scaffold.py

@@ -126,6 +126,10 @@ TEMPLATE_DIRS = {
         "calibration.py",
         "feature_intelligence.py",
         "curriculum_optimizer.py",
+        "model_pruning.py",
+        "model_quantization.py",
+        "model_merger.py",
+        "architecture_surgery.py",
     ],
     "tests": ["__init__.py", "conftest.py"],
 }
@@ -164,6 +168,10 @@ DIRECTORIES_TO_CREATE = [
     "experiments/calibration",
     "experiments/features",
     "experiments/curriculum",
+    "experiments/pruning",
+    "experiments/quantization",
+    "experiments/merges",
+    "experiments/surgery",
     "experiments/logs",
     "models/best",
     "models/archive",