Skip to content

$ aidlc — CLI Reference

Generated from the shipped CLI (30 commands). Requires Node.js >= 22.13.0. Install with npx @rasensio/aidlc init.

Test traceability is configured via traceability.test_globs; the gate command parses tasks.md checkboxes [tasks] and reports done/total task completion at the implementation gate.

$ aidlc add [command]

Add framework components

$ aidlc add action <description>

Create a lifecycle action from a natural language description

Options for action
OptionDescription
--event <event>Override the inferred lifecycle event
--blockingMark the action as blocking (halts transition on failure)
--non-interactiveSkip confirmation prompts; fail if event cannot be inferred
--dry-runShow what would be added without writing

$ aidlc add skill [name]

Create an app-owned operational skill and package it per platform

Options for skill
OptionDescription
--description <text>One-line summary of the operation
--steps <text>The operation steps, as markdown
--trigger <text>When this skill should be used
--paths <paths...>Repo-relative paths the skill operates on
--overwriteReplace an existing skill of the same name
--re-emitRe-package existing skills; refreshes verification text
--checkSmoke-check existing skills without writing
--dry-runShow what would be written without writing

$ aidlc amend <instance>

Record a requirements amendment and reopen the phases it invalidated

Options for amend
OptionDescription
--impactReport remaining citations of the retired criteria; write nothing
--amendment <n>Operate on this amendment instead of the highest-numbered one
--confirmConfirm a reopen from testing or later
--overrideWrite without a live claim (records `by` from the environment)
--jsonOutput as JSON

$ aidlc autopilot [command]

Work the backlog in the background: set up, run, watch, pause, stop

$ aidlc autopilot answer <fingerprint> <option>

Apply your answer to one pending entry and record it, so no session asks it again

Options for answer
OptionDescription
--note <text>Your words: the reason for a park or decline, or the answer for "other"
--rank <n>For a triage backlog answer: the rank to give it instead of the one offered
--by <name>Who answered (default: git config user.name)

$ aidlc autopilot approve <instance>

Approve the phase an item paused after for review, so the run carries it on

$ aidlc autopilot forget <instance>

Stop tracking an item you finished or abandoned by hand

$ aidlc autopilot pause

Freeze the run and its agents in place, e.g. before closing the laptop

$ aidlc autopilot pending

List every decision the run waits on you for, each with its options and the command that applies it

Options for pending
OptionDescription
--jsonPrint {run, entries} as JSON

$ aidlc autopilot resume

Continue a paused run from where it was frozen

$ aidlc autopilot review <instance>

Keep, reject or promote each decision an unattended run logged for an item, in the checkout you run it in

$ aidlc autopilot run

Start a background run over the next items, and return

Options for run
OptionDescription
--items <n>Stop after this many items are released or held
--allKeep going until nothing is ready and nothing is in flight
--interval <seconds>Seconds between passes (default: "60")
--stop-at <step>For the items this run starts, the last step autopilot takes: pr, merge, release
--pause-after <phases>For the items this run starts, pause for review after: comma-separated phases from requirements, design, implementation, testing, or "none"

$ aidlc autopilot setup

Choose the agent, how many items build at once, a cost cap, where autopilot stops for you, and the release step

Options for setup
OptionDescription
--agent <preset>Agent preset (claude-scoped, claude-full, codex-full-auto)
--parallel <n>Items building at once: 1 or 2
--token-cap <tokens>Stop an item past this many tokens (40M, 500k), or "none"
--cost-cap <usd>Stop an item past this many dollars of API price, or "none"
--pause-after <phases>Pause for review after: comma-separated phases from requirements, design, implementation, testing, or "none"
--stop-at <step>The last step autopilot takes: pr, merge, release
--release <preset>After a merge: repo-script or merge-only
--non-interactiveNo prompts; recommended choices for anything not flagged

$ aidlc autopilot status

Show the active run and every tracked item

Options for status
OptionDescription
--watchRedraw every 2 seconds until the run ends; q or Ctrl-C leaves the run running
--view <name>With --watch: cards (default), table or lanes; v switches while watching

$ aidlc autopilot stop

Stop the run at its next step; agents already running finish

$ aidlc autopilot tick

One pass in the foreground (debugging)

Options for tick
OptionDescription
--dry-runPrint what would be done; change nothing

$ aidlc autopilot wait

Block until something new waits for you, the heartbeat passes, or the run ends, then exit

Options for wait
OptionDescription
--pendingWait for a new pending entry (the one thing it waits for)
--heartbeat <minutes>Exit after this many minutes with nothing new (default: "30")
--interval <seconds>Seconds between checks (default: "15")

$ aidlc claim <instance>

Claim a lifecycle instance for this session (writes sessions.ndjson)

Options for claim
OptionDescription
--renewRenew an existing claim instead of taking a new one

$ aidlc compliance [command]

Compliance packs — install, check, and report evidence per control

$ aidlc compliance add <pack>

Install a compliance pack into this project

$ aidlc compliance check

Check a change against the installed packs’ controls

Options for check
OptionDescription
--diff <ref>Assess the diff against this git ref instead of the working tree
--enforceExit non-zero on a failing or unassessed control
--jsonOutput machine-readable JSON

$ aidlc compliance list

List available compliance packs and whether each is installed

Options for list
OptionDescription
--jsonOutput machine-readable JSON

$ aidlc compliance remove <pack>

Remove an installed compliance pack

$ aidlc compliance report

Evidence report: what each control requires and where the evidence is

Options for report
OptionDescription
--instance <name>Limit the report to one instance
--since <date>Limit the report to instances completed on or after this date
--jsonOutput machine-readable JSON

$ aidlc compliance upgrade <pack>

Upgrade an installed pack to the available version

$ aidlc constitution [command]

Import a product vision document and track the repo scope derived from it

$ aidlc constitution check

Report vision statements added or removed since the last import

Options for check
OptionDescription
--jsonOutput machine-readable JSON
--exit-codeExit 1 when drift is found (default: always exit 0)

$ aidlc constitution import <path>

Read a vision document (.docx, .md, .markdown, .txt) into a snapshot

Options for import
OptionDescription
--jsonOutput machine-readable JSON

$ aidlc continue [instance]

Resume the active lifecycle instance from the next incomplete step

Options for continue
OptionDescription
--jsonOutput as JSON

$ aidlc cost [command] [instance]

Per-instance cost tracking: reports, capture, rates, hooks

Options for cost
OptionDescription
--jsonStructured JSON output
--by-templateRoll up average cost per template
--unattributedList usage not attributed to any instance

$ aidlc cost context

Resident context for this session, against the budget

Options for context
OptionDescription
--jsonStructured JSON output

$ aidlc cost dedupe

Plan (or apply) the correction for usage counted once per content block

Options for dedupe
OptionDescription
--applyRewrite the ledgers — read-only without it
--jsonStructured JSON output

$ aidlc cost hooks [command]

Manage cost-capture hooks per platform

$ aidlc cost hooks install

Install cost-capture hooks

Options for install
OptionDescription
--platform <name>Limit to one platform (claude-code, kiro)

$ aidlc cost hooks remove

Remove cost-capture hooks

Options for remove
OptionDescription
--platform <name>Limit to one platform (claude-code, kiro)

$ aidlc cost hooks status

Status cost-capture hooks

Options for status
OptionDescription
--platform <name>Limit to one platform (claude-code, kiro)

$ aidlc cost providers [command]

Cost provider status

$ aidlc cost providers status

Show detection and metered-capture state per provider

$ aidlc cost rates [command]

Manage the usage→dollar rate table

$ aidlc cost rates show

Print the effective merged rate table

Options for show
OptionDescription
--normalizationPrint the model-id normalization rules

$ aidlc cost rates update

Fetch current rates from the configured source

$ aidlc cost record

Record usage (hook mode via stdin, or --manual)

Options for record
OptionDescription
--provider <name>Cost provider (claude-code, kiro)
--detachSpawn a background recorder and exit immediately
--session-endThe session has ended: drop its active-session stash entry
--manualManual entry mode (agent-driven fallback)
--instance <name>Target instance (manual mode)
--session <id>Session id, or "-" for none (manual mode)
--fidelity <f>estimated | unknown (manual mode)
--units <json>Units JSON (manual mode, estimated only)
--from <iso>Coverage start (manual mode)
--to <iso>Coverage end (manual mode)

$ aidlc cost session-start

Stash a platform session id (hook mode via stdin)

Options for session-start
OptionDescription
--provider <name>Platform name

$ aidlc cost sync [instance]

Reconcile historical platform records into ledgers

$ aidlc cross-check <instance>

Report where requirements, design and tasks disagree; writes nothing, blocks nothing

$ aidlc discover

Scan codebase, generate context documents, and seed the knowledge graph

Options for discover
OptionDescription
--jsonOutput full scan result as JSON
--no-knowledgeSkip seeding the knowledge graph
--forceOverwrite hand-edited context docs as well as generated ones

$ aidlc docs

Generate onboarding documentation (.aidlc/ONBOARDING.md)

$ aidlc doctor

Check and repair repo hygiene (gitignore coverage, stale ephemera, tracked cost files)

Options for doctor
OptionDescription
--dry-runList pending migrations without applying anything
--yesApply index-mutating migrations without prompting

$ aidlc explain [topic]

Explain why a part of AIDLC works the way it does (lists topics, or prints one)

$ aidlc gate <instance> [phase]

CI/CD gate check — exits 0 if phase is complete

Options for gate
OptionDescription
--jsonOutput structured JSON (GateCheckResult)
--verifyIn verified mode, run verify.command when no matching passing test receipt exists

$ aidlc hook [command]

Lifecycle hooks: session-start context and the opt-in phase guard

$ aidlc hook guard

Ask before code is edited during planning (PreToolUse hook mode)

$ aidlc hook install

Install the session-start hook (and, with --guard, the phase guard)

Options for install
OptionDescription
--platform <name>Platform to install for (claude-code, codex; default claude-code)
--guardAlso install the phase guard (Claude Code only; off by default)

$ aidlc hook remove

Remove the lifecycle hooks, or only the phase guard with --guard

Options for remove
OptionDescription
--platform <name>Limit to one platform (claude-code, codex)
--guardRemove only the phase guard

$ aidlc hook session-start

Print the claimed instance, its phase and next step (SessionStart hook mode)

$ aidlc init

Set up AIDLC: configure the project and install platform skills

Options for init
OptionDescription
--platform <name>Install skills for a single platform without prompts (claude-code, codex)
--non-interactiveSkip prompts, use defaults or existing config
--dry-runPrint what would be written without making changes
--no-cost-hooksSkip installing cost-capture hooks
--no-lifecycle-hooksSkip installing the session-start hook (and the Codex question)
--autopilotAlso set up autopilot (agent, parallelism, cost cap, where it stops for you, release step)
--host <name>Where the repository is hosted: github, gitlab or git (detected from origin when omitted)

$ aidlc knowledge [command]

Local knowledge graph — persistent codebase memory for agents

$ aidlc knowledge add

Add an entity (via flags, or stdin YAML with --stdin)

Options for add
OptionDescription
--id <id>Entity id (lowercase slug)
--type <type>Entity type (module, service, decision, … or custom:<name>)
--name <name>Human-readable name
--description <text>Free-text description
--confidence <n>Confidence 0.0–1.0
--source <path>Source file path or "agent-inferred"
--tags <tags>Comma-separated tags
--stdinRead one or more entity YAML documents from stdin

$ aidlc knowledge compact

Deduplicate and normalize YAML source files (rewrites files)

$ aidlc knowledge context

Generate a markdown context summary for agent prompts

Options for context
OptionDescription
--scope <scope>full | phase <name> | file <path> (default: "full")
--phase <name>Lifecycle phase (with --scope phase)
--file <path>File path (with --scope file)
--max-tokens <n>Token budget (default: 2000)
--include-staleInclude low-confidence entities

$ aidlc knowledge get <id>

Get a single entity with all its relationships

Options for get
OptionDescription
--format <fmt>Output format: yaml or json (default: "yaml")

$ aidlc knowledge graph <id>

Subgraph of entities within N hops

Options for graph
OptionDescription
--depth <n>Traversal depth (default: 1)
--format <fmt>Output format: yaml or json (default: "yaml")

$ aidlc knowledge import <file>

Bulk import entities and relationships from a YAML file

$ aidlc knowledge install-merge-driver

Install the git merge driver for knowledge YAML files (writes git config)

Options for install-merge-driver
OptionDescription
--yesSkip the confirmation prompt (CI)

$ aidlc knowledge query <term>

Full-text search across the graph

Options for query
OptionDescription
--type <type>Filter by entity type
--min-confidence <n>Minimum confidence
--limit <n>Maximum results (default: 20)
--format <fmt>Output format: yaml or json (default: "yaml")

$ aidlc knowledge rebuild

Rebuild the SQLite index from YAML sources

$ aidlc knowledge relate

Create a relationship between two existing entities

Options for relate
OptionDescription
--from <id>Source entity id
--to <id>Target entity id
--type <type>Relationship type (depends-on, uses, … or custom:<name>)

$ aidlc knowledge stale

List entities that may no longer reflect the code

Options for stale
OptionDescription
--days <n>Age threshold in days (default: 30)
--check-gitAlso degrade confidence of entities whose source files changed
--format <fmt>Output format: yaml or json (default: "yaml")

$ aidlc knowledge sync

After git pull: rebuild the index and report suspicious merges

Options for sync
OptionDescription
--format <fmt>Output format: yaml or json (default: "yaml")

$ aidlc knowledge update <id>

Update fields on an existing entity

Options for update
OptionDescription
--description <text>New description
--confidence <n>New confidence 0.0–1.0
--tags <tags>Comma-separated tags (replaces existing)
--name <name>New name

$ aidlc knowledge verify <id>

Confirm an entity is still accurate (bumps lastVerified and confidence)

Open the aidlc console (also: run `aidlc` with no arguments)

$ aidlc metrics

DORA-style metrics: change failure rate, lead times, true cost

Options for metrics
OptionDescription
--jsonOutput machine-readable JSON

$ aidlc release <instance>

Release a claimed instance (writes sessions.ndjson)

$ aidlc revert <instance>

Undo a task's commits (found by their Task: trailer) after showing the plan

Options for revert
OptionDescription
--task <id>Task to undo, e.g. T3
--phase <phase>Undo every task commit of the phase (implementation only)
--dry-runPrint the plan; change nothing
--yesRevert without asking (needed without a terminal)
--overrideRevert without a live claim on the instance

$ aidlc review <instance> <artifact>

Run an adversarial review of a lifecycle artifact, recording structured findings

Options for review
OptionDescription
--jsonOutput findings as structured JSON

$ aidlc roadmap [command]

Project the roadmap onto GitHub Issues, import an issue, pick or rank the next item, park one, see its milestones, or view it as a page

$ aidlc roadmap assign-milestones

List open items with no milestone, or write the milestone of each item named by --set (commits nothing)

Options for assign-milestones
OptionDescription
--set <item=milestone>Write this item's milestone: line (a milestone id or none); repeatable (default: [])

$ aidlc roadmap board-workflow

Print the GitHub Actions workflow that moves a Project board from roadmap labels

$ aidlc roadmap import <issue-url>

Seed one inbox roadmap item from a GitHub issue (one-shot)

$ aidlc roadmap next

Name the next ready backlog item: lowest priority whose dependencies are done (read-only)

Options for next
OptionDescription
--jsonPrint {next, skipped} as JSON
--explainAlso list the ready order and every skipped item with its reason
--autopilotPick as autopilot does: leave out items marked run: attended

$ aidlc roadmap park [instance]

Park in hold/ the item promoted to an instance, or the one named by --item

Options for park
OptionDescription
--item <item>Park this open item (file name or id) instead, whatever its promoted_to
--reason <text>Why it is parked; recorded in the item history

$ aidlc roadmap rank <item> <rank>

Give a backlog item a rank and renumber the others so ranks stay unique and gap-free

Options for rank
OptionDescription
--dry-runPrint the resulting order and write nothing

$ aidlc roadmap status

Print each milestone and what is done, in flight, next, parked and open under it, then Unassigned

Options for status
OptionDescription
--milestone <id>Print only this milestone, or none for Unassigned

$ aidlc roadmap sync

Project eligible roadmap items onto GitHub Issues (one-way)

Options for sync
OptionDescription
--dry-runPrint the plan and write nothing
--yesApply the plan without asking
--repo <owner/name>Target repository (overrides roadmap.sync.repo)
--retire-ineligibleClose issues whose item has left a projected status

$ aidlc roadmap triage <item> <to>

Move an inbox item to backlog (with its rank and run mode), or park or decline it in hold/

Options for triage
OptionDescription
--rank <n>With backlog: rank to give it, as `aidlc roadmap rank` does
--run <mode>With backlog: autopilot or attended, written to its run: line
--reason <text>With park or decline: why; recorded in the item history

$ aidlc roadmap view|graph

Write the roadmap as one HTML page (board and dependency map) and open it

Options for view
OptionDescription
--no-openWrite the page without opening a browser
--out <path>Write the page here instead of <git-common-dir>/aidlc/roadmap.html

$ aidlc spec [command]

Read the spec corpus — what the system does today — and fold changes into it

$ aidlc spec fold <instance>

Fold an instance's ## Spec delta into the corpus (also run at completion)

Options for fold
OptionDescription
--dry-runReport what the fold would do; write nothing
--jsonOutput machine-readable JSON

$ aidlc spec show [capability]

List capabilities, or print one capability's requirements and revisions

Options for show
OptionDescription
--jsonOutput machine-readable JSON

$ aidlc start [template]

Begin a new lifecycle instance

Options for start
OptionDescription
--name <instance-name>Instance name (URL-safe)
--scope <scope>Cycle scope (full, standard, micro)
--non-interactiveDisable interactive prompts (for AI agents)
--worktreeCreate the instance in a new git worktree (branch based on main)
--no-codeStart without a branch; implementation entry stays blocked until one exists
--no-openWith --worktree inside herdr, do not open a herdr workspace or start the agent there
--roadmap-item <item>Link a backlog or inbox roadmap item (file name or id): set promoted_to, move it to in-progress, seed the instance

$ aidlc status

Show progress across active lifecycle instances

Options for status
OptionDescription
--jsonOutput in JSON format for machine consumption
--allInclude instances from all local branches
--pruneRemove stale registry entries and orphaned claims (explicit cleanup)

$ aidlc templates [command]

Workflow templates — their phases and the artifacts each phase requires

$ aidlc templates list

List available templates

Options for list
OptionDescription
--jsonOutput as JSON

$ aidlc templates show <name>

Show a template's phases and their required artifacts

Options for show
OptionDescription
--scope <scope>Restrict to the phases this scope runs (full, standard, micro)
--jsonOutput as JSON

$ aidlc transition <instance>

Evaluate gates and advance to the next phase

Options for transition
OptionDescription
--overrideOverride ownership gate
--jsonOutput result as JSON

$ aidlc update

Update the AIDLC CLI and refresh project skills

Options for update
OptionDescription
--self-onlyOnly update the CLI globally, skip project file refresh
--project-onlyOnly refresh project files from the currently installed CLI
--rediscoverAlso regenerate context docs in .aidlc/context/
--dry-runShow what would change without writing anything

$ aidlc verify <instance>

Run the project's test command (verify.command) and write the instance's receipt