claude-turing 2.3.0 → 2.4.0

package/.claude-plugin/plugin.json

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

@@ -344,6 +344,9 @@ The index (`hypotheses.yaml`) is the lightweight queue. The detail files (`hypot
 | `/turing:diff <a> <b>` | Deep experiment comparison — config diffs, metric significance, per-class regressions, curve divergence |
 | `/turing:watch [--analyze]` | Live training monitor — loss spikes, NaN detection, overfitting, plateau alerts |
 | `/turing:regress [--tolerance]` | Performance regression gate — verify metrics haven't degraded after changes |
+| `/turing:ensemble [--top-k]` | Automated ensemble — voting, stacking, blending from top-K models |
+| `/turing:stitch <action>` | Pipeline composition — show, swap, cache, and run stages independently |
+| `/turing:warm <exp-id>` | Warm-start from prior model — load checkpoint, freeze layers, adjust LR |
 
 And for fully hands-off operation:
 
@@ -528,11 +531,11 @@ Each project gets independent config, data, experiments, models, and agent memor
 
 ## Architecture of Turing Itself
 
-33 commands, 2 agents, 10 config files, 52 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), 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
+36 commands, 2 agents, 10 config files, 55 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), 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
 
 ```
 turing/
-├── commands/              32 skill files (core + taste-leverage + reporting + exploration + statistical rigor + experiment intelligence + performance + deployment + research workflow + orchestration + deep analysis)
+├── commands/              35 skill files (core + taste-leverage + reporting + exploration + statistical rigor + experiment intelligence + performance + deployment + research workflow + orchestration + deep analysis + model composition)
 ├── 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/ensemble.md

@@ -0,0 +1,54 @@
+---
+name: ensemble
+description: Automated ensemble construction — combines top-K models via voting, stacking, and blending for zero-cost improvement.
+disable-model-invocation: true
+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/commands/stitch.md

@@ -0,0 +1,49 @@
+---
+name: stitch
+description: Pipeline composition — decompose ML pipelines into swappable stages. Show, swap, cache, and run stages independently.
+disable-model-invocation: true
+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/commands/turing.md

@@ -42,6 +42,9 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | "diff", "deep compare", "what changed", "why did it diverge", "experiment diff" | `/turing:diff` | Analyze |
 | "watch", "monitor", "live training", "loss spike", "is it overfitting", "training progress" | `/turing:watch` | Monitor |
 | "regress", "regression", "did metrics degrade", "check for regression", "CI gate", "stability check" | `/turing:regress` | Validate |
+| "ensemble", "combine models", "voting", "stacking", "blending", "merge models" | `/turing:ensemble` | Compose |
+| "stitch", "pipeline", "swap stage", "cache stage", "pipeline composition" | `/turing:stitch` | Compose |
+| "warm", "warm start", "fine-tune", "continue training", "transfer learning", "from checkpoint" | `/turing:warm` | Compose |
 
 ## Sub-commands
 
@@ -80,6 +83,9 @@ You are the Turing ML research router. Detect the user's intent and route to the
 | `/turing:diff <exp-a> <exp-b>` | Deep experiment comparison: config diff, metric significance, per-class regressions, curve divergence | (inline) |
 | `/turing:watch [--analyze]` | Live training monitor with early-warning alerts (loss spike, NaN, overfitting, plateau) | (inline) |
 | `/turing:regress [--tolerance]` | Performance regression gate: re-run best experiment, verify metrics haven't degraded | (inline) |
+| `/turing:ensemble [--top-k] [--methods]` | Automated ensemble: voting, weighted voting, stacking, blending from top-K models | (inline) |
+| `/turing:stitch <action> [stage]` | Pipeline composition: show/swap/cache/run stages independently | (inline) |
+| `/turing:warm <exp-id>` | Warm-start from prior model: load checkpoint, freeze layers, adjust LR | (inline) |
 
 ## Proactive Detection
 

package/commands/warm.md

@@ -0,0 +1,53 @@
+---
+name: warm
+description: Warm-start from a prior model — load checkpoint, optionally freeze layers, adjust learning rate, and continue training.
+disable-model-invocation: true
+argument-hint: "<exp-id> [--freeze-layers encoder] [--unfreeze-after 5]"
+allowed-tools: Read, Bash(*), Grep, Glob
+---
+
+Take a trained checkpoint and use it as initialization for a new experiment. Automates the "start from here but change X" pattern.
+
+## Steps
+
+1. **Activate environment:**
+   ```bash
+   source .venv/bin/activate
+   ```
+
+2. **Parse arguments from `$ARGUMENTS`:**
+   - First argument is the source experiment ID (required)
+   - `--freeze-layers encoder decoder` — layer names to freeze (neural only)
+   - `--unfreeze-after 5` — unfreeze all layers after N epochs (gradual unfreezing)
+   - `--lr-factor 0.1` — learning rate reduction factor (default: 0.1x)
+   - `--json` — raw JSON output
+
+3. **Run warm-start planner:**
+   ```bash
+   python scripts/warm_start.py $ARGUMENTS
+   ```
+
+4. **Report results:**
+   - Model type detection (tree, neural, sklearn)
+   - Strategy: continue_boosting, load_weights, or warm_start_param
+   - Numbered step-by-step instructions
+   - Config changes to apply
+   - Checkpoint info (path, format, size)
+
+5. **Strategies by model type:**
+   - **Tree models (XGBoost/LightGBM):** continue boosting from existing trees with more estimators
+   - **Neural networks:** load weights, optionally freeze layers, reset optimizer, reduce LR
+   - **scikit-learn:** use `warm_start=True` parameter for incremental learning
+
+6. **If no checkpoint found:** plan is still generated, but warns that checkpoint is needed
+
+7. **Saved output:** report written to `experiments/warm_starts/warm-<exp-id>.yaml`
+
+## Examples
+
+```
+/turing:warm exp-042                                   # Auto-detect strategy
+/turing:warm exp-042 --freeze-layers encoder           # Freeze encoder layers
+/turing:warm exp-042 --freeze-layers encoder --unfreeze-after 5  # Gradual unfreezing
+/turing:warm exp-042 --lr-factor 0.01                  # Very small fine-tuning LR
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-turing",
-  "version": "2.3.0",
+  "version": "2.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

@@ -26,6 +26,7 @@ const SUB_COMMANDS = [
   "diagnose", "ablate", "frontier", "profile", "checkpoint", "export",
   "lit", "paper", "queue", "retry", "fork",
   "diff", "watch", "regress",
+  "ensemble", "stitch", "warm",
 ];
 
 export async function install(opts = {}) {

package/src/verify.js

@@ -47,6 +47,9 @@ const EXPECTED_COMMANDS = [
   "diff/SKILL.md",
   "watch/SKILL.md",
   "regress/SKILL.md",
+  "ensemble/SKILL.md",
+  "stitch/SKILL.md",
+  "warm/SKILL.md",
 ];
 
 const EXPECTED_AGENTS = ["ml-researcher.md", "ml-evaluator.md"];