claude-turing 1.0.0

package/bin/cli.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const { Command } = require("commander");
+const pkg = require("../package.json");
+
+const program = new Command();
+
+program
+  .name("claude-turing")
+  .description(pkg.description)
+  .version(pkg.version);
+
+program
+  .command("install")
+  .description("Install turing commands and agents to Claude Code")
+  .option("--global", "Install globally (~/.claude/)")
+  .option("--project", "Install for current project (.claude/)")
+  .action(async (opts) => {
+    const { install } = await import("../src/install.js");
+    await install(opts);
+  });
+
+program
+  .command("verify")
+  .description("Verify turing installation is complete")
+  .option("--scope <scope>", "Check a specific scope (global|project)")
+  .action(async (opts) => {
+    const { verify } = await import("../src/verify.js");
+    await verify(opts);
+  });
+
+program
+  .command("init [name] [dir]")
+  .description("Scaffold ML project (CLI mode, non-Claude-Code usage)")
+  .action(async (name, dir) => {
+    const { execSync } = await import("child_process");
+    const { dirname, join } = await import("path");
+    const { fileURLToPath } = await import("url");
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const script = join(__dirname, "turing-init.sh");
+    const args = [name, dir].filter(Boolean).join(" ");
+    execSync(`bash "${script}" ${args}`, { stdio: "inherit" });
+  });
+
+program.parse();

package/bin/turing-init.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Turing CLI init script.
+# Thin wrapper around scripts/scaffold.py — the unified scaffolding
+# implementation that both CLI and Claude Code use.
+#
+# Usage:
+#   turing-init [project_name] [ml_dir]
+#   turing-init --interactive
+#
+# For Claude Code usage, use /turing:init instead.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_DIR="$(dirname "$SCRIPT_DIR")"
+TEMPLATES_DIR="${PLUGIN_DIR}/templates"
+SCAFFOLD_SCRIPT="${TEMPLATES_DIR}/scripts/scaffold.py"
+
+# Check scaffold script exists
+if [[ ! -f "$SCAFFOLD_SCRIPT" ]]; then
+    echo "Error: scaffold.py not found at ${SCAFFOLD_SCRIPT}" >&2
+    echo "Ensure the Turing plugin is installed correctly." >&2
+    exit 1
+fi
+
+echo "╔══════════════════════════════════════════╗"
+echo "║     Turing ML Research Harness           ║"
+echo "║     Autonomous Experiment Infrastructure ║"
+echo "╚══════════════════════════════════════════╝"
+echo ""
+
+# If no args or --interactive, run interactive mode
+if [[ $# -eq 0 ]] || [[ "${1:-}" == "--interactive" ]]; then
+    python3 "$SCAFFOLD_SCRIPT" --interactive --templates-dir "$TEMPLATES_DIR" --no-venv
+    echo ""
+    echo "  To set up the virtual environment:"
+    echo "    cd <ml_dir> && python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt"
+    exit 0
+fi
+
+# Positional args mode: turing-init <project_name> [ml_dir]
+PROJECT_NAME="${1:-my-ml-project}"
+ML_DIR="${2:-ml/${PROJECT_NAME}}"
+
+python3 "$SCAFFOLD_SCRIPT" \
+    --project-name "$PROJECT_NAME" \
+    --target-metric "accuracy" \
+    --metric-direction "higher" \
+    --task-description "ML task for ${PROJECT_NAME}" \
+    --ml-dir "$ML_DIR" \
+    --data-source "data/training.csv" \
+    --templates-dir "$TEMPLATES_DIR" \
+    --no-venv --no-hooks
+
+echo ""
+echo "Note: Run with --interactive for full setup (metric, data source, etc.)"
+echo "Or use Claude Code: /turing:init"

package/commands/brief.md

@@ -0,0 +1,83 @@
+---
+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]"
+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.
+
+## Steps
+
+1. **Generate the briefing:**
+   ```bash
+   source .venv/bin/activate && python scripts/generate_brief.py
+   ```
+
+2. **Self-critique the briefing** before presenting. Review the generated output and check:
+   - **Recommendations specificity:** Are they concrete enough to act on? "Try a different model" is bad. "Try LightGBM with leaf-wise growth because exp-004 showed depth sensitivity" is good. If vague, rewrite them with specific model/hyperparameter suggestions grounded in the experiment data.
+   - **Exhausted directions coverage:** Cross-reference the "Model Types Explored" section against `experiments/log.jsonl`. Are there discarded experiments missing from the summary? If so, add them.
+   - **Convergence estimate grounding:** If the briefing says "close to convergence" or "further improvement possible", verify against the actual metric trajectory. Is the claim supported by the numbers?
+   - **Metric accuracy:** Spot-check that the "Current Best" metrics match the actual log. Run `python scripts/show_metrics.py --last 1` if uncertain.
+
+   If any section fails the check, regenerate just that section. Max 1 revision round — don't over-polish.
+
+3. **Present the output** to the user. The briefing has 6 sections:
+   - **Campaign Summary** — total experiments, keep rate, timespan
+   - **Current Best** — model type, metrics, experiment ID, configuration
+   - **Improvement Trajectory** — metric over time, rate of improvement
+   - **Model Types Explored** — which approaches have been tried and their hit rates
+   - **Hypothesis Queue** — pending and completed hypotheses
+   - **Recommendations** — data-driven next steps
+
+4. **If `$ARGUMENTS` contains `--deep`:** run the Literature-Grounded Suggestions step below.
+
+5. **Prompt for action:**
+   - "Want to inject a hypothesis? Use `/turing:try <idea>`"
+   - "Want to continue training? Use `/turing:train`"
+   - "Want literature-backed suggestions? Use `/turing:brief --deep`"
+
+## Literature-Grounded Suggestions (--deep flag)
+
+When `--deep` is requested, add a 7th section: **Literature-Grounded Suggestions**.
+
+### Steps:
+
+1. **Read context:** Read `config.yaml` and the briefing output to understand:
+   - What task type this is (tabular classification, time series, etc.)
+   - Which model families have been exhausted (from "Model Types Explored")
+   - Where improvement has plateaued (from "Improvement Trajectory")
+   - What failure patterns keep recurring
+
+2. **Search literature** with `WebSearch` for techniques that address the specific stagnation:
+   - If plateaued: "improve [task type] accuracy beyond [current metric] 2024"
+   - If overfitting: "regularization techniques [model family] [task type]"
+   - If all models tried: "state of the art [task type] benchmark 2024 2025"
+
+3. **Distill 3-5 suggestions** from the literature, each with:
+   - **Technique:** specific and actionable
+   - **Source:** paper or article URL
+   - **Why now:** how it addresses the specific stagnation point
+   - **Impact estimate:** high/medium/low
+   - **Complexity:** low/medium/high
+
+4. **Queue suggestions** as hypotheses:
+   ```bash
+   source .venv/bin/activate && python scripts/manage_hypotheses.py add "<technique>: <rationale> (source: <citation>)" --priority medium --source literature
+   ```
+
+5. **Format as a section** appended to the briefing.
+
+## Saving Briefs
+
+```bash
+mkdir -p briefs && python scripts/generate_brief.py > briefs/brief-$(date +%Y-%m-%d).md
+```
+
+## When to Use
+
+- After a training session completes or converges
+- Before injecting new hypotheses (to understand what's already been tried)
+- When returning to a project after time away
+- **With `--deep`:** when the agent seems stuck and you want evidence-based direction

package/commands/compare.md

@@ -0,0 +1,24 @@
+---
+name: compare
+description: Compare two ML experiment runs side-by-side — metrics, configuration deltas, and a verdict on which approach is more promising.
+disable-model-invocation: true
+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/commands/design.md

@@ -0,0 +1,97 @@
+---
+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/.
+disable-model-invocation: true
+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/commands/init.md

@@ -0,0 +1,123 @@
+---
+name: init
+description: Initialize a new ML project with the Turing autoresearch harness. Scaffolds the full experiment infrastructure — immutable evaluation pipeline, agent-editable training code, structured logging, convergence detection hooks, and a Python virtual environment. Use --plan to generate a research plan.
+disable-model-invocation: true
+argument-hint: "[project_name] [--plan]"
+allowed-tools: Read, Write, Edit, Bash(*), Grep, Glob, WebSearch, WebFetch
+---
+
+Scaffold a new ML project with the Turing autoresearch harness. This creates the separation between the measurement apparatus (READ-ONLY) and the hypothesis space (AGENT-EDITABLE) that makes autonomous experimentation trustworthy.
+
+## Interactive Setup
+
+Ask the user for the following (or accept from `$ARGUMENTS` if provided as JSON):
+
+1. **Project name** (`{{PROJECT_NAME}}`): Name of the ML project (e.g., "sentiment", "churn", "fraud-detection")
+2. **Target metric** (`{{TARGET_METRIC}}`): Primary metric to optimize (e.g., "accuracy", "f1", "mae", "mse", "auc")
+3. **Metric direction**: Is lower better (mae, mse, loss) or higher better (accuracy, f1, auc)?
+4. **Task description** (`{{TASK_DESCRIPTION}}`): What the model does (e.g., "Predict customer churn from usage data")
+5. **ML directory** (`{{ML_DIR}}`): Where ML files go relative to project root (e.g., "ml/sentiment")
+6. **Data source** (`{{DATA_SOURCE}}`): Where training data comes from (e.g., "data/reviews.csv")
+
+## Scaffolding
+
+Once you have all 6 values, delegate to the unified scaffolding script:
+
+```bash
+python3 <templates_dir>/scripts/scaffold.py \
+    --project-name "<project_name>" \
+    --target-metric "<target_metric>" \
+    --metric-direction "<metric_direction>" \
+    --task-description "<task_description>" \
+    --ml-dir "<ml_dir>" \
+    --data-source "<data_source>" \
+    --templates-dir "<templates_dir>"
+```
+
+The scaffold script handles everything in a single atomic operation:
+- Copies all template files with placeholder substitution
+- Creates data/, experiments/, models/ directories
+- Sets up agent memory at `.claude/agent-memory/ml-researcher/MEMORY.md`
+- Configures Claude Code hooks in `.claude/settings.local.json`
+- Creates Python virtual environment and installs requirements
+- Verifies all placeholders were replaced (fails loudly if any remain)
+
+## Locating Templates
+
+Find the templates directory using Glob:
+```
+~/.claude/plugins/*/templates/
+```
+Or check if installed via npm by looking for `node_modules/claude-turing/templates/`.
+
+## After Scaffolding
+
+Report what was created:
+- The separation: READ-ONLY (`prepare.py`, `evaluate.py`) vs AGENT-EDITABLE (`train.py`)
+- Next steps: add data to the configured data source path, run `python prepare.py`, then `/turing:train`
+- The taste-leverage loop: `/turing:try` to inject hypotheses, `/turing:brief` for intelligence reports
+
+## Research Plan Generation (--plan flag)
+
+If `$ARGUMENTS` contains `--plan`, generate a research plan AFTER scaffolding. This gives the agent strategic direction for its first 5-10 experiments rather than ad-hoc exploration.
+
+### Steps:
+
+1. **Read the task context** from the just-created `config.yaml`: task description, model type, target metric, data source.
+
+2. **Search literature** with `WebSearch` for the task domain:
+   - "state of the art <task description> machine learning 2024 2025"
+   - "best model <target metric> <data type> benchmark"
+   - "<task description> common approaches survey"
+
+   Use `WebFetch` on top 2-3 results to extract: dominant model families, typical metric ranges, known challenges.
+
+3. **Generate `RESEARCH_PLAN.md`** in the ML project directory with this structure:
+
+   ```markdown
+   # Research Plan: <task description>
+
+   Generated: <date>
+
+   ## Task Summary
+   <one paragraph describing the task, data, and success criteria>
+
+   ## Model Families to Explore
+   Ordered by expected relevance based on literature:
+   1. **<family 1>** — <why, with citation>
+   2. **<family 2>** — <why, with citation>
+   3. **<family 3>** — <why, with citation>
+
+   ## Evaluation Strategy
+   - Primary metric: <metric> (<higher/lower> is better)
+   - Multi-run recommendation: <yes/no, based on expected variance>
+   - Baseline target: <realistic first-pass metric from literature>
+
+   ## Search Budget
+   - <N> experiments per model family before moving on
+   - Total budget: <N> experiments before first convergence check
+
+   ## Success Criteria
+   - Target metric: <value from literature benchmarks>
+   - Convergence: <patience> consecutive non-improvements
+
+   ## Known Challenges
+   - <challenge 1 from literature, e.g., "class imbalance common in this domain">
+   - <challenge 2>
+
+   ## Sources
+   - <citation 1>
+   - <citation 2>
+   ```
+
+4. **Self-critique the plan** (one round):
+   - Are the model families ordered by evidence strength?
+   - Is the budget realistic?
+   - Are the success criteria grounded in benchmark data?
+   Revise if any section is vague or unsupported.
+
+5. **Report:** "Research plan generated at `<ml_dir>/RESEARCH_PLAN.md`. The agent will read this during `/turing:train` for strategic direction."
+
+### 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`.

package/commands/logbook.md

@@ -0,0 +1,51 @@
+---
+name: logbook
+description: Generate a research logbook showing the full experiment narrative — hypotheses proposed, experiments run, decisions made, and progress over time. Outputs HTML (with interactive chart) or markdown.
+disable-model-invocation: true
+argument-hint: "[--since YYYY-MM-DD] [--format html|markdown] [--output path]"
+allowed-tools: Read, Bash(python scripts/*:*, source .venv/bin/activate:*, mkdir:*), Grep, Glob
+---
+
+Generate a research logbook that captures the full narrative of the experiment campaign.
+
+## Steps
+
+1. **Generate the logbook:**
+   ```bash
+   source .venv/bin/activate && python scripts/generate_logbook.py
+   ```
+
+   **With options from `$ARGUMENTS`:**
+   - `--since 2026-03-15` — only include events after this date
+   - `--format markdown` — output as markdown instead of HTML
+   - `--output logbook.html` — write to file instead of stdout
+
+   **Common usage:**
+   ```bash
+   # HTML logbook with interactive trajectory chart
+   source .venv/bin/activate && python scripts/generate_logbook.py --output logbook.html
+
+   # Markdown for embedding in docs or READMEs
+   source .venv/bin/activate && python scripts/generate_logbook.py --format markdown --output logbook.md
+
+   # Last week's activity
+   source .venv/bin/activate && python scripts/generate_logbook.py --since 2026-03-24 --output logbook.html
+   ```
+
+2. **Present the result:**
+   - If HTML: tell the user to open the file in their browser. The logbook includes an interactive Chart.js trajectory visualization.
+   - If markdown: display inline or note the output file location.
+
+## What the Logbook Contains
+
+- **Campaign summary:** total experiments, keep rate, best metric, hypothesis count
+- **Improvement trajectory:** interactive line chart showing metric progression and best-so-far envelope
+- **Experiment log:** every experiment with ID, description, metric value, status (kept/discarded), date
+- **Hypothesis queue:** every hypothesis with source (human/agent/literature), status, priority
+
+## When to Use
+
+- To share progress with collaborators
+- Before and after meetings to show what was tried
+- To archive a completed research campaign
+- To track progress over a specific time period

package/commands/mode.md

@@ -0,0 +1,43 @@
+---
+name: mode
+description: Set the research strategy mode — explore (try new things), exploit (refine what works), or replicate (verify results). Drives novelty guard policy and agent behavior.
+disable-model-invocation: true
+argument-hint: "<explore|exploit|replicate>"
+---
+
+Set the research mode for the current project. The mode determines how the novelty guard filters proposed experiments and how the agent prioritizes its work.
+
+## Modes
+
+| Mode | Novelty Guard Policy | Agent Behavior |
+|------|---------------------|----------------|
+| **explore** | Allow novel ideas, block repeats and follow-ups | Try fundamentally different approaches |
+| **exploit** | Allow follow-ups and known successes, block repeats | Refine the current best configuration |
+| **replicate** | Allow duplicate runs, block novel ideas | Re-run best experiments with different seeds |
+
+## Steps
+
+1. **Parse mode** from `$ARGUMENTS`. Must be one of: `explore`, `exploit`, `replicate`.
+
+2. **Update experiment state:**
+   ```bash
+   source .venv/bin/activate
+   python -c "
+   import yaml
+   from pathlib import Path
+   path = Path('experiment_state.yaml')
+   state = yaml.safe_load(path.read_text()) if path.exists() else {}
+   state['research_mode'] = '$ARGUMENTS'
+   path.write_text(yaml.dump(state, default_flow_style=False))
+   print(f'Research mode set to: $ARGUMENTS')
+   "
+   ```
+
+3. **Confirm** with guidance:
+   - `explore`: "The agent will prioritize novel ideas and avoid follow-ups. Best when the current approach feels exhausted."
+   - `exploit`: "The agent will refine the current best. Best when you have a promising direction."
+   - `replicate`: "The agent will re-run experiments for statistical verification. Best before declaring a winner."
+
+## Default
+
+The default mode is `exploit` (refine what works). Change to `explore` when plateauing, `replicate` before final decisions.

package/commands/poster.md

@@ -0,0 +1,89 @@
+---
+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.
+disable-model-invocation: true
+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)