The suite.

The Dojo Protocol for Claude Code: ten rules at session start, a scout→contract→build→verify spine, and role agents pinned to the right model.

Components

• Hook: hooks/session_start.py (SessionStart) adds the ten rules to the session's context; a project's ./DOJO.md replaces the text
• Agents: dojo-protocol:scout (haiku), dojo-protocol:builder (sonnet), dojo-protocol:reviewer (sonnet), dojo-protocol:judge (opus)
• Skills: protocol, scout-first, contract, refute, delegate
• Output style: status-and-path (a status line first; big deliverables go to a file and come back as a path)

Install

In Claude Code

/plugin install dojo-protocol@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_PROTOCOL_OFF=1. A project's ./DOJO.md replaces the text.

Deterministic guards for the mistakes that waste a day: blanket staging, rewriting pushed commits, printing secrets, oversized reads, silent probes.

Components

• Skill: gates (what each guard does, the ids, the overrides)
• Hooks: the guards listed below, each with an id

Guards

• staging refuses blanket staging (git add with -A, --all or a dot, and git commit -a) and suggests explicit paths
• pushed-rewrite refuses amend, rebase, hard reset and force-push when the commits are already on a remote; allows them when they aren't
• secret-print refuses commands that print secret-shaped environment variables or read .env files
• token-url refuses token-shaped strings inside URLs and arguments to git and curl
• big-read refuses a whole-file read of a large file and suggests grep or an offset and limit
• mac-timeout on macOS, refuses the timeout command when it isn't installed and says the fix
• masked-exit warns when a test or build piped into tail, head or grep is followed by a commit or push, because the pipe hides the exit code
• config-first after a 401, a refused connection or a missing command, adds a note to check env, settings and credentials before logic (once per session per pattern)
• empty-probe after a search or probe that printed nothing, adds a note: prove it can see a known positive before trusting the negative (once per session)
• claude-md-reach off by default (the claude_md_reach setting turns it on); when enabled, denies the first edit under a directory whose nearest CLAUDE.md was never loaded this session, once, and names the file to read

Install

In Claude Code

/plugin install dojo-gates@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_GATES_OFF=1. Skip single guards with DOJO_GATES_SKIP=<id>,<id>.

No subagent silently inherits your most expensive model. Warns or blocks unpinned dispatches; the mod routes them by role.

Components

• Hook: hooks/agent_model.py (PreToolUse on Agent and Task) warns, or blocks in block mode, when a subagent names no model
• Hook: hooks/workflow_models.py (PreToolUse on Workflow) lists workflow agents that name no model
• Mod: hooks/register.ts fills in the model by role and shows the routed model in the status line
• Skill: router (the role table, and how to set model on a call and in a workflow)
• Settings: mode, default_tier, explore_tier, auto_route, opus_cap

Install

In Claude Code

/plugin install dojo-router@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_ROUTER_OFF=1. The mode setting takes warn, block or off; auto_route turns the mod's routing off.

early access Mod: early access. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1); the classic hooks above work without them.

See what each turn, agent and model costs, and how big your context is: a cost report from your transcripts, and a live band with the mod.

Components

• Command: /dojo-meter:cost reads your transcripts and prints a table by model and by main thread versus subagents. It's an estimate at list prices; unknown models show as unpriced, never as zero
• Mod: hooks/register.ts keeps a live band (session estimate, context size, cache-read share) and warns near a budget or a large context
• Command: /dojo-meter:band toggles the band
• Settings: show_band, budget_usd, context_warn_tokens

Install

In Claude Code

/plugin install dojo-meter@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_METER_OFF=1. The show_band setting hides the band.

early access Mod: early access. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1); the /dojo-meter:cost command above works without them.

"Done" means a check ran and passed in this session. Flags claims of success with no evidence behind them.

Components

• Hook: hooks/stop_evidence.py (Stop) blocks a final message that claims success when no check has passed since your last edit, and never blocks twice in a row
• Skill: evidence (a report is a claim; load the real page after a deploy; empty output isn't evidence)
• Mod: hooks/register.ts shows an UNVERIFIED status and a dispatched, returned and failed tally for agents
• Settings: mode, show_status, toast_unverified

Install

In Claude Code

/plugin install dojo-verify@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_VERIFY_OFF=1. The mode setting takes block, warn or off; show_status and toast_unverified quiet the mod.

early access Mod: early access. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1); the classic hooks above work without them.

Parallel builds that stay independent: a contract gate, scouts on small models, builders in the middle, judges at the ends, and a scorecard that counts returns.

Components

• Workflow: build runs Contract, Scout, Advise, Build, Integrate and Audit; its Contract phase refuses tracks that overlap
• Workflow: converge runs audit lenses, adversarial verification of each finding, optional fixes and a gate
• Commands: /dojo-flow:build, /dojo-flow:converge
• Skill: dag-plan (how to cut a goal into independent tracks, and report returns instead of dispatches)
• Script: scripts/dag_ops.py (validate, width, critical path, cone)

Install

In Claude Code

/plugin install dojo-flow@dojo-genesis

Kill switch

No hooks. Nothing runs unless you call it. To turn it off, disable or uninstall it with /plugin.

Find the hooks and settings that fail or cost you silently: broken interpreters, noisy injections, always-on token weight, flags that are off.

Components

• Command: /dojo-doctor:check runs scripts/doctor.py, which only reads. It never runs your hook commands
• Sections: interpreters, hook failures in recent transcripts, injection weight, always-on weight (an estimate), the function-hooks flag, the python3 version
• Skill: doctor (when to run it, how to read it)

Install

In Claude Code

/plugin install dojo-doctor@dojo-genesis

Kill switch

No hooks. Nothing runs unless you call it. To turn it off, disable or uninstall it with /plugin.

Settle claims with evidence: pre-registered experiments, with/without baselines and decision gates before anything becomes a number.

Components

• Skills: settle, decision-gate, eval-kit
• Script: scripts/prereg.py writes a pre-registration file with a hash of the decision rule, and verifies it later
• Templates: templates/case.yaml, templates/prereg.md. They are scaffolds; the with/without eval hasn't been run

Install

In Claude Code

/plugin install dojo-settle@dojo-genesis

Kill switch

No hooks. Nothing runs unless you call it. To turn it off, disable or uninstall it with /plugin.

See every subagent of a fan-out live, steer one mid-flight, and catch stalls by their writes, not their word.

Components

• Mod: hooks/register.ts tracks every subagent from its spawn, its tool calls and its turn ends; runs the stall check and the commands
• Mod: hooks/views.tsx draws the Fleet pane, a band above the prompt with one chip per agent, and an agent bar
• Mod: hooks/model.ts holds the rules, with no engine calls: stall reasons, writer detection, rows, chips and the nudge text
• Commands: /fleet, /fleet list, /fleet engine, /steer <#n or name> <message>; they run at once, even while a turn is in flight
• Stall check: a running agent is flagged when it has made no tool call for stall_minutes, when a tool call has not returned in that time, or, for an agent whose brief asks it to write, when it has written nothing in that time. It judges what an agent does, never what it says, and an agent waiting on running agents of its own is not flagged
• Waiting: an agent that ends a turn but is still held by the engine, parked on background work of its own, is shown as waiting, not done
• Nudge: sends the agent one check-in; if it stalls again, the pane says to stop it and build that track inline
• Settings: stall_minutes (default 10; 0 turns stall checks off), show_band, stall_toast

Install

In Claude Code

/plugin install dojo-fleet@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_FLEET_OFF=1. Either one makes the mod a pass-through: no tracking, band, pane or commands. The show_band setting hides the band.

Honest limits

• Writer detection reads the brief: one that asks to edit, write, implement or fix makes a writer; one that says to write nothing does not. An agent that writes anyway becomes a writer from its first write
• Stall checks run every 15 seconds, so a flag can arrive up to that long after the threshold; the pane's ages are as of the last tick
• An agent the mod never saw spawn (one started before the mod loaded) is listed under a short id until it is seen again
• Agents a workflow script starts are tracked, but the engine does not list them, so they are never marked ended for being absent from that list
• Stop goes through the normal permission check for the stop tool

early access Mod only: early access, shipping with 2.1.0. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) and has no classic hooks; without them its command only says the mod is not running.

Two agents writing one file clobber each other: the first writer holds the file while it runs, a second running agent is refused, and fan-outs get the shared contract.

Components

• Mod: hooks/register.ts claims and releases lanes, refuses a second writer, adds the contract note and answers /lanes
• Lanes: the first subagent to write a file (Edit, Write, NotebookEdit) holds it as its lane while it runs; another running subagent's write to it is refused, and the refusal tells it to put the change in its report. The main thread is never refused; a main-thread write into a held lane is logged once
• Release: a lane is released when its agent is done. An agent that ends a turn but is still held by the engine keeps its lanes until the engine says it is done
• Contract note: when a subagent is spawned and a contract file exists, or another writing agent is already running, a short note is added to its brief: where the shared decisions are, and that files it writes first become its lane. Two or more writing agents in flight with no contract file raise one toast per wave (rule 4)
• Command: /lanes lists each agent, its state and the files it holds, then the contested writes
• Settings: mode, attach_contract, contract_paths

Install

In Claude Code

/plugin install dojo-lanes@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_LANES_OFF=1. Either one makes the mod a pass-through. The mode setting takes lock (refuse a second writer), warn (let it through and log) or off (only record).

Honest limits

• Paths are compared as written, after resolving relative paths and dots. Letter case and symbolic links are not resolved, so two spellings of one file on a case-insensitive disk are two lanes
• Only the file tools are watched. A shell command that writes a file is not seen
• A lane is held per file, not per region of a file
• Agents a workflow script starts hold lanes like any other, but the engine does not list them, so their lanes are released only by their own turn end
• The guard fails open: if it cannot decide, the write goes through

early access Mod only: early access, shipping with 2.1.0. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) and has no classic hooks; without them its command only says the mod is not running.

Count returns, not dispatches: when a fan-out settles, the model hears what came back (returned, failed, silent, unchecked), and /tally refute sends a report to a judge.

Components

• Mod: hooks/register.ts opens waves, classifies each agent, adds the settle note and answers /tally and /tally refute
• Waves: the first spawn opens a wave; every agent spawned while it is open joins it; it settles when every member is done. An agent that ends a turn but is still held by the engine is waiting, not returned
• Classification, first match wins: failed (an error, a refusal, an interrupt, an empty answer, or an agent the engine stopped); silent (a clean verdict from an agent that looked at nothing); unchecked (a claim of a passing check from an agent that ran no shell command); returned (everything else)
• Settle note: when a wave of min_wave or more agents settles, one toast, and one note added to the main conversation for the model to read: the counts and every agent that did not simply return
• Commands: /tally (the open wave and the last settled ones, one row per agent: outcome, work, how long it lived), /tally refute <n> (sends agent n's report to the protocol's judge agent, or a general-purpose agent when the judge is not installed; the verdict is added to the conversation)
• Settings: min_wave (default 2), settle_note, judge_model

Install

In Claude Code

/plugin install dojo-tally@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_TALLY_OFF=1. Either one makes the mod a pass-through. Setting settle_note to false keeps the toast and drops the note.

Honest limits

• silent and unchecked read the answer's wording: a verdict phrased in a way the patterns do not know is counted as returned
• A shell command can check anything, so an agent that ran one and claims a pass is counted as returned even when the command checked something else
• Only the last five waves are kept; /tally refute names agents by their number in the session
• The bare /refute is only a shortcut: when another plugin holds the name (dojo-protocol's refute skill does), Claude Code keeps it there; /tally refute <n> always works
• Teammates (agents that idle between messages) are not tallied
• A settle note arrives a few seconds after the last agent ends: the mod first asks the engine whether that agent is done
• A /tally refute judge runs on the model you pick and costs what that model costs

early access Mod only: early access, shipping with 2.1.0. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) and has no classic hooks; without them its command only says the mod is not running.

Lints every subagent brief at dispatch against the delegate skill: detail, owned files, done-check, return shape. A notice, or one send-back.

Components

• Mod: hooks/register.ts lints each Agent call at dispatch and answers /dojo-brief
• Checks, on every Agent call: detail (at least min_chars characters); owned files (names a file or a directory, or says which files the agent may write); done-check (says what done is and how to check it; not asked of read-only agent types); return shape (says what to send back). A fork inherits the whole conversation, so it is never linted. Model choice is left to dojo-router
• Modes: a brief that misses a field is handled by mode: notice (the dispatch goes ahead and one dim line names what is missing), sendback (the first dispatch is refused once, with the list; a second dispatch with the same description goes through), off (nothing)
• Commands: /dojo-brief puts the brief template in the prompt; /dojo-brief stats shows how many briefs were linted this session and what they missed. It is not /brief: Claude Code has its own
• Settings: lint_briefs, mode, min_chars (default 200)

Install

In Claude Code

/plugin install dojo-brief@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_BRIEF_OFF=1. Either one makes the mod a pass-through. Setting lint_briefs to false turns the lint off and keeps the command.

Honest limits

• The checks read wording, on purpose loosely: a brief that mentions a test passes the done-check even when it does not say which one. They catch the missing field, not the weak one
• A path with no extension and no backticks may not be recognised as a file
• Goal, facts and the rules carried are prose; the lint does not judge them
• The send-back is remembered per description for the session

early access Mod only: early access, shipping with 2.1.0. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) and has no classic hooks; without them its command only says the mod is not running.

See a fan-out as a timeline: one lane per agent, a mark per tool call, refusals in red, live in a pane.

Components

• Mod: hooks/register.tsx records each subagent's spawn, tool calls and end; draws the pane; answers the command
• Mod: hooks/model.ts holds the rules, with no engine calls: waves, buckets, marks and the text strips
• Mod: types/index.d.ts describes the state the drawings read
• Commands: /swimlanes opens the Swimlanes pane and answers one line, for example 3 agents in view; /swimlanes text answers the text form instead of opening a pane; /swimlanes all toggles between the latest wave and every kept agent
• Wave: the set of agents spawned since the last moment no agent was running
• Desktop, VS Code and mobile: a chart with a label column (number, label, model), a lane band from spawn to end, a mark per tool call coloured by kind (read, write, bash, agent, other) and as wide as the call lasted, a red cross for a refused or failed call, a dashed amber tail while an agent waits, an end glyph, a "now" line while agents are live, a time axis and a legend. Hover a mark for its tool, target, duration and the refusal text
• Terminal: one row per agent with a strip of time buckets: a block where a call ran, a cross for a refused or failed call, a dot for idle, a dashed glyph for waiting
• Settings: enabled (default on)

Install

In Claude Code

/plugin install dojo-swimlanes@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_SWIMLANES_OFF=1. Either one makes the mod a pass-through. The enabled setting, set off in the plugin's settings, turns the mod off for every session.

Honest limits

• While agents run, the desktop chart is a plain image (an interactive frame reloaded each second and blinked), so hover tooltips appear once the wave settles
• The terminal draws text strips, not a chart
• It keeps the last 16 agents and 200 calls each
• A ✗ marks a refused or a failed call; the chart does not tell the two apart except by the hover text

early access Mod only: early access, shipping with 2.2.0. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) outside the Claude desktop app and has no classic hooks; without them its command only says how to turn the mod on.

A tool call a Dojo guard refuses is drawn as a card: who blocked it, why, and the fix as code you can copy.

Components

• Mod: hooks/register.tsx reads a guard's refusal and draws the card; answers the command
• Mod: hooks/model.ts holds the rules, with no engine calls: reading a guard's refusal text
• Mod: types/index.d.ts describes the state the drawings read
• Cards: when a Dojo guard (dojo-gates, dojo-lanes, or a guard added later) refuses a tool call, the transcript shows a plain error; the mod draws a card instead, with the guard that blocked it, the reason, and the fix as code you can copy. Every other row is left to the engine
• The card: a bordered box with text and code, the same on every surface. For a dojo-lanes refusal it names the file and the holder instead of a fix
• Commands: /fixcards or /fixcards status says on or off, and how many cards were drawn this session; /fixcards off switches the cards off for this session; /fixcards on switches them back on
• Settings: enabled (default on)

Install

In Claude Code

/plugin install dojo-fixcards@dojo-genesis

Kill switch

DOJO_OFF=1 or DOJO_FIXCARDS_OFF=1. Either one makes the mod a pass-through. The enabled setting, set off in the plugin's settings, turns the mod off for every session.

Honest limits

• In the desktop app, tool calls sit inside a collapsed step row and the card is drawn with them, so it can only show once that row is expanded. The card has been seen in the terminal; on the desktop it is not yet confirmed
• In the terminal a folded tool group that holds a refusal is unfolded, and the raw refusal text still shows above the card (the engine ignored a rewrite of it)
• A subagent's refusal draws in that agent's own transcript
• It reads dojo-gates and dojo-lanes refusal text; an unknown guard still gets a card with its reason

early access Mod only: early access, shipping with 2.2.0. It needs function hooks (CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1) outside the Claude desktop app and has no classic hooks; without them its command only says how to turn the mod on.