Commands

Every codeloop command and flag, generated from the CLI help output.

Generated from codeloop --help and every <command> --help at build time by site/scripts/gen-commands.mjs. codeloop 0.4.1. Nothing on this page is typed by hand, so a flag listed here is a flag the CLI has.

All commands

init Initialize codeloop in the current project
update Update codeloop skills to latest version
status Show codeloop status and knowledge stats
serve Start the visual board server
store The store under the board: which driver, which migrations have run
watch Watch project for changes, track progress on the board
lane Inspect, check and change lanes
card Create and move cards through a lane
start Start a card: `codeloop start "<title>"` (same as card new, plus its spec folder)
shape Turn a problem into an epic of shippable stories: brief → interview → breakdown → rank, then queued into the build lane
next Run the check for a card and move it on (same as card advance); with one active card the id is optional
approve Approve the gate a card is waiting at (same as card approve)
reject Reject with a note: `codeloop reject <id> "<what to change>"`
inbox What needs you, what shipped, and the numbers per lane
feature Features: the capabilities stories roll up to, scored by RICE
epic Epics: outcomes that take several features
initiative Initiatives: the goals the roadmap rolls up to
ask Ask the owner up to 5 questions about a card: `codeloop ask <card> "<question>" --recommended "<answer>"`, or --file with `## Q1` blocks
answer Answer a question on a card: `codeloop answer <card> <n> "<text>"`, or `--accept` to take the recommended answer
run Start cards for due cron lanes, then advance every card that is not waiting for you until it stops on its own
brief Print what an agent is given to do a card's current stage: skill, output, check, feedback, wiki pages, rules
schedule Run `codeloop run --agent` in this repo on a schedule, from your crontab
adopt Index the skills and commands that already exist so lanes can name them; merges into the index unless --replace
check Done-check helpers for lane stages
pack Package lanes and their skills
spec A card's spec folder: research, spec, plan, tasks
mock A card's mock, built from the shared template so every mock looks like the same product
mocks The mock gallery
artifact A card's artifact, mock, system design, or workflow, built from the shared templates so every artifact looks like the same product
artifacts The artifact gallery: mocks, system designs and workflows, grouped by kind, topic and lineage
scan Look outside the repo for what to build next
task Tasks in a spec folder
import Bring existing specs in as cards; source files are only read
verify Run the use cases for a card and write evidence. Exit 2: nothing to verify, or an acceptance line has no use case; 1: a use case failed; 4: --mutate found one that cannot fail; 5: --mutate could not run
stats Autonomy numbers computed from card events
wiki Gotchas, decisions and concepts that agents read before a stage and write after it
learn Apply frequency thresholds: critical at critical_frequency, promoted to rules.md at promote_frequency
render Write each lane stage as an agent, rule or skill for Claude, Cursor and Codex, plus the standing protocol block and, with --hooks, the hooks that enforce it
mcp Serve the card engine over MCP on stdio (tools: inbox, next_up, get_card, advance, approve, reject, task_done, wiki_inject, wiki_capture)
gate Gate checks for CI
config Read .codeloop/config.yaml, with .codeloop/local.yaml laid over it
cloud Optional: keep the board, wiki, config and lanes in a Protobox workspace as well as in the repo
guard Hooks that enforce the codeloop protocol regardless of what the chat says
presence Presence files Cursor session hooks write under .codeloop/state/presence/ (serving this over HTTP as GET /api/presence is not built yet)
whoami This repo's active card, your git identity and role, and who else is present (from Cursor session hooks)
install Install a skill from the registry, GitHub, or local path
search Search for skills in the registry
list Show installed skills
remove Uninstall a skill
publish Publish a skill to the registry (validate locally with --dry-run)
login Authenticate with the skill registry (check status with --status)
skill Skills (templates/skills/) and their eval fixtures

`codeloop init`

Initialize codeloop in the current project

codeloop init [options]

Option	What it does
`-s, --starter <name>`	Use a specific starter (generic, node-typescript, python, go)
`-t, --tools <tools>`	Comma-separated tools: claude,cursor,codex (skip prompt)
`--hooks`	Only install the hooks: the commit-msg trailer, the Claude Code and Cursor hooks, and the pre-commit and pre-push guards
`--ci <provider>`	Only write CI workflows (github)
`-y, --yes`	Write into an existing .claude/commands/ without asking

`codeloop update`

Update codeloop skills to latest version

codeloop update [options]

Option	What it does
`--dry-run`	Show what would change without modifying files

`codeloop status`

Show codeloop status and knowledge stats

codeloop status [options]

`codeloop serve`

Start the visual board server

codeloop serve [options]

Option	What it does
`-p, --port <port>`	Port to listen on (default: "4040")
`--bg`	Run in background
`--stop`	Stop background server
`--open`	Open browser after starting
`--owner`	Allow Approve and Reject from the board, for whoever has the URL with its token
`--ui <dir>`	Serve this static build instead of the workspace app (or set CODELOOP_UI_DIR)
`--host <host>`	Address to listen on. Anything but the default exposes the board to the network (default: "127.0.0.1")

`codeloop store`

The store under the board: which driver, which migrations have run

codeloop store [options] [command]

`codeloop store status`

Show the driver in use and the migrations applied and pending

codeloop store status [options]

Option	What it does
`--json`	JSON output

`codeloop store migrate`

Apply the pending migrations and record them in .codeloop/store.json

codeloop store migrate [options]

`codeloop watch`

Watch project for changes, track progress on the board

codeloop watch [options]

Option	What it does
`--with-serve`	Also start the board server
`--stop`	Stop background watcher
`--bg`	Run in background
`--guard`	Append a warning to .codeloop/state/warnings.jsonl when files change with no active card

`codeloop lane`

Inspect, check and change lanes

codeloop lane [options] [command]

`codeloop lane list`

List lanes

codeloop lane list [options]

`codeloop lane show`

Show one lane

codeloop lane show [options] <id>

Option	What it does
`--json`	JSON output

`codeloop lane lint`

Check every lane; exits 2 on any error

codeloop lane lint [options]

`codeloop lane propose`

Write lane-change proposals from repeated rejections and stuck stages

codeloop lane propose [options]

`codeloop lane eval`

Lint, fixture-test and replay a proposal; writes eval-result.json

codeloop lane eval [options] <proposal>

`codeloop lane promote`

Install an evaluated proposal as the live lane

codeloop lane promote [options] <proposal>

Option	What it does
`--as <role>`	owner \| reviewer \| agent

`codeloop lane rollback`

Restore the previous version of a lane

codeloop lane rollback [options] <lane>

Option	What it does
`--as <role>`	owner \| reviewer \| agent

`codeloop card`

Create and move cards through a lane

codeloop card [options] [command]

`codeloop card new`

Create a card in the first stage of a lane

codeloop card new [options] <lane> <title>

Option	What it does
`--id <id>`	Card id (default: next c-NNN)
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)
`--persona <persona>`	Who the story is for: founder, builder, reviewer, dev, visitor, team or a persona from config.yaml
`--can <what>`	The "I can" part of the story
`--so <outcome>`	The "so that" part of the story
`--size <size>`	S (hours), M (a day or two) or L (split it)
`--points <n>`	Story points: 1, 2, 3, 5 or 8
`--initiative <initiative>`	The initiative this card serves
`--epic <card-id>`	The parent card this one was split from
`--feature <feature>`	The capability this card is a slice of
`--effort <weeks>`	Weeks; replaces the feature's effort in this card's RICE score
`--metric <metric>`	The one stage metric this card moves
`--ticket <key>`	Tracker key, like ACME-412; a title starting "ACME-412: " sets it too
`--force`	Create it even though the title or story fails the standard

`codeloop card propose`

Propose a card: it waits in the inbox until the owner promotes it with `codeloop approve`, and nothing starts it

codeloop card propose [options] <lane> <title>

Option	What it does
`--id <id>`	Card id (default: next c-NNN)
`--description <text>`	What was seen, for the owner deciding
`--source <url or path>`	Where it came from
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)
`--persona <persona>`	Who the story is for: founder, builder, reviewer, dev, visitor, team or a persona from config.yaml
`--can <what>`	The "I can" part of the story
`--so <outcome>`	The "so that" part of the story
`--size <size>`	S (hours), M (a day or two) or L (split it)
`--points <n>`	Story points: 1, 2, 3, 5 or 8
`--initiative <initiative>`	The initiative this card serves
`--epic <card-id>`	The parent card this one was split from
`--feature <feature>`	The capability this card is a slice of
`--effort <weeks>`	Weeks; replaces the feature's effort in this card's RICE score
`--metric <metric>`	The one stage metric this card moves
`--ticket <key>`	Tracker key, like ACME-412; a title starting "ACME-412: " sets it too
`--force`	Create it even though the title or story fails the standard

`codeloop card show`

Show a card, its current stage brief and its events

codeloop card show [options] <id>

Option	What it does
`--json`	JSON output

`codeloop card list`

List cards; dropped proposals are hidden unless --all

codeloop card list [options]

Option	What it does
`--json`	JSON output --lane <lane> --stage <stage> --initiative <slug> --epic <slug> --feature <slug>
`--band <band>`	P1, P2, P3 or P4 --persona <persona>
`--size <size>`	S, M or L --points <n>
`--all`	Include dropped proposals

`codeloop card migrate-stories`

Fill the story fields of proposals whose description is written as `As a X, I can Y, so that Z. Initiative: W · S · metric: M`

codeloop card migrate-stories [options]

`codeloop card migrate-features`

Set `feature:` and its initiative on each card a mapping file names (default .codeloop/migrations/features.yaml); an unknown feature refuses the run

codeloop card migrate-features [options] [mapping]

`codeloop card run`

Run the current stage: its check, the agent when the check fails, then one advance; waits for the run and prints its log

codeloop card run [options] <id>

Option	What it does
`--agent <name>`	The agent to start (default: agents.default, or the one configured)
`--json`	JSON output: the final run record

`codeloop card output`

Print the current stage's output file, or write it from a file (`-` for stdin)

codeloop card output [options] <id> [file]

Option	What it does
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)

`codeloop card split`

Split a card into siblings under the same feature, one per title; each is marked split_from

codeloop card split [options] <id> <titles...>

Option	What it does
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)

`codeloop card advance`

Run the current stage's check and move the card if it passes

codeloop card advance [options] [id]

Option	What it does
`--event <name>`	Report the event a stage with `done.event` is waiting for

`codeloop card approve`

Approve the gate a card is waiting at, then advance it once

codeloop card approve [options] <id>

Option	What it does
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)
`--note <note>`	Optional note

`codeloop card reject`

Reject the gate with a note; the card stays in its stage

codeloop card reject [options] <id> [note]

Option	What it does
`--note <note>`	What to change
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)

`codeloop card activate`

Mark a card as the active one in this repo; the guard hooks, the MCP server and `codeloop whoami` all read this

codeloop card activate [options] <id>

`codeloop start`

Start a card: `codeloop start "<title>"` (same as card new, plus its spec folder)

codeloop start [options] <title>

Option	What it does
`--lane <lane>`	Lane to start in (default: "build")
`--id <id>`	Card id (default: next c-NNN)
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)
`--persona <persona>`	Who the story is for: founder, builder, reviewer, dev, visitor, team or a persona from config.yaml
`--can <what>`	The "I can" part of the story
`--so <outcome>`	The "so that" part of the story
`--size <size>`	S (hours), M (a day or two) or L (split it)
`--points <n>`	Story points: 1, 2, 3, 5 or 8
`--initiative <initiative>`	The initiative this card serves
`--epic <card-id>`	The parent card this one was split from
`--feature <feature>`	The capability this card is a slice of
`--effort <weeks>`	Weeks; replaces the feature's effort in this card's RICE score
`--metric <metric>`	The one stage metric this card moves
`--ticket <key>`	Tracker key, like ACME-412; a title starting "ACME-412: " sets it too
`--force`	Create it even though the title or story fails the standard

`codeloop shape`

Turn a problem into an epic of shippable stories: brief → interview → breakdown → rank, then queued into the build lane

codeloop shape [options] <problem>

Argument	What it does
`problem`	The problem as the person stated it

Option	What it does
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)

`codeloop next`

Run the check for a card and move it on (same as card advance); with one active card the id is optional

codeloop next [options] [id]

Option	What it does
`--event <name>`	Report the event a stage with `done.event` is waiting for

`codeloop approve`

Approve the gate a card is waiting at (same as card approve)

codeloop approve [options] <id>

Option	What it does
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)
`--note <note>`	Optional note

`codeloop reject`

Reject with a note: `codeloop reject <id> "<what to change>"`

codeloop reject [options] <id> [note]

Option	What it does
`--note <note>`	What to change
`--as <role>`	owner \| reviewer \| agent (default: owner at a terminal, agent otherwise)

`codeloop inbox`

What needs you, what shipped, and the numbers per lane

codeloop inbox [options]

Option	What it does
`--json`	JSON output
`--seen`	Mark everything shipped so far as seen
`--by <order>`	score (highest RICE first, then oldest) or age (oldest first) (default: "score")

`codeloop feature`

Features: the capabilities stories roll up to, scored by RICE

codeloop feature [options] [command]

`codeloop feature new`

Create .codeloop/wiki/features/<slug>.md

codeloop feature new [options] <slug>

Option	What it does
`--title <title>`	What the user can now do
`--initiative <slug>`	The initiative it serves
`--epic <slug>`	The epic it belongs to
`--status <status>`	planned, active, done (default: "planned")
`--release <tag>`	Target release tag, or next
`--body <text>`	A line or two on the capability
`--reach <n>`	How many users it touches, 1–10
`--impact <n>`	How much it moves the initiative metric, 1–10
`--confidence <n>`	How sure the estimates are, 1–10
`--effort <weeks>`	Weeks of work

`codeloop feature list`

Every feature with its score and band, highest first

codeloop feature list [options]

Option	What it does
`--json`	JSON output --initiative <slug> --epic <slug>
`--band <band>`	P1, P2, P3 or P4

`codeloop feature score`

Set the RICE on a feature; the score and band are derived on every read

codeloop feature score [options] <slug>

Option	What it does
`--reach <n>`	How many users it touches, 1–10
`--impact <n>`	How much it moves the initiative metric, 1–10
`--confidence <n>`	How sure the estimates are, 1–10
`--effort <weeks>`	Weeks of work

`codeloop epic`

Epics: outcomes that take several features

codeloop epic [options] [command]

`codeloop epic new`

Create .codeloop/wiki/epics/<slug>.md

codeloop epic new [options] <slug>

Option	What it does
`--title <title>`	The outcome, phrased as what becomes true
`--initiative <slug>`	The initiative it serves
`--status <status>`	planned, active, done (default: "planned")
`--goal <goal>`	The target and when
`--body <text>`	A line or two on the outcome

`codeloop epic list`

Every epic with its score: the sum of its features

codeloop epic list [options]

Option	What it does
`--json`	JSON output --initiative <slug>

`codeloop initiative`

Initiatives: the goals the roadmap rolls up to

codeloop initiative [options] [command]

`codeloop initiative list`

Every initiative with its score: the sum of its features

codeloop initiative list [options]

Option	What it does
`--json`	JSON output

`codeloop initiative tree`

initiative › epics › features › stories, with scores and bands

codeloop initiative tree [options] <slug>

Option	What it does
`--json`	JSON output

`codeloop ask`

Ask the owner up to 5 questions about a card: `codeloop ask <card> "<question>" --recommended "<answer>"`, or --file with `## Q1` blocks

codeloop ask [options] <card> [question]

Option	What it does
`--recommended <answer>`	The answer to take when the owner has no better one
`--file <path>`	A markdown file of `## Q<n> <question>` / `recommended:` blocks
`--as <role>`	owner \| reviewer \| agent

`codeloop answer`

Answer a question on a card: `codeloop answer <card> <n> "<text>"`, or `--accept` to take the recommended answer

codeloop answer [options] <card> <n> [text]

Option	What it does
`--accept`	Take the recommended answer
`--as <role>`	owner \| reviewer \| agent

`codeloop run`

Start cards for due cron lanes, then advance every card that is not waiting for you until it stops on its own

codeloop run [options]

Option	What it does
`--due`	Run what is due (the default; kept so older scripts still work)
`--agent [name]`	First start a headless agent on each stage whose check does not pass yet (an entry under agents: in config.yaml)
`--no-agent`	Only check and advance, even when config.yaml has run.agent: true
`--lane <id>`	Only this lane: its trigger and its cards; the other lanes' due slots are kept for the next full run
`--card <id>`	Only this card; no lane trigger fires
`--dry-run`	Print what would run; start nothing and change nothing
`--now <iso>`	Treat this as the current time
`--json`	JSON output

`codeloop brief`

Print what an agent is given to do a card's current stage: skill, output, check, feedback, wiki pages, rules

codeloop brief [options] <card>

Option	What it does
`--out <file>`	Write the brief to a file

`codeloop schedule`

Run `codeloop run --agent` in this repo on a schedule, from your crontab

codeloop schedule [options] [command]

`codeloop schedule install`

Add (or replace) this repo's crontab entry

codeloop schedule install [options]

Option	What it does
`--every <interval>`	5m, 10m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 12h or 24h (default: "30m")
`--cron <expr>`	A five-field cron expression, in place of --every
`--agent <name>`	Agent to run (default: agents.default)
`--print`	Print the crontab line and change nothing

`codeloop schedule remove`

Remove this repo's crontab entry

codeloop schedule remove [options]

`codeloop schedule status`

Show the installed entry and the end of the last run's output

codeloop schedule status [options]

`codeloop adopt`

Index the skills and commands that already exist so lanes can name them; merges into the index unless --replace

codeloop adopt [options]

Option	What it does
`--from <dir...>`	Directories to scan (default: .claude/skills, .claude/commands, .cursor/commands, .agents/skills in the project, and ~/.claude/skills, ~/.claude/commands)
`--replace`	Rebuild the index from the scan alone, dropping entries from other directories
`--gaps`	List lane stages with no mechanical done check

`codeloop check`

Done-check helpers for lane stages

codeloop check [options] [command]

`codeloop check file`

Exit 1 unless the file exists, is not empty, and contains every --has string

codeloop check file [options] <path>

Option	What it does
`--has <str...>`	Strings the file must contain

`codeloop check gotchas`

Exit 1 while a critical wiki page applies to these files and has not been acknowledged

codeloop check gotchas [options]

Option	What it does
`--files <path...>`	Changed files
`--ack <title...>`	Titles of critical pages that were read and handled (default: [])

`codeloop check research`

Exit 1 unless the card's research.md has a `verdict:` line and enough `- source: <url> — <note>` lines

codeloop check research [options] <card>

Option	What it does
`--min-sources <n>`	How many source lines are required (default: "3")
`--online`	Also require each source URL to answer with 2xx or 3xx

`codeloop check mock`

Exit 1 unless the card's mock is built from the shared template, keeps its tokens, uses no other colours and draws every screen the spec names

codeloop check mock [options] <card>

`codeloop check artifact`

Exit 1 unless the card's artifact (mock, system-design or workflow) meets its kind's anatomy: tokens, dark mode, no raw colour, valid mermaid, and every frame/layer/flow/actor the frontmatter names

codeloop check artifact [options] <card>

Option	What it does
`--kind <kind>`	mock \| system-design \| workflow, auto-detected from whichever artifact exists for the card when omitted

`codeloop check story`

Exit 1 unless the card meets the story standard: a title saying what the user can do, a three-part story, a known persona and a size

codeloop check story [options] <card>

`codeloop check brief`

Exit 1 unless the card's shape brief has problem:, users: and exists: filled in, and at least 3 `- source:` lines

codeloop check brief [options] <card>

`codeloop check breakdown`

Exit 1 unless the card's shape breakdown has a hypothesis and a metric, at most 7 stories, and every story sized S or M with an exists: verdict, a real done_when and only backward depends_on

codeloop check breakdown [options] <card>

Option	What it does
`--ranked`	Also require a `rice:` part on every story

`codeloop check questions`

Exit 1 unless the card's interview has at least --min questions and every one of them has an answer

codeloop check questions [options] <card>

Option	What it does
`--min <n>`	Questions the interview must hold (default: "1")

`codeloop pack`

Package lanes and their skills

codeloop pack [options] [command]

`codeloop pack build`

Compile lanes and the skills they name into a Protobox skills-only manifest

codeloop pack build [options]

Option	What it does
`--out <file>`	Output file (default: "dist/pack.json")
`--pack-version <version>`	Manifest version (default: "1.0.0")

`codeloop spec`

A card's spec folder: research, spec, plan, tasks

codeloop spec [options] [command]

`codeloop spec new`

Create specs/<nnn>-<slug>/ from the templates and record it on the card

codeloop spec new [options] <card-id>

Option	What it does
`--as <role>`	owner \| reviewer \| agent

`codeloop spec check`

Exit 2 unless every task is tagged and every acceptance line has a task

codeloop spec check [options] <nnn>

`codeloop mock`

A card's mock, built from the shared template so every mock looks like the same product

codeloop mock [options] [command]

`codeloop mock new`

Create docs/mocks/<project>/<topic>/<card-id>.html from templates/mock/template.html

codeloop mock new [options] <card>

Option	What it does
`--topic <topic>`	Folder the mock is filed under, e.g. exports
`--from <card-id\|latest\|none>`	The mock to build on: a card id, the newest in this topic, or none for the bare template (default: "latest")

`codeloop mocks`

The mock gallery

codeloop mocks [options] [command]

`codeloop mocks index`

Write docs/mocks/index.html: projects, then topics, then cards, newest first

codeloop mocks index [options]

`codeloop artifact`

A card's artifact, mock, system design, or workflow, built from the shared templates so every artifact looks like the same product

codeloop artifact [options] [command]

`codeloop artifact new`

Create docs/artifacts/<project>/<topic>/<card-id>-<kind>.html from templates/artifacts/<kind>/template.html. `--kind mock` is the same engine as `codeloop mock new`: it writes docs/mocks/<project>/<topic>/<card-id>.html instead.

codeloop artifact new [options] <card>

Option	What it does
`--kind <kind>`	Which artifact to create: mock \| system-design \| workflow
`--topic <topic>`	Folder the artifact is filed under, e.g. board
`--from <card-id\|latest\|none>`	The artifact to build on: a card id, the newest of this kind in this topic, or none for the bare template (default: "latest")

`codeloop artifacts`

The artifact gallery: mocks, system designs and workflows, grouped by kind, topic and lineage

codeloop artifacts [options] [command]

`codeloop artifacts index`

Write docs/artifacts/index.html: kind, then project, then topic, then cards, newest first

codeloop artifacts index [options]

`codeloop scan`

Look outside the repo for what to build next

codeloop scan [options] [command]

`codeloop scan competitors`

Compare each competitor page's changelog with the last scan and propose one plan card per competitor that shipped something new

codeloop scan competitors [options]

Option	What it does
`--from-file <path>`	Use this file as the changelog text instead of fetching the URL
`--only <name>`	Scan one competitor

`codeloop task`

Tasks in a spec folder

codeloop task [options] [command]

`codeloop task list`

List tasks, optionally one layer

codeloop task list [options] <nnn>

Option	What it does
`--layer <layer>`	api \| sdk \| ui \| test \| docs
`--json`	JSON output

`codeloop task done`

Tick a task

codeloop task done [options] <nnn> <task>

`codeloop task check`

Exit 1 while any task is open

codeloop task check [options] <nnn>

Option	What it does
`--all-done`	Require every task ticked

`codeloop import`

Bring existing specs in as cards; source files are only read

codeloop import [options] [command]

`codeloop import speckit`

One card per specs/NNN* feature, tasks rewritten with layer tags

codeloop import speckit [options] [dir]

Option	What it does
`--lane <id>`	Lane to create cards in (default: "build")

`codeloop import bmad`

One card per story in sprint-status.yaml, status mapped to a stage

codeloop import bmad [options] [dir]

Option	What it does
`--lane <id>`	Lane to create cards in (default: "build")

`codeloop verify`

Run the use cases for a card and write evidence. Exit 2: nothing to verify, or an acceptance line has no use case; 1: a use case failed; 4: --mutate found one that cannot fail; 5: --mutate could not run

codeloop verify [options] <nnn>

Argument	What it does
`nnn`	Card number or id

Option	What it does
`--mutate`	Re-run on the commit before the feature (after config verify.setup, default `npm ci && npm run build`); a use case that still passes is vacuous
`--env <name>`	Environment: api use cases use deploy.<name>.base_url from config.yaml
`--no-record`	Do not add the evidence to the card

`codeloop stats`

Autonomy numbers computed from card events

codeloop stats [options]

Option	What it does
`--card <id>`	One card
`--lane <id>`	One lane
`--compare <versions...>`	Two lane versions to compare, e.g. v1 v2
`--json`	JSON output

`codeloop wiki`

Gotchas, decisions and concepts that agents read before a stage and write after it

codeloop wiki [options] [command]

`codeloop wiki capture`

Write a page; capturing an existing title raises its frequency

codeloop wiki capture [options]

Option	What it does
`--title <title>`	Page title (required unless --quiet)
`--scope <glob...>`	File globs the page applies to (default: [])
`--body <text>`	Page body (default: "")
`--kind <kind>`	gotcha \| decision \| concept (default: "gotcha")
`--card <id>`	Card this came from
`--quiet`	Used by the Claude Code Stop hook: exit 0 silently when no --title was given, instead of refusing (default: false)

`codeloop wiki inject`

Print the pages whose scope matches the given files

codeloop wiki inject [options]

Option	What it does
`--files <path...>`	Changed or soon-to-change files
`--json`	JSON output

`codeloop wiki list`

List pages

codeloop wiki list [options]

`codeloop wiki lint`

Report broken links (exit 1), stale pages and duplicate titles

codeloop wiki lint [options]

`codeloop wiki init`

Seed the wiki from the repo's own files instead of writing an empty tree

codeloop wiki init [options]

Option	What it does
`--from-repo`	Scan README, docs, package manifests, Makefile/scripts, CI, deploy config, routes, schemas, git log and TODOs (default: false)
`--write`	Write the pages (default is a dry run) (default: false)
`--dry-run`	Print the outline without writing anything (the default) (default: false)
`--force`	Overwrite pages that already exist (default: false)
`--json`	JSON output

`codeloop wiki competitor`

One wiki page per competitor: links at the top, findings from each research stage below

codeloop wiki competitor [options] [command]

`codeloop wiki competitor add`

Create .codeloop/wiki/competitors/<name>.md, or update the links of an existing page

codeloop wiki competitor add [options] <name>

Option	What it does
`--docs <url>`	Where their product docs are
`--changelog <url>`	Where they announce what shipped; `codeloop scan competitors` reads it
`--title <title>`	Display name (default: the name)

`codeloop wiki competitor list`

List competitor pages

codeloop wiki competitor list [options]

`codeloop learn`

Apply frequency thresholds: critical at critical_frequency, promoted to rules.md at promote_frequency

codeloop learn [options]

`codeloop render`

Write each lane stage as an agent, rule or skill for Claude, Cursor and Codex, plus the standing protocol block and, with --hooks, the hooks that enforce it

codeloop render [options]

Option	What it does
`--host <host>`	claude \| cursor \| codex \| all; by default the hosts init set up (.claude, .cursor, .agents present), or all when none is (default: "auto")
`--hooks`	Also install the Claude Code and Cursor hooks and the pre-commit/pre-push git guards (same as `codeloop init --hooks`) (default: false)

`codeloop mcp`

Serve the card engine over MCP on stdio (tools: inbox, next_up, get_card, advance, approve, reject, task_done, wiki_inject, wiki_capture)

codeloop mcp [options]

`codeloop gate`

Gate checks for CI

codeloop gate [options] [command]

`codeloop gate check`

Exit 2 unless the card has an approval for the named gate

codeloop gate check [options] <id>

Option	What it does
`--require <gate>`	Gate name, e.g. local

`codeloop config`

Read .codeloop/config.yaml, with .codeloop/local.yaml laid over it

codeloop config [options] [command]

`codeloop config get`

Print one value by dotted path (empty when unset), for use in CI scripts

codeloop config get [options] <path>

`codeloop cloud`

Optional: keep the board, wiki, config and lanes in a Protobox workspace as well as in the repo

codeloop cloud [options] [command]

`codeloop cloud connect`

Save the connection in .codeloop/cloud.json (gitignored) and upload the board, wiki, config.yaml and lanes

codeloop cloud connect [options]

Option	What it does
`--url <mcp url>`	Workspace MCP URL
`--key <api key>`	Workspace API key (stored in cloud.json, never printed)
`--workspace-name <name>`	A label for status output
`--folder <path>`	Workspace folder for this project's pages (default: codeloop)

`codeloop cloud status`

Workspace, page revision against the local version, and each document as in-sync, local-ahead, cloud-ahead or both-changed

codeloop cloud status [options]

Option	What it does
`--json`	JSON output

`codeloop cloud push`

Write the board, wiki pages and config that changed here to the cloud. Lanes are not pushed: they change through `lane promote`

codeloop cloud push [options]

Option	What it does
`--force`	Overwrite even if the cloud copy changed since it was last seen here

`codeloop cloud pull`

Take the cloud board, and every other cloud copy whose local file was not edited here

codeloop cloud pull [options]

Option	What it does
`--force`	Take the cloud copy of every document, discarding local edits

`codeloop cloud disconnect`

Push pending writes, pull everything back into the repo, then remove cloud.json

codeloop cloud disconnect [options]

`codeloop cloud search`

Search the workspace knowledge base

codeloop cloud search [options] <query>

Option	What it does
`--json`	JSON output

`codeloop guard`

Hooks that enforce the codeloop protocol regardless of what the chat says

codeloop guard [options] [command]

`codeloop guard edit`

PreToolUse hook for Edit|Write|MultiEdit: exits 2 with no active card, or when the path is outside the plan and the card is past its spec gate

codeloop guard edit [options] [path]

`codeloop guard session`

SessionStart hook: prints the active story and its brief, or the top open stories by priority when none is active

codeloop guard session [options]

`codeloop guard prompt`

UserPromptSubmit hook: prints the active card, its stage and open questions; flags a prompt whose words match none of the card's title (a heuristic, not a parser)

codeloop guard prompt [options]

`codeloop guard diff`

Pre-commit hook: lists changed files outside the active card's plan; exits 1 when any are found and the plan has a files list

codeloop guard diff [options]

Option	What it does
`--staged`	Compare the git index instead of the working tree (default: false)

`codeloop presence`

Presence files Cursor session hooks write under .codeloop/state/presence/ (serving this over HTTP as GET /api/presence is not built yet)

codeloop presence [options] [command]

`codeloop presence start`

sessionStart hook: records host, session id and machine

codeloop presence start [options]

`codeloop presence end`

sessionEnd hook: clears the presence file

codeloop presence end [options]

`codeloop presence event`

subagentStart/subagentStop hooks: appends an event line to the session's presence log

codeloop presence event [options] <kind>

`codeloop whoami`

This repo's active card, your git identity and role, and who else is present (from Cursor session hooks)

codeloop whoami [options]

`codeloop install`

Install a skill from the registry, GitHub, or local path

codeloop install [options] <source>

Argument	What it does
`source`	Skill name, github:user/repo/path, or local path

`codeloop search`

Search for skills in the registry

codeloop search [options] <query>

Argument	What it does
`query`	Search query

Option	What it does
`--tag <tag>`	Filter by tag
`--stack <stack>`	Filter by stack
`--local`	Search local index only (offline)

`codeloop list`

Show installed skills

codeloop list [options]

`codeloop remove`

Uninstall a skill

codeloop remove [options] <name>

Argument	What it does
`name`	Skill name to remove

`codeloop publish`

Publish a skill to the registry (validate locally with --dry-run)

codeloop publish [options]

Option	What it does
`--dry-run`	Validate only, don't publish

`codeloop login`

Authenticate with the skill registry (check status with --status)

codeloop login [options]

Option	What it does
`--token <token>`	GitHub personal access token
`--status`	Check current auth status

`codeloop skill`

Skills (templates/skills/) and their eval fixtures

codeloop skill [options] [command]

`codeloop skill list`

Every skill under the skills dir

codeloop skill list [options]

Option	What it does
`--skills-dir <dir>`	Skills dir, relative to the project root (default templates/skills)
`--json`	Print as JSON

`codeloop skill show`

A skill's SKILL.md: its frontmatter and its body

codeloop skill show [options] <name>

Option	What it does
`--skills-dir <dir>`	Skills dir, relative to the project root (default templates/skills)
`--json`	Print as JSON

`codeloop skill eval`

Replay a skill's fixtures: the configured agent on the stage, the stage's check, then a graded run against checklist.md

codeloop skill eval [options] <name>

Option	What it does
`--fixture <id>`	Only this fixture (default: every fixture under the skill)
`--agent <name>`	The configured agent to use (default agents.default, or the only one configured)
`--min <0..1>`	Score a fixture must reach to pass (default: "0.8")
`--skills-dir <dir>`	Skills dir, relative to the project root (default templates/skills)
`--fixtures-dir <dir>`	Fixtures dir, relative to the project root (default fixtures/skills)
`--json`	Print the report as JSON instead of a table