rockie-claude

Pre-commit anti-slop audit — checks staged/dirty files for code slop (debug artifacts, single-use helpers, dead imports) AND documentation slop (stale claims, broken internal links, new .md files, redundant sections). Writes a sentinel so the pre-commit-gate hook lets the commit through. MUST be invoked before `git commit` in this repo. Triggers when the agent is about to commit, when user says "commit", "clean", "ready to commit", or when the pre-commit-gate hook blocks.

Pull expert skills into this harness from the Rockie platform catalog (~300 skills across ML training/inference, biology, chemistry, physics, databases, coding). Use BEFORE writing domain guidance from scratch or fumbling an unfamiliar framework — if the task names a library (vLLM, GRPO, TRL, AlphaFold, DuckDB, LAMMPS), check the catalog first. Browse `rockie skill catalog --search X --json`, pull into `.claude/skills/`, invoke immediately. Silently no-ops when the Rockie CLI is absent or logged out.

Canonical around-the-clock research loop. Defines the agent's outer loop — read taste corpus + queue, pick the next experiment, mutate the explicitly-declared mutation surface, run the experiment under a hard time budget against a frozen metric, score, codify, repeat. Augmented with Karpathy's sharp primitives (frozen metric, time cap, explicit mutation surface) and a sustained-campaign layer (concurrent run/plan/write-up pipeline, verdict protocol, novelty re-verification gate) for multi-day operations.

Build any goal-declared agent end to end. Turns one declared goal into a portable, self-hardening, publishable agent repo on the Claude-Code harness. Declare goal, pick runtime/tools and write policies/hooks/safeguards, scaffold a portable repo (config-over-code split), build, run a fresh no-memory adversarial gauntlet, iterate with the clean-pass counter resetting on any failed round, publish ONLY after passing twice with zero CRITICALs, then export a .af agent-file. Biased to emit agents that contain their own internal adversarial critic loop. Triggers on "build an agent", "make me an agent that", "agent builder", "scaffold an agent", "publish this agent", "export to .af", "/agent-builder".

Lab composer command scaffold for `/build-agent <name>`. In Agent Builder A1 this only creates a lab-scoped draft agent record and opens that lab's agent detail route for editing. It does not build, run, evaluate, observe, or deploy agents yet.

Narrow quickstart wrapper for pre-baked Deploy-card requests. Triggers on server-validated structured quickstart deploy prompts such as "Quickstart deploy request: track: deploy model: <id> source: quickstart-picker quickstart_intent_id: <id>" and explicit "deploy this featured model" requests from Rockie's quickstart picker when validation metadata is present.

Produce structured acquisition due-diligence findings from deal inputs and a private data room. Triggers on "run diligence", "due diligence on", "diligence deck", "DD findings", "acquisition analysis", "data room", "ingest data room", "/diligence".

Create validated Excel `.xlsx` workbook artifacts with XlsxWriter, formula-injection protection, and Rockie artifact emission.

Run a materials-science / ML compute job on Rockie GPU capacity. Trigger words "run experiment", "submit job", "/experiment", or requests to quote/approve GPU spend before an experiment. Picks the right GPU type and count from a natural-language description (DFT for QE/VASP/ABINIT, MD for GROMACS/LAMMPS/OpenMM, training for PyTorch/JAX), generates the script, routes Rockie-originated submits through the embedded budget-term-sheet gate plus `runtime/submit.py`, polls status, streams logs, and surfaces the final artifacts. Use this for anything that needs a GPU — single A100 up to multi-pod B200 clusters.

Embedded /experiment subskill that builds a pre-deploy Rockie GPU budget term sheet before any Rockie-originated experiment submit. Trigger through /experiment when the user asks to quote the GPU budget, show the term sheet, modify approval, or submit GPU / torch / triton / training / weight-download work.

Track 2 quickstart wrapper for structured fine-tune prompts using a registry model, a registry dataset, Rockie GPU jobs, and inference-loader deployment of the trained artifact.

Productize an open-source model into a hosted inference endpoint the researcher (or their agent) can call. Picks the right hardware, the right serving stack (vLLM / Triton / TEI / BentoML), wraps it in an OpenAI-compatible gateway (LiteLLM) with per-tenant auth, exposes it as an MCP tool in chat, and runs a quality + latency + cost probe so the user knows what they actually shipped. Triggers on `/inference-engineer [model-url]`, or on natural intent like "host this model", "serve inference for X", "deploy model Y", "get me an API for Z", "I want to reproduce paper P on a small GPU", "what do I do with this trained model".

One-time researcher onboarding interview that compiles a `taste/` corpus (SOUL.md, STYLE.md, METHODOLOGY.md, DISMISSALS.md, MEMORY.md, INDEX.md) capturing the researcher's intellectual taste, beliefs, and values. Auto-injects INDEX.md into every future session via SessionStart. Triggers on first install ("no taste corpus found"), explicit `/onboard`, `/onboard --deep` for Tier 2 voice laddering, or `/onboard --redo` / `/onboard --section <name>` to refresh.

Write submission-grade research papers end to end inside a Rockie lab, the way a careful human researcher does — not generic LLM filler. Three entry points. /lit-review pulls and ranks a corpus and persists a human reading list Note plus a machine-readable index Note. /paper-draft produces a brief, a page-budgeted outline, per-section drafts, an adversarial review gauntlet (attack, defense, rebuttal, style, format), and a final AI-vs-human detector gate. /publish assembles a downloadable bundle, lands it as a lab Note, and optionally exports to GitHub or Hugging Face. Triggers on "write a paper", "lit review", "literature review", "draft the paper", "review my paper", "run the gauntlet on this draft", "publish the paper", "submit to <venue>", "/lit-review", "/paper-draft", "/publish".

Route physics simulation, modeling, validation, and research-compute requests across force fields, molecular dynamics, electronic structure, particle transport/collision, continuum multiphysics, plasma/PIC, nuclear/radiation, and astro/cosmology. Use open-source-first engines, refuse local heavyweight execution on the orchestrator, and attach physics dashboard monitoring profiles to run plans.

Create validated PowerPoint `.pptx` deck artifacts through the lean Rockie PPTAgent wrapper and emit them to the lab.

Track 3 quickstart wrapper that reproduces a paper or repository baseline on Rockie GPU, then extends it with a user-specified delta and compares baseline versus delta.

Scan the current session for harness-level patterns that would be useful to other rockie users, then either package a reviewed local harness patch or dispatch a public upstream contribution PR. Uses Scout/Generator/Verifier/Updater separation, never auto-merges, and requires human sign-off before pushing. Triggers when the user says "upstream this", "contribute back", "propose a harness change", "write a PR for rockie", or after `/clean` emits its post-audit nudge.

This agent's own internal adversarial critic loop. Hardens every deliverable with a fresh no-memory domain critic until it passes twice consecutively with zero CRITICALs before return.

Build a pre-deploy Rockie GPU budget term sheet before any Rocky-originated experiment submit. Trigger words "/budget-term-sheet", "quote the GPU budget", "show me the term sheet", or any workflow that is about to call `/experiment` for GPU / torch / triton / training / weight-download work.

One-time onboarding flow for users who set ROCKIE_GPU_MODE=custom (i.e., they have their own GPU setup — own AWS account, on-prem cluster, SSH tunnel to a workstation, university HPC, custom orchestration — instead of using Rockie's deidentified GPU router). Trigger this when (1) the user mentions GPU/training/provisioning, (2) `echo $ROCKIE_GPU_MODE` returns `custom`, AND (3) `.claude/gpu-custom.md` doesn't exist or is empty. Walks the user through their auth/provision/connect/monitor/terminate flow and saves it to .claude/gpu-custom.md so future agent sessions reuse the saved flow without re-asking. Run this AT MOST ONCE per project.

Runtime skill for users in ROCKIE_GPU_MODE=custom — invoked when the user (or agent) needs to do anything GPU-related (provision, connect, check status, check cost, terminate) in a project where Rockie's GPU router is bypassed in favor of the user's own setup. Reads `.claude/gpu-custom.md` (populated by /gpu-custom-setup) for the user's documented flow and follows it. Replaces the deidentified `rockie-gpu` surface and /gpu-spend in custom mode — those route to gpu.py which exits gracefully when ROCKIE_GPU_MODE is not 'router'. If `.claude/gpu-custom.md` doesn't exist, redirect to /gpu-custom-setup first.

Manage swappable operational overlays on top of the central taste corpus. A mode is a small TOML file capturing how *this session's* policy differs from the researcher's stable identity — hardware preferences, budget ceilings, reading focus, scope-lock, subagent model policy, output register, deadlines. The active mode is loaded into every SessionStart alongside taste/INDEX.md. Triggers on `/mode show`, `/mode list`, `/mode switch <name>`, `/mode new <name>`, `/mode edit <name>`, `/mode diff <a> <b>`.

When the user (or you) needs to know GPU spend — "what's my burn rate?", "how much have I spent this week?", "is anything still running?", "am I close to budget?", "what's running idle?" — invoke this. Wraps `rockie-gpu spent --json` (the deidentified Rockie-GPU spend surface) for accurate, reconciled numbers, then summarizes for the user. `rockie-gpu` is the single GPU surface: it never names the underlying compute supplier and never exposes a supplier API key. **Custom-mode users:** if `ROCKIE_GPU_MODE=custom`, invoke `/gpu-custom` instead — `rockie-gpu` is bypassed in that mode.

Continuous-operation mode for rockie — runs the experiment queue autonomously, using Zero-Cost Monitoring ($0 LLM cost during training), anti-burn exponential cooldown on failures, and ntfy to wake the human only when a decision is needed. Use when you want agent-driven research to proceed for days without human input. Not appropriate for unproven projects — only enable after you have a populated queue, budget ceilings, and a working launcher.

Package a harness-level improvement (a new hook, a fixed script, an improved skill) as a reviewed, verified patch — optionally openable as a PR against the rockie upstream repo. Uses Generator/Verifier/Updater role separation so the proposing agent never auto-commits; a fresh-context verifier plus the smoke test must agree, and the human signs off before anything is written to the user's rockie checkout or pushed anywhere. Triggers when the user says "upstream that", "propose a harness change", "write a PR for rockie", or when a recent `[LEARN harness-upstream]` block is waiting.

Deploy a multi-agent team on a hard, multi-dimensional problem where several aspects need simultaneous optimization and trade-offs between them, or to shape the thinking behind a non-obvious architectural choice, or to examine work you've already done from multiple distinct perspectives. This is for throwing compute at genuinely hard problems — not for parallelism. Each agent has its own motivation, runs in an isolated git worktree, coordinates with the others via a shared thread, and is observable through a live dashboard the developer can intervene in. NOT for fire-and-forget parallelism — use the native Agent tool when one specialist can answer.

Dispatch a small team of Claude agents to think through a problem in parallel and return a combined report. Use for research gauntlets (brainstorm / research / attack / validate), pre-launch code audits (security / correctness / simplicity), post-run analysis (positive / adversarial / contextualizer), or blog-coherence audits. Local only — uses Claude Max subscription, no API key, no GPU. Triggers on "deploy a team", "run the gauntlet", "get multiple perspectives on", "audit this before running", "throw agents at this".

After an experiment finishes, structured review emits {is_bug, failure_class, summary, metric, lower_is_better}, auto-closes the journal node, emits a [LEARN] block when is_bug=true, and files a [DEAD-END] when the failure_class is "bad-hypothesis". Use immediately after any training/eval run — the agent invokes this without user prompt as the last step of the Assess phase.

Refill the experiment queue when it drops below target (default 5 pending items). Brainstorms 3–5 new high-quality experiments informed by recent [LEARN] rules, killed dead-ends, best-so-far results, and hypothesis-calibration drift. Use when `queue.py refill-needed` returns non-zero, when the user asks "what should we try next", or as a scheduled task between GPU-bound runs.

Persistent notes a scheduled/recurring agent reads as its FIRST action and writes as its LAST action, so a weekly/nightly autonomous run "knows where it left off." Use inside /loop or /schedule tasks that span multiple wake-ups. Pairs with hypothesis calibration and the experiment queue.