claude-turing 1.0.0 → 1.0.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "turing",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Autonomous ML research harness — the autoresearch loop as a formal protocol. 14 commands, 2 specialized agents, structured experiment lifecycle with convergence detection, immutable evaluation infrastructure, novelty guard, decision synthesis, hypothesis database, and safety guardrails that separate the hypothesis space from the measurement apparatus. Inspired by Karpathy's autoresearch and the scientific method itself.",
   "author": {
     "name": "pragnition"

package/README.md

@@ -300,8 +300,8 @@ The index (`hypotheses.yaml`) is the lightweight queue. The detail files (`hypot
 
 | Command | What it does |
 |---------|-------------|
-| `/turing:init [--plan]` | Scaffold a new ML project. `--plan` generates a literature-grounded research plan. |
-| `/turing:train [N]` | Run the autonomous experiment loop (optional max iterations) |
+| `/turing:init [--plan]` | Scaffold a new ML project. `--plan` generates a literature-grounded research plan. Supports multiple projects in subdirectories. |
+| `/turing:train [ml/project] [N]` | Run the experiment loop. Auto-detects project from cwd or explicit path. |
 | `/turing:sweep` | Systematic hyperparameter sweep via cartesian product |
 | `/turing:status` | Quick experiment status — best model, convergence state |
 | `/turing:compare <a> <b>` | Side-by-side experiment comparison with causal analysis |
@@ -404,15 +404,27 @@ claude plugin add /path/to/turing
 ### Quick Start
 
 ```bash
-/turing:init            # Scaffold project (answer 3 prompts)
-/turing:train           # Run experiment loop
-/turing:brief           # Read what happened
-/turing:try "idea"      # Inject your taste
+/turing:init                    # Scaffold project (answer 3 prompts)
+/turing:train                   # Run experiment loop
+/turing:brief                   # Read what happened
+/turing:try "idea"              # Inject your taste
 ```
 
+### Multiple Projects
+
+```bash
+/turing:init                    # Scaffold ml/sentiment
+/turing:init                    # Scaffold ml/churn
+/turing:train ml/sentiment      # Train in specific project
+/turing:brief ml/churn          # Brief for specific project
+cd ml/sentiment && /turing:train  # Auto-detects from cwd
+```
+
+Each project gets independent config, data, experiments, models, and agent memory.
+
 ## Architecture of Turing Itself
 
-15 commands, 2 agents, 8 config files, 25 template scripts, 338 tests, 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
+15 commands, 2 agents, 8 config files, 25 template scripts, model registry, artifact contract, 338 tests, 16 ADRs. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full codemap.
 
 ```
 turing/
@@ -423,6 +435,8 @@ turing/
 │   ├── prepare.py         Data loading (HIDDEN from agent)
 │   ├── evaluate.py        Evaluation harness (HIDDEN from agent)
 │   ├── train.py           Training code (AGENT-EDITABLE)
+│   ├── model_contract.md  Artifact schema for production consumers
+│   ├── model_registry.yaml  Available model architectures + hyperparams
 │   └── scripts/           25 Python scripts (core loop + analysis + infra)
 ├── tests/                 338 tests (unit + integration + anti-pattern + manifest)
 ├── src/                   5 JS installer files (npm deployment)

package/commands/brief.md

@@ -2,12 +2,24 @@
 name: brief
 description: Generate a structured research intelligence report from experiment history — what's been learned, what's promising, what's exhausted, and what the human should consider next. Use --deep for literature-grounded suggestions.
 disable-model-invocation: true
-argument-hint: "[--deep]"
+argument-hint: "[ml/project] [--deep]"
 allowed-tools: Read, Bash(python scripts/*:*, source .venv/bin/activate:*), Grep, Glob, WebSearch, WebFetch
 ---
 
 Generate a research briefing that a human can read in 2 minutes and immediately decide what to inject next.
 
+## Project Detection
+
+Before generating the briefing, detect which project to report on:
+
+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 report on
+   - All subsequent commands run from the detected project directory
+
 ## Steps
 
 1. **Generate the briefing:**

package/commands/init.md

@@ -121,3 +121,16 @@ If `$ARGUMENTS` contains `--plan`, generate a research plan AFTER scaffolding. T
 ### Integration
 
 The agent's `program.md` OBSERVE step reads `RESEARCH_PLAN.md` (if it exists) for strategic direction. The plan is advisory — the agent can deviate but should note why in `experiment_state.yaml`.
+
+## Multiple Projects
+
+You can scaffold multiple ML projects in the same repository:
+
+```bash
+/turing:init    # First project: prompts for ml_dir (e.g., ml/sentiment)
+/turing:init    # Second project: prompts for ml_dir (e.g., ml/churn)
+```
+
+Each project gets its own directory with independent config, data, experiments, and models. `/turing:train ml/sentiment` or `/turing:train ml/churn` targets a specific project. If you `cd ml/sentiment` first, `/turing:train` auto-detects from cwd.
+
+Agent memory is scoped per project: `.claude/agent-memory/ml-researcher-{project_name}/MEMORY.md`

package/commands/train.md

@@ -12,16 +12,25 @@ Read `program.md` in the ML project directory for the complete protocol. Follow
 
 ## Arguments
 
-`$ARGUMENTS` — if a number, use as max_iterations (stop after N experiments). If empty, run until convergence (as defined in `config.yaml` convergence settings).
+`$ARGUMENTS` — accepts a project path (e.g., `ml/coding`), a number for max_iterations, or both (e.g., `ml/coding 10`). If no number, run until convergence (as defined in `config.yaml` convergence settings).
 
 ## Bootstrap Sequence
 
-0. **Restore memory:** Read `.claude/agent-memory/ml-researcher/MEMORY.md` for prior observations and best results.
-1. **Read protocol:** Read `program.md` completely — it defines the experiment loop, constraints, and output format.
-2. **Bootstrap data:** Check for training data at `config.yaml` → `data.source`. If no splits exist, run `python prepare.py`.
-3. **Bootstrap venv:** `test -d .venv || (python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt)`
-4. **Assess state:** `source .venv/bin/activate && python scripts/show_metrics.py --last 5`
-5. **Begin the loop** from program.md.
+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
+   - Memory path: `.claude/agent-memory/ml-researcher-{project_name}/MEMORY.md`
+
+1. **Restore memory:** Read `.claude/agent-memory/ml-researcher-{project_name}/MEMORY.md` for prior observations and best results.
+2. **Read protocol:** Read `program.md` completely — it defines the experiment loop, constraints, and output format.
+3. **Bootstrap data:** Check for training data at `config.yaml` → `data.source`. If no splits exist, run `python prepare.py`.
+4. **Bootstrap venv:** `test -d .venv || (python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt)`
+5. **Assess state:** `source .venv/bin/activate && python scripts/show_metrics.py --last 5`
+6. **Begin the loop** from program.md.
 
 ## The Loop
 

package/commands/turing.md

@@ -9,7 +9,7 @@ You are the Turing ML research router. Detect the user's intent and route to the
 
 | User says... | Route to | Lifecycle phase |
 |---|---|---|
-| "train", "run experiments", "autoresearch", "improve the model", "start training" | `/turing:train` | Execute |
+| "train", "train ml/coding", "train ml/claims", "run experiments", "run experiments in ml/X", "autoresearch", "improve the model", "start training" | `/turing:train` | Execute |
 | "status", "how's training", "experiment results", "current metrics" | `/turing:status` | Observe |
 | "compare", "diff runs", "which is better" | `/turing:compare` | Analyze |
 | "sweep", "grid search", "hyperparameter search", "tune" | `/turing:sweep` | Explore |
@@ -29,7 +29,7 @@ You are the Turing ML research router. Detect the user's intent and route to the
 
 | Command | Purpose | Agent |
 |---|---|---|
-| `/turing:train [N]` | Run the autonomous experiment loop | @ml-researcher |
+| `/turing:train [ml/project] [N]` | Run the autonomous experiment loop (auto-detects project from path or cwd) | @ml-researcher |
 | `/turing:status` | Show experiment status, best model, convergence | @ml-evaluator |
 | `/turing:compare <a> <b>` | Side-by-side experiment comparison | @ml-evaluator |
 | `/turing:sweep` | Generate and run hyperparameter sweep | @ml-researcher |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-turing",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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/templates/model_contract.md

@@ -0,0 +1,49 @@
+# Model Artifact Contract
+
+Version: 1
+Last updated: {{PROJECT_NAME}} initial scaffold
+
+## Bundle Format
+
+The trained model is saved as a joblib bundle at `models/best/model.joblib` containing:
+
+```python
+{
+    "model": <fitted model object>,
+    "featurizer": <fitted CompositeFeaturizer>,
+    "config": <dict of training config>,
+    "contract_version": 1
+}
+```
+
+## Metadata
+
+`models/best/metadata.json` contains:
+
+```json
+{
+    "contract_version": 1,
+    "model_type": "xgboost",
+    "experiment_id": "exp-001",
+    "metrics": {"{{TARGET_METRIC}}": 0.0},
+    "feature_names": [],
+    "created_at": "ISO-8601"
+}
+```
+
+## Consumer Contract
+
+Any service loading this model expects:
+- `bundle["model"]` has a `.predict()` method accepting a feature matrix
+- `bundle["featurizer"]` has a `.transform(df)` method returning a DataFrame
+- `bundle.get("contract_version", 0)` must equal 1
+
+If `contract_version` doesn't match, the consumer should log a warning and fall back to a default/rules-based approach.
+
+## Breaking Changes
+
+Increment `contract_version` when changing:
+- Feature schema (different featurizer output shape)
+- Label encoding (different label_map)
+- Bundle key names
+- Model input/output format

package/templates/model_registry.yaml

@@ -0,0 +1,69 @@
+# Model Registry for {{PROJECT_NAME}}
+#
+# Catalog of available model architectures. The agent reads this
+# during /turing:suggest and archetype:model_comparison to know
+# what models are available and how to configure them.
+#
+# Add your domain-specific models here.
+
+models:
+  xgboost:
+    name: "XGBoost Classifier"
+    family: "gradient_boosting"
+    task: "{{TARGET_METRIC}}"
+    notes: "Default model. Good for tabular data with mixed feature types."
+    paper: "https://arxiv.org/abs/1603.02754"
+    default_hyperparams:
+      n_estimators: 100
+      max_depth: 4
+      learning_rate: 0.1
+      objective: "multi:softmax"
+
+  lightgbm:
+    name: "LightGBM Classifier"
+    family: "gradient_boosting"
+    task: "{{TARGET_METRIC}}"
+    notes: "Often faster than XGBoost. Leaf-wise growth. Try dart boosting for regularization."
+    paper: "https://papers.nips.cc/paper/2017/hash/6449f44a102fde848669bdd9eb6b76fa-Abstract.html"
+    default_hyperparams:
+      n_estimators: 100
+      max_depth: -1
+      learning_rate: 0.1
+      num_leaves: 31
+
+  random_forest:
+    name: "Random Forest Classifier"
+    family: "ensemble"
+    task: "{{TARGET_METRIC}}"
+    notes: "Bagging ensemble. Good baseline. Less prone to overfitting than single trees."
+    default_hyperparams:
+      n_estimators: 100
+      max_depth: null
+      min_samples_split: 2
+
+  logistic_regression:
+    name: "Logistic Regression"
+    family: "linear"
+    task: "{{TARGET_METRIC}}"
+    notes: "Simple linear baseline. Always try this first — if it works well, your features are strong."
+    default_hyperparams:
+      C: 1.0
+      max_iter: 1000
+
+  mlp:
+    name: "Multi-Layer Perceptron"
+    family: "neural_network"
+    task: "{{TARGET_METRIC}}"
+    notes: "Simple neural network. Try when samples > 2000. Needs feature scaling."
+    default_hyperparams:
+      hidden_layer_sizes: [100, 50]
+      learning_rate_init: 0.001
+      max_iter: 200
+
+# Add your domain-specific models below:
+# e.g., for NLP tasks:
+#   bert-base:
+#     name: "BERT Base"
+#     family: "transformer"
+#     hf_id: "bert-base-uncased"
+#     ...

package/templates/program.md

@@ -71,6 +71,8 @@ The autoresearch experiment loop. Each iteration is one experiment — one hypot
    cat RESEARCH_PLAN.md 2>/dev/null || true
    ```
 
+   Read `model_registry.yaml` to know what model architectures are available, their default hyperparameters, and family groupings. Use this to inform model selection during suggest and model_comparison archetypes.
+
    If `RESEARCH_PLAN.md` exists, use it for strategic direction (which model families to explore, in what order, what budget). The plan is advisory — deviate if evidence warrants, but note why.
 
    For the most recent discarded experiments, read the actual git diff to understand what was tried and failed — do NOT rely on your own memory of what you changed:

package/templates/scripts/scaffold.py

@@ -46,6 +46,8 @@ TEMPLATE_FILES = [
     "program.md",
     "README.md",
     "MEMORY.md",
+    "model_registry.yaml",
+    "model_contract.md",
     "requirements.txt",
     "pyproject.toml",
 ]