claude-turing 4.6.0 → 4.8.0

package/skills/turing/checkpoint/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: checkpoint
+description: Smart checkpoint management — list, prune (Pareto-based), average top-K, resume from any point, disk usage stats.
+argument-hint: "<list|prune|average|resume|stats> [exp-id] [--top 3] [--dry-run]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Manage model checkpoints intelligently using Pareto dominance.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First word is the action: `list`, `prune`, `average`, `resume`, `stats`
+   - `resume` requires an experiment ID as second argument
+   - `--top 3` sets the number of checkpoints for averaging
+   - `--dry-run` previews pruning without deleting
+
+3. **Run checkpoint manager:**
+   ```bash
+   python scripts/checkpoint_manager.py $ARGUMENTS
+   ```
+
+4. **Report results by action:**
+   - **list:** Table of all checkpoints with metrics, size, and Pareto status
+   - **prune:** Removes dominated checkpoints, reports space saved
+   - **average:** Lists top-K checkpoints for weight averaging
+   - **resume:** Locates checkpoint for a specific experiment
+   - **stats:** Disk usage summary by total, average, and model type
+
+5. **Saved output:** report written to `experiments/checkpoints/checkpoint-report.yaml`
+
+## Examples
+
+```
+/turing:checkpoint list              # Show all checkpoints
+/turing:checkpoint stats             # Disk usage summary
+/turing:checkpoint prune --dry-run   # Preview what would be pruned
+/turing:checkpoint prune             # Remove dominated checkpoints
+/turing:checkpoint average --top 5   # Top 5 for averaging
+/turing:checkpoint resume exp-042    # Resume from checkpoint
+```

package/skills/turing/cite/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: cite
+description: Citation & attribution manager — track papers, datasets, methods. Audit for missing citations, generate BibTeX.
+argument-hint: "<add|list|check|bib> [--key Chen2016 --title XGBoost --url ...]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Track which papers and methods influenced each experiment. Catch missing citations before submission.
+
+## Steps
+1. **Activate environment:** `source .venv/bin/activate`
+2. **Run:** `python scripts/citation_manager.py $ARGUMENTS`
+3. **Operations:** add (associate citation with experiment), list (group by type), check (audit missing), bib (BibTeX)
+4. **Stored in:** `experiments/citations.yaml`
+
+## Examples
+```
+/turing:cite add exp-042 --key Chen2016 --title "XGBoost" --type method --url "https://arxiv.org/abs/1603.02754"
+/turing:cite list
+/turing:cite check                    # Audit for missing citations
+/turing:cite bib                      # Generate BibTeX
+```

package/skills/turing/compare/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: compare
+description: Compare two ML experiment runs side-by-side — metrics, configuration deltas, and a verdict on which approach is more promising.
+argument-hint: "<exp-id-1> <exp-id-2>"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Compare two ML experiment runs side-by-side to understand what changed and why one performed better.
+
+## Steps
+
+1. **Run comparison:**
+   ```bash
+   source .venv/bin/activate && python scripts/compare_runs.py $0 $1
+   ```
+
+2. **Analyze the delta:**
+   - **Metric differences:** all configured metrics for both runs
+   - **Configuration delta:** what changed (model type, hyperparameters, features)
+   - **Causal analysis:** which changes likely caused the metric difference
+   - **Verdict:** which approach is more promising for future experiments
+
+3. **If either ID is missing:** report the error and suggest `/turing:status` to see available experiment IDs.

package/skills/turing/counterfactual/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: counterfactual
+description: Input-level counterfactual explanations — find the smallest input change to flip a prediction.
+argument-hint: "<exp-id> --sample <index> [--target <class>]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+What would need to change to flip this prediction? Minimum-change counterfactual for individual predictions.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/counterfactual_explanation.py $ARGUMENTS`
+3. **Saved:** `experiments/counterfactuals/`
+
+## Methods
+- **Greedy perturbation:** change one feature at a time, find minimum flip
+- **Prototype-based:** find nearest training sample from target class
+- Both methods run and the best (smallest distance) is selected
+
+## Examples
+```
+/turing:counterfactual exp-042 --sample 1247
+/turing:counterfactual exp-042 --sample 1247 --target 0
+/turing:counterfactual exp-042 --batch-misclassified
+/turing:counterfactual exp-042 --sample 500 --json
+```

package/skills/turing/curriculum/SKILL.md

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

package/skills/turing/design/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: design
+description: Generate a structured experiment design for a hypothesis. Reads experiment history, searches literature for methodology, produces a scored design document at experiments/designs/.
+argument-hint: "<hypothesis-id or description>"
+allowed-tools: Read, Write, Bash(python scripts/*:*, source .venv/bin/activate:*, mkdir:*), Grep, Glob, WebSearch, WebFetch
+---
+
+Front-load the thinking before the coding. Given a hypothesis, produce a structured experiment design grounded in methodology from the literature.
+
+## Steps
+
+### 1. Load Context
+
+If `$ARGUMENTS` matches `hyp-NNN`, load the hypothesis:
+```bash
+source .venv/bin/activate && python scripts/manage_hypotheses.py show $ARGUMENTS
+```
+
+If freeform text, use it directly as the hypothesis description.
+
+Read the current config and experiment state:
+```bash
+cat config.yaml
+```
+```bash
+source .venv/bin/activate && python scripts/show_metrics.py --last 10 2>/dev/null || echo "No experiments yet"
+```
+```bash
+cat experiment_state.yaml 2>/dev/null || echo "No experiment state yet"
+```
+
+### 2. Search for Methodology
+
+Use `WebSearch` to find 2-3 papers or articles describing how to implement the proposed change effectively. Target:
+- The specific technique in the hypothesis (e.g., "LightGBM dart boosting implementation best practices")
+- Common pitfalls for this type of change
+- Benchmark results showing expected improvement range
+
+Use `WebFetch` on the most relevant results to extract specific methodology details: hyperparameter recommendations, training procedures, evaluation approaches.
+
+### 3. Write the Design Document
+
+Create `experiments/designs/<hyp-id>-design.md` (or `experiments/designs/adhoc-<date>-design.md` for freeform hypotheses):
+
+```bash
+mkdir -p experiments/designs
+```
+
+Write with this structure:
+
+```markdown
+# Experiment Design: <hypothesis summary>
+
+## Hypothesis
+<full description>
+
+## Objective
+<what we're testing, stated as a falsifiable claim>
+
+## Method
+<specific changes, grounded in literature findings>
+
+## Literature Support
+- <source 1>: <what it says about this approach>
+- <source 2>: <relevant finding>
+
+## Implementation Plan
+### Changes to train.py
+<concrete code changes needed>
+
+### Changes to config.yaml (if any)
+<hyperparameter values to set, with rationale from literature>
+
+## Expected Outcome
+- **Success:** <metric > threshold, specific number>
+- **Failure:** <what would disprove the hypothesis>
+
+## Risks
+<specific pitfalls from literature, not generic "might not work">
+
+## Estimated Runs
+<how many iterations>
+```
+
+### 4. Self-Critique
+
+Review the design:
+- Is the implementation plan specific enough for the researcher agent to execute without ambiguity?
+- Does the expected outcome have a concrete metric threshold?
+- Are risks actionable?
+
+Score each dimension 1-10 (feasibility, novelty, clarity). If any < 7, revise that section. Max 2 revision rounds.
+
+### 5. Report
+
+Display the design summary with scores and file location. The researcher agent can read the design during `/turing:train`.

package/skills/turing/diagnose/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: diagnose
+description: Error analysis — cluster failure cases, identify systematic failure modes, and suggest targeted fixes with auto-queued hypotheses.
+argument-hint: "[exp-id] [--auto-queue] [--top 5]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Analyze where and why the model fails, beyond aggregate metrics.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Generate predictions if needed:**
+   Check if `experiments/predictions/exp-NNN-preds.yaml` exists. If not, run:
+   ```bash
+   python train.py --predict-only --output experiments/predictions/
+   ```
+   The predictions file must contain `y_true`, `y_pred`, `task_type`, and optionally `features`.
+
+3. **Parse arguments from `$ARGUMENTS`:**
+   - First argument can be an experiment ID (e.g., `exp-042`); defaults to best
+   - `--auto-queue` auto-queues hypotheses from failure modes into `hypotheses.yaml`
+   - `--top 5` limits to top N failure modes (default 5)
+
+4. **Run error analysis:**
+   ```bash
+   python scripts/diagnose_errors.py $ARGUMENTS
+   ```
+
+5. **Report results:**
+   - **Classification:** confusion matrix, most-confused pairs, per-class P/R/F1, low-recall classes
+   - **Regression:** residual stats, P90/P95 errors, feature-range bias, systematic bias
+   - **Failure modes:** ranked by impact, with suggested fixes
+   - **Auto-hypotheses:** if `--auto-queue`, shows queued hypotheses targeting weaknesses
+
+6. **Saved output:** report written to `experiments/diagnoses/exp-NNN-diagnosis.yaml`
+
+7. **If no predictions file exists:** instruct user to run the model on validation set first.
+
+## Examples
+
+```
+/turing:diagnose                    # Analyze best experiment
+/turing:diagnose exp-042            # Specific experiment
+/turing:diagnose --auto-queue       # Queue fix hypotheses
+/turing:diagnose --top 10           # Top 10 failure modes
+```

package/skills/turing/diff/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: diff
+description: Deep experiment comparison — config diffs, metric significance, per-class regressions, training curve divergence, feature importance shifts.
+argument-hint: "<exp-a> <exp-b> [--code]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Deep diagnostic comparison of two experiments. Goes beyond "which metric is higher" to show where, when, and why two experiments diverge.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First two arguments are experiment IDs (required), e.g. `exp-042 exp-053`
+   - `--code` includes git diff of train.py between the two experiments' commits
+   - `--json` outputs raw JSON instead of markdown
+
+3. **Run deep comparison:**
+   ```bash
+   python scripts/experiment_diff.py $ARGUMENTS
+   ```
+
+4. **Report results — the diff includes:**
+   - **Config diff:** which hyperparameters changed, with magnitude (e.g., `max_depth: 6 → 8 (+33%)`)
+   - **Metric diff:** all metrics with deltas and statistical significance (if seed studies exist)
+   - **Per-class diff:** which classes improved/regressed — flags regressions hidden by aggregate improvement
+   - **Training curve divergence:** the epoch where the two experiments' loss/metric curves separate
+   - **Feature importance shifts:** which features gained/lost importance
+   - **Code diff (--code):** git diff of train.py between the two commits
+
+5. **Saved output:** report written to `experiments/diffs/<exp-a>-vs-<exp-b>.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:diff exp-042 exp-053                # Full diagnostic comparison
+/turing:diff exp-042 exp-053 --code         # Include train.py code changes
+/turing:diff exp-001 exp-010 --json         # Raw JSON output
+```

package/skills/turing/distill/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: distill
+description: Model compression via distillation — train a smaller student model to match a larger teacher's predictions.
+argument-hint: "<teacher-exp-id> [--compression 4] [--method soft-labels]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Compress a large model into a smaller, faster one for production. Measures the accuracy/size/latency tradeoff.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First argument is teacher experiment ID (required)
+   - `--compression 4` — compression ratio (default: 4x)
+   - `--method soft_labels|feature_matching|dataset_distillation` — distillation method
+   - `--target-latency 5` — auto-adjust compression to meet latency target (ms)
+   - `--json` — raw JSON output
+
+3. **Run distillation planner:**
+   ```bash
+   python scripts/model_distiller.py $ARGUMENTS
+   ```
+
+4. **Report includes:**
+   - Teacher model metrics
+   - Auto-selected student architecture (fewer trees/layers/width)
+   - Estimated size reduction and latency improvement
+   - Distillation configuration (temperature, alpha, loss function)
+   - Verdict: EXCELLENT / ACCEPTABLE / MARGINAL / TOO MUCH LOSS
+
+5. **Student selection by model type:**
+   - **Tree models:** fewer estimators, shallower depth
+   - **Neural networks:** fewer layers, narrower hidden dims
+   - **scikit-learn:** simpler model family (RandomForest → DecisionTree)
+
+6. **Distillation methods:**
+   - **soft_labels:** train on teacher's probability outputs with temperature scaling
+   - **feature_matching:** align intermediate representations (neural only)
+   - **dataset_distillation:** train on teacher-labeled synthetic data
+
+7. **Saved output:** report written to `experiments/distillations/distill-<exp-id>.yaml`
+
+## Examples
+
+```
+/turing:distill exp-042                              # 4x compression, soft labels
+/turing:distill exp-042 --compression 8              # Aggressive compression
+/turing:distill exp-042 --method feature_matching    # Neural feature alignment
+/turing:distill exp-042 --target-latency 5           # Meet 5ms latency target
+```

package/skills/turing/doctor/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: doctor
+description: Harness self-diagnosis — check environment, project, resources, and git state. Auto-fix common issues.
+argument-hint: "[--fix] [--verbose]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Is Turing healthy? Check everything and get a score.
+
+## Steps
+1. `source .venv/bin/activate`
+2. `python scripts/harness_doctor.py $ARGUMENTS`
+3. **Saved:** `experiments/doctor/`
+
+## Checks
+- **Environment:** Python version, venv status
+- **Dependencies:** all required packages importable
+- **Config:** config.yaml valid with required fields
+- **Experiment log:** JSONL integrity, corrupt line detection
+- **Scripts:** train.py, prepare.py, evaluate.py exist and parse
+- **Disk space:** warn if <1GB free
+- **Git state:** uncommitted changes to critical files
+- **Claude hooks:** `.claude/settings.local.json` hook group schema; `--fix` migrates legacy bare command hooks
+
+## Examples
+```
+/turing:doctor
+/turing:doctor --fix
+/turing:doctor --verbose --json
+```

package/skills/turing/ensemble/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: ensemble
+description: Automated ensemble construction — combines top-K models via voting, stacking, and blending for zero-cost improvement.
+argument-hint: "[--top-k 5] [--methods voting,stacking,blending]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Build ensembles from your best experiments automatically. Often yields 1-3% improvement with zero additional training.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - `--top-k 5` — number of top models to include (default: 5)
+   - `--methods voting,stacking,blending` — ensemble methods to try
+   - `--predictions-dir experiments/predictions` — directory with saved predictions
+   - `--json` — raw JSON output
+
+3. **Run ensemble construction:**
+   ```bash
+   python scripts/build_ensemble.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - Table of all ensemble methods tried with metric deltas vs best single model
+   - Best ensemble method highlighted with improvement amount
+   - Diversity analysis: prediction correlation matrix, diversity assessment
+   - Base model summary: which experiments were combined
+
+5. **Ensemble methods:**
+   - **Voting:** majority vote (classification) or mean (regression)
+   - **Weighted voting:** weights proportional to individual model performance
+   - **Stacking:** cross-validated meta-learner (ridge/logistic) on out-of-fold predictions
+   - **Blending:** holdout-based meta-learner (simpler, less data-efficient)
+
+6. **Prerequisites:** experiments must have saved predictions in `experiments/predictions/`. Each experiment needs `<exp-id>-predictions.npy` and a shared `labels.npy`.
+
+7. **If no predictions exist:** suggest saving predictions during training by adding prediction logging to `evaluate.py`.
+
+8. **Saved output:** report written to `experiments/ensembles/ensemble-*.yaml`
+
+## Examples
+
+```
+/turing:ensemble                              # Default: top-5, all methods
+/turing:ensemble --top-k 3                    # Top-3 models only
+/turing:ensemble --methods voting,stacking    # Specific methods
+/turing:ensemble --json                       # Machine-readable output
+```

package/skills/turing/explore/SKILL.md

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

package/skills/turing/export/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: export
+description: Export model to production format with equivalence verification, latency benchmarking, and deployment model card.
+argument-hint: "[exp-id] [--format joblib|xgboost_json|onnx|torchscript|tflite]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Export a trained model to a production-ready format.
+
+## 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
+   - `--format joblib|xgboost_json|onnx|torchscript|tflite` specifies export format (auto-detected if omitted)
+   - `--skip-equivalence` skips inference equivalence check
+   - `--skip-latency` skips latency benchmark
+   - `--samples 100` sets test sample count
+
+3. **Run export pipeline:**
+   ```bash
+   python scripts/export_model.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - **Export:** format, file size, output path, dependencies
+   - **Equivalence:** verdict (equivalent/approximately_equivalent/divergent), max delta
+   - **Latency:** p50/p95/p99 ms, speedup vs original
+   - **Model Card:** metrics, seed study, equivalence, latency, dependencies
+
+5. **Output:** exported model + model_card.yaml written to `exports/exp-NNN/`
+
+6. **If model file not found:** suggest checking models/best/ directory.
+
+## Examples
+
+```
+/turing:export                                     # Best experiment, default format
+/turing:export exp-042                             # Specific experiment
+/turing:export --format xgboost_json               # Native XGBoost JSON
+/turing:export --format onnx                       # ONNX format
+/turing:export --skip-equivalence --skip-latency   # Fast export
+```