Global flags

Option	What it does
-V, --version	output the version number
--no-color	disable colored output
--verbose	detailed logs
--yes	non-interactive: accept all defaults (CI)
--dry-run	print planned actions without writing
init [options]	scaffold the mission structure (interactive wizard, or --yes)
check [options]	can I cross the gate — gate audit, exit 1 on gaps (CI-friendly)
verify [options] <attestation>	re-check a `check --attest` attestation offline — the tree has not drifted and the verdict re-derives, on the repo alone (ADR-0055)
bundle [options] <artifacts...>	bind delivery artifacts (the verdict attestation, seal, OSCAL, SBOM) into one in-toto-attested manifest — a single provenance for an assessor (ADR-0055)
spec-check [options] <spec...>	deterministic spec conformance: every acceptance criterion is LINKED to a present delivered artifact, and every criterion identifier the bundle references is declared — never a claim it is semantically met (ADR-0056)
status [options]	where am I — mission snapshot: current gate, decision journal, workflows
doctor [options]	environment and installation checks
wire [options]	recommend the auto-trigger channel for the AI harness running this command (read-only without --install; --install, run by the operator in a terminal, arms the gate — ADR-0065)
update [options]	refresh runward/workflows/ and runward/rules/ from this package version (mission state untouched)
characterize [options]	inventory of an existing codebase (brownfield/retro-doc): never modifies your code; writes runward/characterization.md, and runward/adr/DRAFT-*.md with --mine
manifest [options]	rule-conformance manifest overview; --sync scaffolds missing rows and migrates renamed slugs (form only, never content)
propose [options]	deterministic proposer: fill empty manifest rows as proposed:applied where a rule's signature matches inside its declared territory — no model call; the gate refuses every proposal until it is ratified (runward ADR-0066)
ratify [options]	turn proposals into your decisions, against displayed evidence; interactive for a person, --attest-blind is the recorded, disclosed escape; an agent ratifies under its own name with --agent <name> --for <person>, --list then --accept (runward ADR-0066, ADR-0082)
sample [options] [action] [verdicts...]	the weekly signed sample of a delegation charter (runward ADR-0088 decision 6), outside the verdict path: plant (the planter commits a seed as H(seed, nonce)), draw (the population from git, a drand round's signature you fetch), review (the maintainer's verdicts, the one act to sign), reveal (the planter opens the seeds); with no action, where the period stands, what git says of the signatures, and what comes next
gate-hook [options]	run by your AI tool's end-of-turn hook: when check --strict is red, blocks the end of the turn once, in the shape that tool understands (Cursor cannot block: there it is advisory); every release after that is logged to runward/gate-bypass.log; with no mission found or a misconfigured hook it lets the turn through and says so on stderr
report [options]	write the delivery report an assessor reads alone (ADR-0064): one self-contained HTML, rendered from the same machine payload check --json publishes — computes nothing, works without a terminal, an account or runward installed
rules [options]	the effective rule set (mission copy, else package); --json is a stable machine contract
explain [options] <rule>	print a rule's contract (impact, phases, why, signature) and its full text — the rationale inline
compliance [options] [regime]	assemble a regime-framed evidence pack from the mission (deterministic, read-only; a readiness draft, never a compliance claim)
help [command]	display help for command

runward init

scaffold the mission structure (interactive wizard, or --yes)

runward init [options]

Option	What it does
-p, --path <path>	project directory (default: prompt, or . with --yes)
-t, --tools <list>	comma-separated tool profiles: claude,cursor,copilot,gemini,windsurf,continue,junie,trae,kiro
--force	overwrite existing files
--example	scaffold a filled reference mission (request-triage) — the whole chain is green out of the box

runward check

can I cross the gate — gate audit, exit 1 on gaps (CI-friendly)

runward check [options]

Option	What it does
-p, --path <path>	project directory
--strict	also verify the rule-conformance manifests: rows, typed pointers, signatures, drift, seal (deterministic)
--freeze	seal a green strict gate: hash the evidence into runward/evidence-lock.json (implies --strict)
--hooks	run operator hooks from runward/hooks.json around the audit (opt-in)
--coverage	advisory: report deliverable + decision-ratification coverage (does not gate)
--through <phase-id>	construction gate: certify only phases up to and including <phase-id> (frame | architect | floor | govern | handover) — a progress signal, never the sole release gate (ADR-0053) (choices: "frame", "architect", "floor", "govern", "handover")
--json	machine output: verdict, current gate, deliverable states, conformance gaps, next step (stable contract, for agent-driven runs; gaps.proposed and gaps.unboundRows are already inside gaps.conformance, never added to it)
--attest	emit the verdict as an unsigned in-toto attestation (in-toto Statement wrapping --json; sign it yourself under your own key)
--sarif	emit the verdict as a SARIF 2.1.0 log (annotations on the manifest rows; upload it yourself)
--vsa	emit the verdict as a SLSA Verification Summary Attestation (needs --resource-uri; set SOURCE_DATE_EPOCH to keep it byte-idempotent)
--resource-uri <uri>	the artifact the VSA is about (a package, image or release URI) — required with --vsa, never guessed
--witness <file>	with --strict: also write the witness of the verdict to <file> (runward-witness/1, specified at https://github.com/stranxik/runward/blob/main/docs/spec/witness.md): the facts it relied on, for a separate checker to re-check; stdout and the exit code are unchanged
--codequality <file>	also write the verdict as a Code Quality report (CodeClimate-shaped JSON, GitLab's merge-request widget) to <file>: one issue per cause, fingerprints stable across runs; stdout and the exit code are unchanged
--junit <file>	also write the verdict as a JUnit XML report to <file> (no test is executed: one case per cause and one `runward gate` case); runward refuses its own JUnit as evidence; stdout and the exit code are unchanged

runward verify

re-check a `check --attest` attestation offline — the tree has not drifted and the verdict re-derives, on the repo alone (ADR-0055)

runward verify [options] <attestation>

Option	What it does
-p, --path <path>	project directory
--json	machine output: verified, and the digest/verdict match (stable contract)

runward bundle

bind delivery artifacts (the verdict attestation, seal, OSCAL, SBOM) into one in-toto-attested manifest — a single provenance for an assessor (ADR-0055)

runward bundle [options] <artifacts...>

Option	What it does
-p, --path <path>	project directory

runward spec-check

deterministic spec conformance: every acceptance criterion is LINKED to a present delivered artifact, and every criterion identifier the bundle references is declared — never a claim it is semantically met (ADR-0056)

runward spec-check [options] <spec...>

Option	What it does
-p, --path <path>	project root the criteria's file:/test: pointers resolve against (default: .)
--json	machine output: verdict, per-criterion linkage, non-scope (stable contract)

runward status

where am I — mission snapshot: current gate, decision journal, workflows

runward status [options]

Option	What it does
-p, --path <path>	project directory
--json	machine output: current gate and phase, deliverable states, the strict verdict, ADRs with their dates, reopening triggers, workflows (stable contract, additive)

runward doctor

environment and installation checks

runward doctor [options]

Option	What it does
-p, --path <path>	project directory (default: .)
--json	machine output: every check with its status (ok | warning | critical), counts, exit code (stable contract, additive)

runward wire

recommend the auto-trigger channel for the AI harness running this command (read-only without --install; --install, run by the operator in a terminal, arms the gate — ADR-0065)

runward wire [options]

Option	What it does
-p, --path <path>	project directory
--json	machine output: detection status, harness, gate-hook id, recommended + candidate channels, the armed tier (stable contract)
--install	the operator's writing gesture (ADR-0065): shows the exact file, asks y/N, writes atomically with a probe and a committed journal — TTY-only, refused under an agent runtime signal, and --yes does not exist here
--uninstall	the symmetric removal of what --install wrote, under the same locks (the global --dry-run renders either gesture without writing, exempt from the locks)

runward update

refresh runward/workflows/ and runward/rules/ from this package version (mission state untouched)

runward update [options]

Option	What it does
-p, --path <path>	project directory
--force	overwrite locally modified workflows
--corpus <path>	vendor runward/rules/ from this local corpus directory (a path, never a registry coordinate)

runward characterize

inventory of an existing codebase (brownfield/retro-doc): never modifies your code; writes runward/characterization.md, and runward/adr/DRAFT-*.md with --mine

runward characterize [options]

Option	What it does
-p, --path <path>	project directory (default: .)
--mine	also write candidate retroactive ADRs as runward/adr/DRAFT-*.md hypotheses (deterministic git archaeology, no model call); check --strict refuses each DRAFT until accepted or rejected
--force	with --mine on an already-governed mission: write the DRAFTs anyway (refused without it)

runward manifest

rule-conformance manifest overview; --sync scaffolds missing rows and migrates renamed slugs (form only, never content)

runward manifest [options]

Option	What it does
-p, --path <path>	project directory
--sync	write: append missing rows with an empty status, rewrite renamed slugs, create missing sections
--json	machine output: every row of every gated manifest with its status and evidence, what is missing, and with --sync what was appended (stable contract, additive)

runward propose

deterministic proposer: fill empty manifest rows as proposed:applied where a rule's signature matches inside its declared territory — no model call; the gate refuses every proposal until it is ratified (runward ADR-0066)

runward propose [options]

Option	What it does
-p, --path <path>	project directory
--for <person>	the person accountable for whoever runs this proposer, recorded in each proposed row as declared (`; for: <person>`): what lets an agent ratification be compared by accountable person (runward ADR-0088)
--json	machine output: the proposals made (row, pointer, signature) and the rows left empty with their cause (stable contract, additive)

runward ratify

turn proposals into your decisions, against displayed evidence; interactive for a person, --attest-blind is the recorded, disclosed escape; an agent ratifies under its own name with --agent <name> --for <person>, --list then --accept (runward ADR-0066, ADR-0082)

runward ratify [options]

Option	What it does
-p, --path <path>	project directory
--all	en-bloc ratification with a mandatory sample drawn deterministically from the mission digest
--by <name>	the declared ratifier (defaults to the OS user name; always recorded as declared)
--attest-blind	ratify without displayed evidence and RECORD the mode as BLIND — disclosed by every later check and carried by the attestation
--decided	ratify rows already DECIDED whose ratification is missing, BLIND, or older than the row's current content, instead of proposals
--agent <name>	an agent ratifies under its OWN name, never a person's; needs --for, runs without a terminal, and only through --list then --accept
--for <person>	the person accountable for the agent, recorded beside it as declared; mandatory with --agent
--list	write nothing: show every pending row with its resolved evidence, exactly what a person is shown, and its <deliverable>:<rule> id
--accept <ids...>	with --agent: ratify ONLY these listed rows, named <deliverable>:<rule> (repeatable or comma-separated); refused whole if one is not listed or was proposed by the agent or its accountable person
--single-accountable	with --agent and --accept: also accept a row whose proposer answers to the same accountable person as the agent, recorded as agent (single accountable) and disclosed as such on every surface; refused by default under the regulated tier (runward ADR-0088)
--json	with --list: the same rows and evidence as machine output

runward sample

the weekly signed sample of a delegation charter (runward ADR-0088 decision 6), outside the verdict path: plant (the planter commits a seed as H(seed, nonce)), draw (the population from git, a drand round's signature you fetch), review (the maintainer's verdicts, the one act to sign), reveal (the planter opens the seeds); with no action, where the period stands, what git says of the signatures, and what comes next

runward sample [options] [action] [verdicts...]

Option	What it does
-p, --path <path>	project directory
--branch <name>	the branch the population is read from (default main)
--ref <ref>	with plant: the planted item's reference, as the reviewer will see it
--summary <text>	with plant: the planted item's summary
--defect <text>	with plant: the defect a careful review finds (revealed after the review)
--stratum <name>	with plant: merge (default), ratification or tag
--actor <name>	with plant: the actor shown (default: the charter's first delegate)
--date <YYYY-MM-DD>	with plant: the date shown (default: today)
--signature <hex>	with draw: the drand quicknet round's signature (runward opens no socket: fetch it with the URL `runward sample` prints)
--reviewer <name>	with review: the declared reviewer (default: the charter's accountable person)

runward gate-hook

run by your AI tool's end-of-turn hook: when check --strict is red, blocks the end of the turn once, in the shape that tool understands (Cursor cannot block: there it is advisory); every release after that is logged to runward/gate-bypass.log; with no mission found or a misconfigured hook it lets the turn through and says so on stderr

runward gate-hook [options]

Option	What it does
--harness <id>	one of: claude, copilot, kiro, gemini, junie, cursor
-p, --path <path>	project directory

runward report

write the delivery report an assessor reads alone (ADR-0064): one self-contained HTML, rendered from the same machine payload check --json publishes — computes nothing, works without a terminal, an account or runward installed

runward report [options]

Option	What it does
-p, --path <path>	project directory
-o, --out <path>	output file inside the project, relative to its root or absolute (default runward/governance/delivery-report.html)
--force	replace an existing --out file that is not a previous delivery report
--format <format>	html (default): the assessor's report; md: the pull/merge request summary runward-forge posts, to standard output unless --out is given (ADR-0093)
--json	machine output: the file written, the verdict and next step it carries, dry-run (stable contract, additive)

runward rules

the effective rule set (mission copy, else package); --json is a stable machine contract

runward rules [options]

Option	What it does
-p, --path <path>	project directory
--json	machine output: { runward, source, count, rules } sorted by slug (versioned, additive)
--phase <id>	only the rules mapped to this phase (architect | topology | floor | govern | handover)
--for <paths...>	only the rules whose declared territory (appliesTo:) covers these project-relative paths; prints the pattern that matched

runward explain

print a rule's contract (impact, phases, why, signature) and its full text — the rationale inline

runward explain [options] <rule>

Option	What it does
-p, --path <path>	project directory
--json	machine output: the rule plus its body

runward compliance

assemble a regime-framed evidence pack from the mission (deterministic, read-only; a readiness draft, never a compliance claim)

runward compliance [options] [regime]

Option	What it does
-p, --path <path>	project directory
--regime-version <version>	regime mapping version (default: highest shipped, see regimes/)
--json	machine output: regime and mapping version, files written, the strict verdict the pack carries (stable contract, additive)
-o, --out <dir>	write the pack to this directory instead of runward/compliance/ (relative to the current directory, or absolute): for a CI artifact that is not committed

Generated from runward --help / runward <command> --help · runward v0.46.0

← Docs