Docs / Reference / What you can configureVIEW .MD

What you can configure

Generated 09/11/2026 from the kit

Every verb and every ade.toml section, generated from the kit when the site is built. The detail behind each (options, keys, defaults, examples) is the reference for owners of the kit: sign in or see how to get it. Owners also get a Troubleshooting page listing every refusal code with its cause and cure.

Commands#

Verb	What it does
`ade budget`	print core lines, hooks, refusal codes and tests against their budgets; fails when a hard row is over (component rows are notes); --refusals counts firings
`ade card`	add, list, show, hold, close, snooze and re-path cards; a card needs paths and a done line, and a recurring one opens again every N days
`ade cockpit`	the pilot's view: every open card with its state and next command, plus budgets; orca mode opens it in Orca too
`ade conduct`	walk the board through `ade loop` until no open card is left untried, one card at a time or several whose reach the graph keeps apart; route every stop by ade/route.toml, wake a model only where the route says wake. Pilots: run it as a background task, and keep working: the flight band (Claude Code) or the cockpit terminal shows each stage, and the background task's own finish is the one wake; safe because each lane builds in its own worktree and branch, tests run in a detached checkout, and land waits only if the main checkout has uncommitted edits to the very paths the card changes or if the main checkout is not on the trunk branch, so do not edit a flying card's paths and keep the main checkout on trunk
`ade config`	list ade.toml's sections, or look up every key matching a word with its effective value and template comment
`ade decide`	rulings that govern path globs, and questions for a person with a recommendation, a default and a deadline
`ade digest`	one short summary of a day: cards landed, cards parked with their open question, questions whose default applied; then any rule 7 lines (at most 3)
`ade graph`	regenerate the graph file from headers and imports, or with FILE print that file's briefing from a fresh graph; --check fails if the committed one is stale or the route has drifted
`ade handover`	generate a role's working context from records and graph; prints its token estimate, fails over budget
`ade hook`	Claude Code hook entry: brief (first-edit briefing, protected paths), bash (the guard), read (secret Read/Grep under tracked: secret_ok), grep (graph notes on search output), turn-end (holds), start (handover)
`ade init`	start a new project in an empty folder, or install or refresh ADE in a repo from ade.toml; idempotent, --dry-run prints the diff
`ade land`	land a card whose lane tree has an approved review and passing tests: merge, verdict, outcome
`ade link`	make a plain `ade` work in new shells: one small launcher named ade in a per-user folder already on PATH
`ade loop`	drive a card through lane, build, review, test, land; journal each stage, stop at the first non-advance. Pilots: run it as a background task, and keep working: the flight band (Claude Code) or the cockpit terminal shows each stage, and the background task's own finish is the one wake; safe because the lane builds in its own worktree and branch, tests run in a detached checkout, and land waits only if the main checkout has uncommitted edits to the very paths the card changes or if the main checkout is not on the trunk branch, so do not edit a flying card's paths and keep the main checkout on trunk
`ade parts`	list the parts catalogue with each part's state; `set x=off` (or `x=on`) switches one in ade.toml and prints what it costs
`ade push`	push trunk, ade-records and checkpoint tags to the remote (under [git] push = "pr", only ade-records and tags, never trunk or its mirrors); fast-forward only, never forced; waits for .ade/land.lock (a landing in progress) first; --dry-run asks the remote without pushing
`ade q`	keep long output out of a model's context: run a command through the store, page or grep what it kept, query it
`ade rehearse`	one full loop per config option on throwaway repos with the fake provider; reports calls, wall time and refusals
`ade session`	run an ade verb detached from this terminal (no tmux, any platform), list sessions live or ended, follow one, stop one
`ade setup`	a terminal panel to switch the kit's parts on and off; shows the ade.toml diff first, saves through parts.rewrite; a numbered list when there is no terminal or NO_COLOR is set
`ade status`	one-line state for the Claude Code status line: repo, open cards, last stage outcome
`ade telemetry`	show usage per card and per provider for the week, each week meter against its share; export OTLP files locally
`ade uninstall`	remove everything `ade init` generated (hooks, rules, agents, AGENTS.md block, graph); keep ade.toml and records
`ade wait`	wait for a condition with a bound (exit 0 met, 3 stage parked, 4 bound passed, 5 lane stalled); run it in the background to be told; `stage` is a condition for a pilot that needs to block on one stage
`ade watch`	follow a card's lane log live (any platform, no tmux) until its loop stops or the log goes quiet; --once prints it

ade.toml sections#

Section	What it is for
`[git]`	How ADE uses git: trunk, pushing and pull requests.
`[tests]`	How a project's tests are run, found for a change and retried when they fail.
`[lanes]`	How each card's separate checkout gets the folders it needs without installing them again.
`[rigour]`	Which paths get the full test suite and which paths land without review.
`[graph]`	How ADE maps the code, its tests and its docs, and what it requires of each changed file.
`[guards]`	Which secret files and which shell commands the guards refuse to read or write.
`[protected]`	The paths an agent may not edit, and what it is told to do about them instead.
`[land]`	Which changes wait for a person's answer before they land.
`[budgets]`	The size limits that keep the kit and its briefings small.
`[budgets.components]`	How the core code's line budget is divided among named components.
`[providers.claude]`	How ADE starts Claude Code for a role, and what that call may inherit from the host.
`[providers.codex]`	How ADE starts Codex for a role, and how its rights and reasoning effort are set.
`[providers.opencode]`	How ADE starts opencode for a role, so any model it can reach can do the work.
`[providers.pi]`	How ADE starts Pi for a role, reading its JSON event stream for the answer and usage.
`[review]`	How a lane's diff is reviewed, and by which engine.
`[conduct]`	How ADE's conductor routes stops, waits and parks a card, and how much it may spend in a day or week.
`[cards]`	How long a drafted card waits for a veto before it flies.
`[watch]`	How long a lane may go silent before the watcher calls it stalled.
`[q]`	How long output is stored and how much of it is shown in full or as a short excerpt.
`[cockpit]`	Which view shows the lanes while the board runs: the terminal alone or a mirror in another app.
`[report]`	Whether each engine call records the seat it ran with in its lane log.
`[usage]`	How ADE measures and prints each provider's share of the week and the plan behind it.
`[roles.pilot]`	The pilot role: who flies the board, which engine and model it uses and what it may touch.
`[roles.builder]`	The builder role: who builds one card, which engine and model it uses and what it may touch.
`[roles.reviewer]`	The reviewer role: who reviews one lane's diff, which engine and model it uses and what it may touch.
`[parts]`	Which optional parts of the kit are switched off in this project.
`[parts.override]`	The reasons a project went past a warning about a part.
`[permissions]`	The permission modes ADE writes for your own sessions and for the lanes.
`[permissions.allow]`	The commands agents may run without asking, each with its reason.
`[permissions.deny]`	The reads and commands agents are never allowed, each with its reason.