claude-turing 4.6.0 → 4.8.0

package/skills/turing/poster/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: poster
+description: Generate a single-page HTML research poster summarizing the experiment campaign — best result, trajectory, key findings, and methodology. Adapted from posterskill's self-contained HTML architecture.
+argument-hint: "[title override]"
+allowed-tools: Read, Write, Edit, Bash(python scripts/*:*, source .venv/bin/activate:*, mkdir:*, open:*), Grep, Glob
+---
+
+Generate a research poster summarizing the experiment campaign as a single self-contained HTML file. Adapted from [posterskill](https://github.com/ethanweber/posterskill)'s architecture — no build step, works when opened as `file://`.
+
+## Steps
+
+### 1. Gather Data
+
+Read the experiment history and project context:
+
+```bash
+cat config.yaml
+source .venv/bin/activate && python scripts/generate_brief.py
+source .venv/bin/activate && python scripts/show_metrics.py --last 20
+cat experiment_state.yaml 2>/dev/null || true
+cat RESEARCH_PLAN.md 2>/dev/null || true
+```
+
+From this, extract:
+- **Title:** from config task description (or `$ARGUMENTS` override)
+- **Best result:** metric name, value, experiment ID
+- **Improvement trajectory:** metric values over experiments
+- **Key findings:** what model families worked, what didn't, what was surprising
+- **Methodology:** the experiment loop, evaluation strategy, convergence criteria
+- **Campaign stats:** total experiments, keep rate, time span
+
+### 2. Generate the Poster HTML
+
+Create `poster/index.html` — a self-contained HTML file with:
+
+```bash
+mkdir -p poster
+```
+
+**Structure the poster with these cards:**
+
+| Card | Content |
+|------|---------|
+| **Header** | Title, "Autonomous ML Research Campaign", date range, best metric badge |
+| **Objective** | Task description and success criteria from config |
+| **Methodology** | The autoresearch loop: hypothesize → train → evaluate → decide. Mention immutable evaluation, git-disciplined rollback |
+| **Trajectory** | Chart.js line chart of metric progression (embed data inline) |
+| **Best Configuration** | Model type, hyperparameters, metric values from best experiment |
+| **Key Findings** | 3-5 bullet points: what worked, what didn't, surprises |
+| **Explored Approaches** | Table of model families tried with keep rates |
+| **Campaign Stats** | Total experiments, keep rate, human vs agent hypotheses, convergence |
+
+**Design principles (from posterskill):**
+- Single self-contained HTML file, CDN dependencies only (Chart.js, Google Fonts)
+- Print-optimized CSS (`@media print`, `@page` with poster dimensions)
+- Card-based layout with colored top borders
+- Clean typography (system fonts or Nunito from Google Fonts)
+- Data embedded directly in the HTML as JSON — no external file dependencies
+
+**Poster dimensions:** Default A1 landscape (841mm x 594mm). The user can print to PDF from their browser.
+
+### 3. Self-Critique
+
+Review the generated poster:
+- Does the trajectory chart render correctly with the embedded data?
+- Are the key findings specific and data-grounded (not generic)?
+- Is the best configuration complete (model type + all relevant hyperparameters)?
+- Would a collaborator understand the campaign from this single page?
+
+Fix any issues found.
+
+### 4. Present
+
+```
+Research poster generated at poster/index.html
+
+Open in your browser to view. Print to PDF for sharing.
+Best result: <metric>=<value> (<experiment_id>)
+Campaign: <N> experiments, <keep_rate>% keep rate
+```
+
+Suggest: "Open `poster/index.html` in your browser. Use Ctrl+P / Cmd+P to save as PDF."
+
+## Integration
+
+- The poster reads from the same data sources as `/turing:brief` and `/turing:logbook`
+- For a more detailed view, use `/turing:logbook` (full experiment-by-experiment narrative)
+- For a quick summary, use `/turing:brief` (text-only intelligence report)

package/skills/turing/postmortem/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: postmortem
+description: Failure postmortem — diagnose why experiments stopped improving and get actionable next steps.
+argument-hint: "[--window 10] [--auto-trigger 5]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+When experiments stop improving, find out why. Diagnoses search space exhaustion, config errors, data issues, metric ceilings, and noise floors.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/failure_postmortem.py $ARGUMENTS`
+3. **Saved:** `experiments/postmortems/`
+
+## Diagnosis categories
+- **Search space exhaustion:** micro-tuning params that don't matter
+- **Systematic config error:** all experiments share a bad common config
+- **Data issue:** all model types fail similarly
+- **Metric ceiling:** near theoretical maximum
+- **Noise floor:** improvements within seed variance
+
+## Examples
+```
+/turing:postmortem
+/turing:postmortem --window 15
+/turing:postmortem --json
+```

package/skills/turing/preflight/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: preflight
+description: Pre-flight resource check — estimates VRAM, RAM, and disk requirements before running ML training. Compares against available system resources and issues PASS/WARN/FAIL verdict. Use before training to catch OOM errors before they happen.
+argument-hint: "[--model-type torch] [--params 10M] [--batch-size 32]"
+allowed-tools: Read, Bash(python scripts/*:*, source .venv/bin/activate:*, nvidia-smi:*), Grep, Glob
+---
+
+Check whether the current system has enough resources to run the planned experiment.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Run preflight check:**
+
+   If `$ARGUMENTS` is empty (auto-detect from config.yaml):
+   ```bash
+   python scripts/preflight.py
+   ```
+
+   If `$ARGUMENTS` contains flags:
+   ```bash
+   python scripts/preflight.py $ARGUMENTS
+   ```
+
+3. **Interpret the verdict:**
+
+   - **PASS** — system has sufficient resources. Proceed with training.
+   - **WARN** — resources are tight. Training may succeed but could be slow or unstable. Present warnings to the user and ask whether to proceed.
+   - **FAIL** — training will likely fail (OOM, disk full, no GPU for GPU-required model). Present the specific resource gap and suggest mitigations:
+     - RAM too low: reduce dataset size, use chunked loading, or add swap
+     - VRAM too low: reduce batch size, use fp16/bf16, enable gradient checkpointing, or use a smaller model
+     - Disk too low: clean up old models/checkpoints
+     - No GPU: switch to a CPU-friendly model (XGBoost, LightGBM, sklearn)
+
+4. **If running before `/turing:train`:** report the verdict so the human can decide whether to proceed, adjust config, or choose a different model type.
+
+## Examples
+
+```bash
+# Auto-detect from config.yaml (works for Turing projects)
+/turing:preflight
+
+# Check for a specific model type
+/turing:preflight --model-type transformer --params 350M --batch-size 16 --precision fp16
+
+# Check with a specific dataset
+/turing:preflight --model-type xgboost --dataset data/train.csv
+
+# JSON output for scripting
+/turing:preflight --json
+```
+
+## What It Checks
+
+| Resource | How estimated | Warning threshold |
+|----------|--------------|-------------------|
+| **RAM** | Dataset size (4x CSV on disk) + model memory (tree nodes or param count) | >90% of available |
+| **VRAM** | Model params + gradients + optimizer state + activations | >80% of largest GPU |
+| **Disk** | Model artifacts + dataset + checkpoints | >50% of free space |
+| **GPU presence** | torch.cuda or nvidia-smi | Required for neural nets >1GB VRAM |
+
+## Model-Specific Estimates
+
+| Model Type | RAM | VRAM | GPU Required? |
+|-----------|-----|------|---------------|
+| XGBoost/LightGBM | Trees + data (typically <4GB) | 0 | No |
+| Random Forest | Trees + data (can be large) | 0 | No |
+| Linear/Logistic | 2x data | 0 | No |
+| MLP (small) | Data + params | Params x 4 (Adam) | If >1GB VRAM |
+| Transformer | Data + params | Params x 4 + activations | Yes |

package/skills/turing/present/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: present
+description: Presentation figure generation — training curves, comparison charts, ablation tables, Pareto plots, sensitivity heatmaps.
+argument-hint: "[--figures training,comparison] [--style light|dark|poster]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Generate presentation-ready figure specifications from experiment data in seconds.
+
+## Steps
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/generate_figures.py $ARGUMENTS`
+3. **Figure types:** training, comparison, ablation, pareto, sensitivity
+4. **Styles:** light (papers), dark (demos), poster (large fonts)
+5. **Saved output:** `paper/figures/`
+
+## Examples
+```
+/turing:present                                  # All figures
+/turing:present --figures training,comparison    # Specific figures
+/turing:present --style dark                     # Dark theme
+```

package/skills/turing/profile/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: profile
+description: Profile a training run — timing breakdown, memory usage, throughput, bottleneck detection with actionable recommendations.
+argument-hint: "[exp-id] [--seed 42]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Profile a training run to identify performance bottlenecks.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First argument can be an experiment ID (e.g., `exp-042`); defaults to best
+   - `--seed 42` sets the random seed for the profiling run
+
+3. **Run profiling:**
+   ```bash
+   python scripts/profile_training.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - **Timing:** total time, training time, overhead breakdown
+   - **Memory:** peak RSS, Python peak, GPU peak (if applicable)
+   - **Throughput:** samples/sec
+   - **Bottleneck:** identified bottleneck type and severity
+   - **Recommendations:** actionable fixes for the detected bottleneck
+
+5. **Saved output:** results written to `experiments/profiles/exp-NNN-profile.yaml`
+
+6. **If no training pipeline exists:** suggest `/turing:init` first.
+
+## Examples
+
+```
+/turing:profile              # Profile best experiment config
+/turing:profile exp-042      # Profile specific experiment
+```

package/skills/turing/prune/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: prune
+description: Weight pruning — measure accuracy at different sparsity levels, find the knee point, produce a smaller/faster model.
+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/skills/turing/quantize/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: quantize
+description: Post-training quantization — FP32→INT8/FP16, measure accuracy loss, 2-4x speedup with <0.5% accuracy loss.
+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/skills/turing/queue/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: queue
+description: Queue experiments for batch execution with priority ordering and dependency chains. Load the queue, walk away, read the summary.
+argument-hint: "<add|list|run|pause|clear> [description] [--priority high] [--after q-001]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Manage the experiment queue for unattended batch execution.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - **add** `"description"` `--priority high` `--after q-001` — queue an experiment
+   - **list** — show queue with status, priority, dependencies
+   - **run** `--halt-on-error` — execute all queued experiments
+   - **pause** — stop after current experiment finishes
+   - **clear** — discard all queued items
+
+3. **Run queue manager:**
+   ```bash
+   python scripts/experiment_queue.py $ARGUMENTS
+   ```
+
+4. **Report results by action:**
+   - **add:** confirms ID and priority
+   - **list:** table of queued/completed/failed items
+   - **run:** batch summary with per-experiment status
+   - **pause/clear:** confirmation message
+
+5. **Queue persists in** `experiments/queue.yaml`
+
+## Examples
+
+```
+/turing:queue add "try LightGBM" --priority high
+/turing:queue add "deeper trees" --after q-001
+/turing:queue list
+/turing:queue run
+/turing:queue run --halt-on-error
+/turing:queue pause
+/turing:queue clear
+```

package/skills/turing/registry/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: registry
+description: Model registry — track, promote, and govern the model lifecycle from candidate to production.
+argument-hint: "[list|register|promote|demote|archive|history] [exp-id] [stage]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Track which model is production, staging, candidate, or archived. Promotion requires passing gates.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/model_lifecycle.py $ARGUMENTS`
+3. **Registry:** `experiments/registry.yaml`
+
+## Promotion gates
+- **candidate → staging:** regression check + seed study must PASS
+- **staging → production:** audit + calibration check must PASS
+- Use `--force` to skip gate checks
+
+## Examples
+```
+/turing:registry list
+/turing:registry register exp-095 --version v4.1
+/turing:registry promote exp-089 staging
+/turing:registry promote exp-089 production --force
+/turing:registry demote exp-078 staging --reason "latency regression"
+/turing:registry archive exp-042 --reason "superseded by v4"
+/turing:registry history
+/turing:registry history exp-089
+```

package/skills/turing/regress/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: regress
+description: Performance regression gate — re-run best experiment after code/dependency changes and verify metrics haven't degraded.
+argument-hint: "[--tolerance 0.01] [--against exp-id] [--quick]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+CI for your model. After any change to code, dependencies, or data, verify metrics haven't silently regressed.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - `--tolerance 0.01` sets the relative tolerance (default 1%)
+   - `--against exp-042` checks against a specific experiment (default: best)
+   - `--quick` runs 1 seed instead of 3 for fast checks
+   - `--runs 5` sets number of regression runs (default 3)
+   - `--json` outputs raw JSON
+
+3. **Run regression gate:**
+   ```bash
+   python scripts/regression_gate.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - **PASS:** all metrics within tolerance — no regression
+   - **WARNING:** some metrics degraded within 2x tolerance — investigate
+   - **FAIL:** REGRESSION DETECTED — at least one metric degraded beyond tolerance
+   - Shows per-metric comparison with deltas and relative differences
+   - Shows environment diff if library versions changed (may explain regression)
+
+5. **Saved output:** report written to `experiments/regressions/check-YYYY-MM-DD.yaml`
+
+6. **If no experiments exist:** suggest running `/turing:train` first.
+
+7. **On FAIL verdict:** suggest investigating with:
+   - `/turing:diff <baseline> <latest>` to see what changed
+   - `pip freeze` comparison to identify library version changes
+   - `git diff` to review code changes
+
+## Examples
+
+```
+/turing:regress                              # Default: check best, 1% tolerance, 3 runs
+/turing:regress --quick                      # Fast check: 1 run
+/turing:regress --against exp-042            # Check specific experiment
+/turing:regress --tolerance 0.005 --runs 5   # Strict: 0.5% tolerance, 5 runs
+```

package/skills/turing/replay/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: replay
+description: Experiment replay — re-run a historical experiment with current infrastructure to test if old approaches do better now.
+argument-hint: "<exp-id> [--with-current-data] [--with-current-preprocessing]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Should you revisit old ideas? Infrastructure changes may make failed approaches work now.
+
+## Steps
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/experiment_replay.py $ARGUMENTS`
+3. **Modes:** default (current code+data), --with-current-data, --with-current-preprocessing
+4. **Report:** original vs replayed metrics, delta, verdict
+5. **Saved output:** `experiments/replays/`
+
+## Examples
+```
+/turing:replay exp-023                              # Replay with current infrastructure
+/turing:replay exp-023 --with-current-data          # Current data, old code
+/turing:replay --list                               # List replayable experiments
+```

package/skills/turing/report/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: report
+description: Generate a markdown research report from experiment history — structured for sharing, archiving, or including in documentation. More detailed than a brief, less visual than a poster.
+argument-hint: "[--since YYYY-MM-DD] [--output path]"
+allowed-tools: Read, Bash(python scripts/*:*, source .venv/bin/activate:*, mkdir:*), Grep, Glob
+---
+
+Generate a structured markdown research report summarizing the experiment campaign.
+
+## Steps
+
+### 1. Generate the Report
+
+Use the logbook generator in markdown mode as the data backbone:
+
+```bash
+source .venv/bin/activate && python scripts/generate_logbook.py --format markdown
+```
+
+Also gather supplementary data:
+```bash
+source .venv/bin/activate && python scripts/generate_brief.py
+cat experiment_state.yaml 2>/dev/null || true
+cat RESEARCH_PLAN.md 2>/dev/null || true
+```
+
+### 2. Enhance with Analysis
+
+The logbook generator produces raw data. Enhance it with your analysis to create a proper report. Add these sections that the script doesn't generate:
+
+- **Executive Summary** (2-3 sentences): What was the task? What's the best result? Is it good enough?
+- **Approach:** Describe the methodology — autoresearch loop, evaluation strategy, search strategy used
+- **Key Findings:** Synthesize patterns from the experiment log:
+  - Which model families outperformed others?
+  - What hyperparameter ranges work vs don't?
+  - Were there surprising results?
+  - What failure patterns emerged?
+- **Recommendations:** Based on the findings, what should be tried next? What should be avoided?
+- **Limitations:** What wasn't explored? What constraints affected the results?
+
+### 3. Output
+
+If `$ARGUMENTS` contains `--output <path>`:
+```bash
+mkdir -p $(dirname <path>)
+```
+Write the report to the specified path.
+
+Otherwise, display the report directly.
+
+**Common usage:**
+```
+/turing:report --output reports/campaign-v1.md
+/turing:report --since 2026-03-15 --output reports/week-12.md
+```
+
+## Report Structure
+
+```markdown
+# Research Report: <task description>
+Generated: <date>
+
+## Executive Summary
+<2-3 sentences>
+
+## Methodology
+<approach, evaluation strategy, convergence criteria>
+
+## Campaign Summary
+<table: experiments, keep rate, best metric, timespan>
+
+## Improvement Trajectory
+<table: experiment-by-experiment metric progression>
+
+## Key Findings
+<synthesized patterns from experiment history>
+
+## Model Comparison
+<table: model families, experiments per family, best metric, keep rate>
+
+## Hypothesis Analysis
+<what was proposed, by whom, what worked>
+
+## Recommendations
+<concrete next steps>
+
+## Limitations
+<what wasn't tried, constraints>
+```
+
+## When to Use
+
+- End of a research campaign for archiving
+- Before a team review or status update
+- To document findings for a paper or thesis
+- To hand off a project to another researcher

package/skills/turing/reproduce/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: reproduce
+description: Verify reproducibility of a specific experiment by re-running from logged config and checking metrics fall within tolerance.
+argument-hint: "<exp-id> [--tolerance 0.02] [--strict] [--runs 3]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Verify that a logged experiment can be reproduced with consistent results.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First argument is the experiment ID (required), e.g. `exp-042`
+   - `--tolerance 0.02` sets the relative tolerance (default 2%)
+   - `--strict` requires exact float match (1e-6), overrides tolerance
+   - `--runs 3` sets number of reproduction runs (default 3, 1 for strict)
+
+3. **Run reproducibility verification:**
+   ```bash
+   python scripts/reproduce_experiment.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - **reproducible:** metrics match exactly (deterministic algorithm)
+   - **approximately_reproducible:** metrics within tolerance or original falls in 95% CI
+   - **not_reproducible:** metrics outside tolerance and CI
+   - **environment_changed:** metrics diverge AND library versions differ
+   - Show environment diff if present (Python version, package versions)
+
+5. **Saved output:** report written to `experiments/reproductions/exp-NNN-repro.yaml`
+
+6. **If experiment ID not found:** list available experiment IDs from `experiments/log.jsonl`
+
+7. **If no training pipeline exists:** suggest `/turing:init` first.
+
+## Examples
+
+```
+/turing:reproduce exp-042                 # Default: 3 runs, 2% tolerance
+/turing:reproduce exp-042 --strict        # Exact match required
+/turing:reproduce exp-042 --tolerance 0.05 --runs 5   # Lenient, more runs
+```

package/skills/turing/retry/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: retry
+description: Smart failure recovery — auto-diagnose crash type and retry with targeted fix. OOM → halve batch. NaN → add clipping.
+argument-hint: "<exp-id> [--max-attempts 3]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Auto-diagnose and recover from experiment failures.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First argument is the experiment ID (required)
+   - `--max-attempts 3` limits retry count
+   - `--classify "error text"` just classifies without retrying
+
+3. **Run smart retry:**
+   ```bash
+   python scripts/smart_retry.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - **RECOVERED:** fix applied, retry succeeded
+   - **FAILED:** all retry attempts exhausted
+   - **MANUAL FIX NEEDED:** failure type requires human intervention
+   - Shows failure classification, fix applied, and attempt history
+
+5. **Saved output:** report written to `experiments/retries/exp-NNN-retry.yaml`
+
+## Examples
+
+```
+/turing:retry exp-042                    # Auto-diagnose and retry
+/turing:retry exp-042 --max-attempts 5   # More retries
+```

package/skills/turing/review/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: review
+description: Peer review simulation — generate likely reviewer objections with severity ratings and fix commands.
+argument-hint: "[--venue neurips|icml|general] [--harsh]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Simulate a conference reviewer before you submit. Each weakness links to the command that fixes it.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/simulate_review.py $ARGUMENTS`
+3. **Saved:** `experiments/reviews/`
+
+## Examples
+```
+/turing:review
+/turing:review --venue neurips --harsh
+```