claude-turing 4.6.0 → 4.8.0

package/skills/turing/rules/loop-protocol.md

@@ -0,0 +1,91 @@
+# Autoresearch Loop Protocol Rules
+
+These rules govern the autonomous ML experiment loop. They are non-negotiable safety constraints that preserve the integrity of the experimental process.
+
+## The Fundamental Separation
+
+The autoresearch harness enforces a strict separation between the **hypothesis space** (what the agent can change) and the **measurement apparatus** (how results are evaluated). This separation is the architectural invariant that makes autonomous experimentation trustworthy.
+
+| Layer | Files | Agent Access | Rationale |
+|-------|-------|-------------|-----------|
+| Hidden | `evaluate.py` | NONE — do not read, write, or reference | Reading evaluation code enables seed exploitation and metric gaming |
+| Measurement | `prepare.py` | READ-ONLY | Data loading is visible but immutable |
+| Hypothesis | `train.py` | READ-WRITE | All experimental changes go here |
+| Configuration | `config.yaml` | READ-WRITE | Hyperparameter changes without code changes |
+| Features | `features/featurizers.py` | READ-ONLY | Modify how `train.py` *uses* featurizers instead |
+
+## Execution Rules
+
+- **ALWAYS redirect training output:** `python train.py > run.log 2>&1`
+- **ALWAYS parse metrics with grep** between `---` delimiters: `grep -A 10 "^---" run.log | head -10`
+- **ALWAYS activate the venv first:** `source .venv/bin/activate`
+- **NEVER install new packages** without human approval
+
+## Git Discipline
+
+### Per-Experiment Branches (preferred)
+
+- **Create branch before each experiment:** `git checkout -b exp/{NNN}-{short-description}`
+- **Commit changes on the branch:** `git commit -am "exp: {description}"`
+- **Run the experiment on the branch**
+- **If improved:** `git checkout main && git merge exp/{NNN}-{short-description}`. Copy model to `models/best/`.
+- **If NOT improved:** `git checkout main`. Branch preserved for comparison.
+- **Keep all experiment branches** — they preserve code variants for later analysis.
+
+### Fallback: Commit/Revert (mid-sweep)
+
+- **ALWAYS commit before running:** `git commit -am "exp: {description}"`
+- **If improved:** keep commit, copy model to `models/best/`
+- **If NOT improved:** `git reset --hard HEAD~1`
+
+## Sweep Workflow
+
+1. Generate queue: `python scripts/sweep.py`
+2. Check status: `python scripts/sweep.py --status`
+3. Get next: `python scripts/sweep.py --next`
+4. Apply overrides, create branch, run training
+5. Mark: `python scripts/sweep.py --mark <name> complete|failed`
+6. Repeat until queue is empty
+
+## Logging Rules
+
+- **Log every experiment** to `experiments/log.jsonl` via `python scripts/log_experiment.py` — kept and discarded alike.
+- **Include all metrics, config, and description** of the hypothesis and its outcome.
+
+## Convergence Rules
+
+- **N consecutive non-improvements** (from `config.yaml` `convergence.patience`) with less than threshold relative gain = STOP.
+- **max_iterations** (if provided) overrides convergence.
+- **Always report** final best model, metrics, and recommended next steps when stopping.
+
+## Tool Restrictions
+
+The researcher agent's Bash access is restricted to a whitelist of necessary commands:
+
+| Allowed Pattern | Purpose |
+|-----------------|---------|
+| `python train.py:*` | Execute training |
+| `python scripts/*:*` | Run utility scripts (logging, metrics, sweep) |
+| `git:*` | Branch, commit, merge, reset operations |
+| `source .venv/bin/activate:*` | Virtual environment activation |
+| `pip:*` | Package installation (requires human approval) |
+
+**Blocked by omission:** `cat`, `head`, `tail`, `less` (prevents reading hidden files via shell), `curl`, `wget` (prevents data exfiltration), arbitrary command execution.
+
+The agent's Read tool is separately governed by the file access tiers above — hidden files are denied at the tool level.
+
+## Reproducibility Rules
+
+Every experiment must be fully reproducible. The training template handles this automatically, but the agent must not subvert it:
+
+- **NEVER use unseeded randomness.** All random state flows from `config.yaml → data.random_state`. The `pin_all_seeds()` function in `train.py` sets stdlib `random`, `numpy`, `PYTHONHASHSEED`, and `torch`/`cuda` seeds from this single source.
+- **NEVER modify seeds mid-experiment.** If you need a different seed, use `--seed` flag for multi-run comparison (Phase 2.1). Do not hardcode seeds in `train.py`.
+- **Environment is captured automatically.** `train_metadata.json` records python version, package versions, platform, GPU info, and a config hash. Do not modify this recording — it's used by behavioral probes.
+- **Config snapshot:** The config at training time is stored inside the model artifact (`model.joblib` contains the full config dict). For any saved model, the exact configuration can be recovered.
+- **If adding new dependencies** (requires human approval), note that the environment capture in `train_metadata.json` will automatically record the new package version.
+
+## Safety
+
+- Do not modify files outside the ML project directory.
+- Do not delete experiment logs or model archives.
+- If something breaks unexpectedly, stop and report — do not auto-fix evaluation infrastructure.

package/skills/turing/sanity/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: sanity
+description: Pre-training sanity checks — catch broken data loaders, misconfigured losses, and dead gradients in 30 seconds before wasting hours.
+argument-hint: "[--quick] [--verbose]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Run a battery of fast checks before committing to a full training run. Catches wiring bugs in seconds.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - `--quick` — skip single-batch overfit test (fastest, ~5 seconds)
+   - `--verbose` — show detailed check output
+   - `--json` — raw JSON output
+
+3. **Run sanity checks:**
+   ```bash
+   python scripts/sanity_checks.py $ARGUMENTS
+   ```
+
+4. **Checks performed:**
+   - **Data pipeline** (critical): first batch loads, shapes match, no NaN/Inf
+   - **Initial loss** (high): loss at initialization matches theory (e.g., -log(1/C) for cross-entropy)
+   - **Gradient flow** (high): all parameters have non-zero, non-exploding gradients
+   - **Single-batch overfit** (critical): model can memorize 1 batch in 50 steps — if not, something is broken
+   - **Output validation** (high): predictions are non-NaN, non-constant, reasonable range
+   - **Config consistency** (medium): learning rate, batch size in reasonable ranges
+
+5. **Verdicts:**
+   - **PASS** — safe to proceed
+   - **PASS (with warnings)** — review before training
+   - **FAIL** — do not proceed, fix issues first
+
+6. **Saved output:** report in `experiments/sanity/sanity-*.yaml`
+
+## Examples
+
+```
+/turing:sanity                    # Full check (~30 seconds)
+/turing:sanity --quick            # Skip overfit test (~5 seconds)
+```

package/skills/turing/scale/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: scale
+description: Scaling law estimator — run small experiments at different sizes, fit a power law, and predict full-scale performance before committing compute.
+argument-hint: "[--axis data|compute|params] [--points 4] [--analyze results.yaml]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Predict full-scale performance from a handful of small experiments. Answers "is it worth training on the full dataset?" in 30 minutes instead of 3 days.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - `--axis data|compute|params` — scaling axis (default: data)
+   - `--points 4` — number of scale points (default: 4)
+   - `--analyze results.yaml` — analyze existing results instead of planning
+   - `--plot` — include ASCII scaling plot
+   - `--json` — raw JSON output
+
+3. **Plan or analyze:**
+   - **Plan mode (default):** generates scale point configs to run
+     ```bash
+     python scripts/scaling_estimator.py --axis data --points 4
+     ```
+   - **Analyze mode:** fits power law to completed results
+     ```bash
+     python scripts/scaling_estimator.py --analyze experiments/scaling/results.yaml
+     ```
+
+4. **Scaling axes:**
+   - **data:** train on 10%, 25%, 50%, 75% of dataset
+   - **compute:** train for 10%, 25%, 50%, 75% of max epochs
+   - **params:** scale model size (fewer estimators, shallower depth)
+
+5. **After planning:** run each scale point experiment, record results in YAML, then use `--analyze` to fit the curve
+
+6. **Report includes:**
+   - Power law fit: `metric = a × n^b` with R²
+   - Predictions for 100%, 150%, 200% scale
+   - Verdict: DIMINISHING RETURNS / MARGINAL GAINS / WORTH SCALING
+
+7. **Saved output:** report written to `experiments/scaling/scale-YYYY-MM-DD.yaml`
+
+## Examples
+
+```
+/turing:scale                                  # Plan: data axis, 4 points
+/turing:scale --axis compute --points 3        # Plan: compute axis, 3 points
+/turing:scale --analyze results.yaml --plot    # Analyze with ASCII plot
+```

package/skills/turing/search/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: search
+description: Natural language experiment search — query with text + structured filters over 200+ experiments.
+argument-hint: "<query> [--filter \"accuracy>0.85\"] [--limit 10]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Find specific experiments in a large history with natural language and structured filters.
+
+## Steps
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/experiment_search.py $ARGUMENTS`
+3. **Filters:** `accuracy>0.85`, `status:kept`, `family:baseline`, `date:last-week`
+4. **Report:** ranked table of matching experiments
+
+## Examples
+```
+/turing:search "LightGBM high accuracy" --filter "accuracy>0.85"
+/turing:search "failed neural net" --filter "status:discarded"
+/turing:search "last week" --limit 5
+```

package/skills/turing/seed/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: seed
+description: Run multi-seed study on an experiment to compute mean/std/CI and flag seed-sensitive results. Prevents publishing lucky seeds.
+argument-hint: "[N] [--quick] [--exp-id <id>]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Run a multi-seed study to verify that experiment results are robust across random seeds.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - A bare number (e.g., `5`) sets the seed count
+   - `--quick` runs 3 seeds instead of 5
+   - `--exp-id exp-042` targets a specific experiment (defaults to best)
+   - `--seed-list 42,123,456` uses specific seed values
+
+3. **Run seed study:**
+   ```bash
+   python scripts/seed_runner.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - Show the per-seed results table
+   - Show mean +/- std with 95% CI
+   - **STABLE (CV < 5%):** result is robust, safe to report
+   - **SEED-SENSITIVE (CV >= 5%):** result varies too much across seeds — do not report single-seed numbers
+   - If seed-sensitive, recommend reporting as mean +/- std over N seeds
+
+5. **Saved output:** results are written to `experiments/seed_studies/exp-NNN-seeds.yaml`
+
+6. **If no training pipeline exists:** suggest `/turing:init` first.
+
+## Examples
+
+```
+/turing:seed              # 5 seeds on best experiment
+/turing:seed --quick      # 3 seeds for fast check
+/turing:seed 10           # 10 seeds for thorough study
+/turing:seed --exp-id exp-042   # Specific experiment
+```

package/skills/turing/sensitivity/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: sensitivity
+description: Hyperparameter sensitivity analysis — rank parameters by impact, identify which matter and which are noise.
+argument-hint: "[exp-id] [--params learning_rate,max_depth]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Which hyperparameters actually matter? Stop wasting time on the ones that don't.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - Optional experiment ID
+   - `--params "learning_rate,max_depth"` — specific parameters to analyze
+   - `--json` — raw JSON output
+
+3. **Run sensitivity analysis:**
+   ```bash
+   python scripts/sensitivity_analysis.py $ARGUMENTS
+   ```
+
+4. **Report includes:**
+   - Per-parameter sensitivity ranking: HIGH / MED / LOW / NONE
+   - Metric range for each parameter sweep
+   - Monotonicity detection (is there a sweet spot?)
+   - Recommendations: focus tuning on X, stop tuning Y
+
+5. **Saved output:** report in `experiments/sensitivity/<exp-id>-sensitivity.yaml`
+
+## Examples
+
+```
+/turing:sensitivity exp-042                           # All tunable params
+/turing:sensitivity --params "learning_rate,max_depth" # Specific params
+```

package/skills/turing/share/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: share
+description: Experiment packaging — portable archive with config, metrics, seed study, annotations, reproduction instructions.
+argument-hint: "<exp-ids...> [--include model,figures,code]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Package experiments for collaborator handoff or paper supplementary material.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/package_experiments.py $ARGUMENTS`
+3. **Saved:** `exports/packages/<name>/`
+
+## Examples
+```
+/turing:share exp-089
+/turing:share exp-042 exp-089 --include model,figures
+```

package/skills/turing/simulate/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: simulate
+description: Experiment outcome prediction — predict which configs will beat the current best before running them.
+argument-hint: "[--configs configs.yaml] [--top-k 5] [--threshold 0.001]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Predict outcomes before spending compute. Ranks proposed configs and recommends which to run vs skip.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/experiment_simulator.py $ARGUMENTS`
+3. **Saved:** `experiments/simulations/`
+
+## How it works
+- Builds a surrogate model from experiment history (weighted k-NN)
+- Predicts metric for each proposed config
+- Applies novelty penalty for configs far from training distribution
+- Ranks and filters: only recommend configs predicted to improve
+
+## Examples
+```
+/turing:simulate --configs sweep_configs.yaml
+/turing:simulate --configs candidates.yaml --top-k 3
+/turing:simulate --configs proposals.yaml --threshold 0.005
+/turing:simulate --configs sweep.yaml --json
+```

package/skills/turing/status/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: status
+description: Show current ML experiment status — best model, recent experiments, convergence state, and trend analysis. Delegates to @ml-evaluator for read-only safety.
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Show the current state of the ML training pipeline. This is an observation-only operation — no code is modified.
+
+## Steps
+
+1. **Run metrics display:**
+   ```bash
+   source .venv/bin/activate && python scripts/show_metrics.py --last 10
+   ```
+
+2. **Summarize for the user:**
+   - **Best model:** type, key metrics, experiment ID
+   - **Total experiments:** count from the log
+   - **Convergence state:** consecutive non-improvements vs patience threshold
+   - **Trend:** improving, plateauing, or regressing?
+   - **Recommendation:** continue training, try a different approach, or declare convergence
+
+3. **If no experiments exist:** report that the pipeline is ready but untrained. Suggest `/turing:train`.

package/skills/turing/stitch/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: stitch
+description: Pipeline composition — decompose ML pipelines into swappable stages. Show, swap, cache, and run stages independently.
+argument-hint: "<show|swap|cache|run> [stage] [--from exp-id]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Decompose your ML pipeline into stages that can be independently varied, cached, and reused across experiments.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First argument is the action: `show`, `swap`, `cache`, `run`
+   - `show` — display pipeline stages with hash and cache status
+   - `swap <stage> --from <exp-id>` — replace a stage with one from another experiment
+   - `cache` — save intermediate stage outputs to disk
+   - `run` — execute pipeline, skipping cached stages
+
+3. **Run pipeline manager:**
+   ```bash
+   python scripts/pipeline_manager.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - **show:** numbered stage list with description, content hash, and cache status
+   - **swap:** what changed, old vs new stage config, updated pipeline
+   - **cache:** per-stage cache paths and status
+   - **run:** which stages will be skipped (cached) vs re-run
+
+5. **Stage types:** preprocess, features, model, postprocess (configurable in `config.yaml` under `pipeline.stages`)
+
+6. **Cache benefit:** when only the model stage changes, preprocessing and feature engineering are skipped — experiments run faster
+
+7. **If no pipeline config:** falls back to default 4-stage pipeline
+
+## Examples
+
+```
+/turing:stitch show                          # Display pipeline stages
+/turing:stitch swap model --from exp-031     # Keep features, swap model
+/turing:stitch cache                         # Cache intermediate outputs
+/turing:stitch run                           # Run with cached stages
+```

package/skills/turing/suggest/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: suggest
+description: Literature-grounded model selection. Reads the ML task context, searches recent literature, and suggests model architectures worth trying — with citations. Suggestions are auto-queued as hypotheses.
+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. Supports two strategies:
+
+- **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
+
+Read the project config and recent experiment history to understand the task:
+
+```bash
+cat config.yaml
+```
+
+```bash
+source .venv/bin/activate && python scripts/show_metrics.py --last 10 2>/dev/null || echo "No experiments yet"
+```
+
+If `$ARGUMENTS` is provided, use that as the task description. Otherwise, infer from `config.yaml` (model type, primary metric, data source, target column).
+
+From the config and any task description, identify the key task properties:
+- Data type (tabular, time series, image, text, etc.)
+- Objective (classification, regression, generation, etc.)
+- Special constraints (imbalanced classes, small dataset, real-time, interpretability, etc.)
+- Current model family and what's been tried
+
+### 2. Search Literature
+
+Use `WebSearch` to find recent papers and benchmark results. Run 3-5 searches targeting:
+
+1. **Model comparison for this task type:** e.g., "best models for tabular classification benchmark 2024"
+2. **Current model alternatives:** e.g., "LightGBM vs XGBoost vs CatBoost tabular data"
+3. **Task-specific techniques:** e.g., "handling class imbalance gradient boosting"
+
+For each search, use `WebFetch` on the top 1-2 results to extract specific model recommendations, benchmark numbers, and methodology.
+
+Focus on:
+- Recent work (2023-2026) with empirical comparisons
+- Benchmark studies and surveys
+- arXiv papers or reputable ML blogs with concrete results
+
+### 3. Synthesize Suggestions
+
+From the literature, synthesize **3-5 concrete model architecture suggestions**. Each must include:
+
+- **Model architecture:** specific (e.g., "LightGBM with GOSS sampling", not "try a different model")
+- **Why:** one-sentence rationale grounded in what the literature says
+- **Citation:** paper or source that supports this
+- **Expected impact:** high/medium/low based on how well it fits this task
+- **Implementation hint:** what to change in `train.py` (one concrete line)
+
+### 4. Queue as Hypotheses
+
+For each suggestion, add to the hypothesis queue:
+
+```bash
+source .venv/bin/activate && python scripts/manage_hypotheses.py add "<model>: <rationale> (source: <citation>)" --priority medium --source literature
+```
+
+### 5. Show Results
+
+```
+Literature-Grounded Model Suggestions
+======================================
+
+Task: <task description>
+Current: <current model> (<current metric>=<value>)
+Sources consulted: <N papers/articles>
+
+1. [HIGH] <technique>
+   Why: <one-sentence rationale with citation>
+   Source: <URL>
+   Change: <specific train.py change>
+   → Queued as hyp-NNN
+
+2. [MEDIUM] ...
+
+Queued N hypotheses. Run /turing:train to test them.
+```
+
+## 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 and treequest-sourced hypotheses
+- `/turing:explore` runs the TreeQuest search as a standalone command
+- Human can override priority: `/turing:try` always takes precedence

package/skills/turing/surgery/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: surgery
+description: Architecture modification — add/remove layers, widen/narrow, swap activations, inject skip connections. Specify what to change, system handles how.
+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/skills/turing/sweep/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: sweep
+description: Generate and run a systematic hyperparameter sweep. Computes the cartesian product of configured parameter ranges and processes the queue sequentially with full experiment logging.
+argument-hint: "[sweep_config.yaml]"
+allowed-tools: Read, Write, Edit, Bash(python train.py:*, python scripts/*:*, git:*, source .venv/bin/activate:*, pip:*), Grep, Glob
+---
+
+Run a systematic hyperparameter sweep using the sweep configuration.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Resolve config:** Use `$ARGUMENTS` as sweep config path, or default to `sweep_config.yaml`.
+
+3. **Generate queue** (if not already generated):
+   ```bash
+   python scripts/sweep.py [sweep_config.yaml]
+   ```
+
+4. **Check queue status:**
+   ```bash
+   python scripts/sweep.py --status
+   ```
+
+5. **Process queue sequentially:**
+   - Get next: `python scripts/sweep.py --next`
+   - Apply config overrides to `config.yaml`
+   - Create experiment branch: `git checkout -b exp/NNN-description`
+   - Run training: `python train.py > run.log 2>&1`
+   - Parse metrics: `grep -A 10 "^---" run.log | head -10`
+   - Log the experiment
+   - Mark complete: `python scripts/sweep.py --mark <name> complete`
+   - If improved, merge to main. If not, return to main.
+   - Repeat until queue is empty
+
+6. **Report** final results with best configuration found.
+
+## Rules
+
+Follow the same safety constraints as `/turing:train` — see `rules/loop-protocol.md`.

package/skills/turing/template/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: template
+description: Experiment template library — save winning configs as reusable templates, apply to new projects.
+argument-hint: "<save|list|apply|share> [--name name] [--from exp-id]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Turn your best experiment configs into reusable recipes that persist across projects.
+
+## Steps
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/experiment_templates.py $ARGUMENTS`
+3. **Operations:** save (from experiment), list (all templates), apply (to current project), share (export)
+4. **Stored at:** `~/.turing/templates/` (cross-project)
+
+## Examples
+```
+/turing:template save --from exp-042 --name "tabular-xgboost-v2"
+/turing:template list
+/turing:template apply tabular-xgboost-v2
+```