Command reference

After this page you can pick the right /guild:verb command for the job, start or resume a run, inspect evidence, and find the deeper reference table when you need exact flags.

Every Guild Stack command is a flat token: /guild:verb. Bare /guild is not the v2 command surface; use /guild:guild when you want Guild Stack to detect the next phase from project state.

Command surface

map / active

Choose a verb by the job in front of you

1. Run/guild:guildinit · ideate · plan · build · qa · ops
2. Recover/guild:statusresume · fix
3. Learn/guild:learnwiki query · wiki ingest
4. Govern/guild:initiativegoal · config
5. Maintain/guild:evolverollback · migrate · audit · stats

Command surface

Verbs grouped by job

Lifecycle

/guild:guild [brief] Smart entry: detects the next phase from .guild/ state. Run trace + phase artifacts

/guild:init [--learn] Onboards an existing repo or scaffolds new-product knowledge. .guild/wiki/**

/guild:ideate [brief] Produces the spec and asks for approval. .guild/spec/slug.md

/guild:plan Composes the phase team and lane plan. .guild/plan/slug.md

/guild:build [lane-id] Dispatches lanes, reviews, and verifies done. handoffs/, review.md, verify.md

/guild:qa [run-id] Selects the Quality matrix and records the release recommendation. quality/run-id.md

/guild:ops [runbook] Runs an approved runbook under safety rails. ops/run-id.md

Recovery

/guild:status Reads current run state, next gate, and blockers (read-only).

/guild:resume [--restart] Continues the active run from the next pending gate.

/guild:fix [run-id] Diagnoses a failed or suspicious run and asks before applying edits.

Knowledge

/guild:learn [map|graph|onboard|diff|explain] Runs smart learn-all, or a targeted learn operation.

/guild:wiki ingest path Ingests a source through the anomaly gate.

/guild:wiki query "text" Searches the canonical wiki.

/guild:wiki lint Checks wiki structure and expired entries.

Goals & initiatives

/guild:goal from-spec slug Creates portable P.O.V.E.R. goals from an approved spec.

/guild:initiative new [id] Creates an opt-in durable work scope.

/guild:initiative close [id] Closes only after the D8 close gate resolves.

Configuration

/guild:config init Scaffolds or reconciles .guild/settings.json without clobbering user values.

/guild:config show --sources Prints resolved settings with the inheritance layer that won for each key.

/guild:config set key value Writes one known key to the chosen settings layer.

Maintenance

/guild:evolve [id] [--auto] Runs the skill evolution pipeline; promotion stays human-gated.

/guild:rollback skill [n] Restores a previous skill version.

/guild:migrate Converts a v1 .guild/ directory to v2 layout (dry-run by default).

/guild:audit Runs read-only static security and boundary checks.

/guild:stats Shows usage and telemetry stats.

The everyday command is:

/guild:guild "your task"

That starts a traceable run, proposes the next lifecycle phase, and asks before load-bearing work proceeds. Sub-verbs such as wiki query, config show, learn graph, and initiative close are positional arguments to one command. They are not nested command files.

Start work        /guild:guild "brief"
Jump a phase      /guild:init | /guild:ideate | /guild:plan | /guild:build | /guild:qa | /guild:ops
Inspect/recover   /guild:status | /guild:resume | /guild:fix
Use knowledge     /guild:learn ... | /guild:wiki ...
Track goals       /guild:goal ... | /guild:initiative ...
Tune behavior     /guild:config ... plus global flags
Maintain Guild    /guild:evolve | /guild:rollback | /guild:migrate | /guild:audit | /guild:stats

Which command do I want?

| Job | Start here | Why | |---|---| | Start from a normal brief | /guild:guild "your task" | Lets Guild detect the next phase from .guild/ state and show the proposal. | | Get an existing repo ready | /guild:init | Builds the first project context and wiki scaffolding. Add --learn for deeper learning. | | Turn an idea into a spec | /guild:ideate "brief" | Produces the spec and asks for approval before planning. | | Decide who works and in what order | /guild:plan | Composes the phase team, writes the lane plan, and asks for approval. | | Execute an approved plan | /guild:build | Dispatches lanes, writes handoffs, reviews, and verifies done. | | Check release readiness | /guild:qa | Selects the Quality matrix and records the release recommendation. | | Run a release, incident, rollback, or maintenance path | /guild:ops release | Executes an approved runbook under safety rails. | | See what is happening | /guild:status | Reads .guild/ state and reports the active phase, next gate, and blockers. | | Continue after a pause | /guild:resume | Continues from the next pending gate or phase checkpoint. | | Diagnose a suspicious run | /guild:fix run-id | Writes a diagnosis and fix plan, then asks before edits. | | Search or maintain project knowledge | /guild:wiki query "topic" | Reads the canonical .guild/wiki/** knowledge model. | | Change a setting | /guild:config set key value | Writes a known config key through the closed-key authoring surface. | | Track work across sessions | /guild:initiative new | Creates an opt-in durable wrapper; one-off runs remain first-class. | | Open the local dashboard | /guild:dashboard | Opens the localhost view over runs and knowledge. |

Command jobs

Run the lifecycle

Use these when you are moving one task through the six phases.

Command	Phase	What it does	Main evidence
/guild:guild [brief]	Smart entry	Detects the next phase from .guild/ state, surfaces the proposal, and proceeds only after confirmation.	Run trace plus phase artifacts.
/guild:init [--learn] [--new]	Init	Onboards an existing repo or scaffolds new-product knowledge. --learn runs the deeper learn subset.	.guild/init/slug.md, .guild/wiki/**, codebase map.
/guild:ideate [brief] [--skip]	Ideation	Produces the spec; standard and deep rigor include the clarify loop.	.guild/spec/slug.md.
/guild:plan [--team-size=N]	Planning	Composes the phase team, writes the plan, and records the autonomy contract.	.guild/team/slug.phase.yaml, .guild/plan/slug.md.
/guild:build [lane-id]	Development	Assembles context, dispatches lanes, reviews, and verifies done.	Context bundles, handoff receipts, assumptions.md, review.md, verify.md.
/guild:qa [run-id]	Quality	Selects E2E, smoke, accessibility, performance, and integration checks from project signals; shows the matrix before execution.	.guild/runs/run-id/quality/run-id.md.
/guild:ops [runbook]	Operations	Runs release, monitoring, incident, rollback, or maintenance runbooks under safety rails.	.guild/runs/run-id/ops/run-id.md.

The lifecycle has six phases: Init, Ideation, Planning, Development, Quality, and Operations. Reflection is cross-phase and writes proposals only; promotion remains human-gated.

Inspect or recover a run

Command	What it does
/guild:status [--no-index]	Reads current run state, furthest phase, next gate, and blockers. Read-only.
/guild:resume [--no-index] [--restart]	Continues the active run from the next pending gate. --restart forces a fresh loop after confirmation.
/guild:dashboard [--port N] [--no-import] [--install] [--dry-run] [--stop]	Launches the local dashboard over recorded runs and knowledge. It binds locally; clone/install work needs --install or confirmation.

Build or query knowledge

Guild Stack’s durable knowledge lives in .guild/wiki/**. The KnowledgeGraph, links layer, recall projections, and indexes are derived and rebuildable.

Command	What it does
`/guild:learn [map	graph
/guild:wiki ingest path	Ingests a source into the project wiki through the anomaly gate.
/guild:wiki query "text"	Searches the wiki through filesystem search or the optional memory index, depending on project size and availability.
/guild:wiki lint	Checks wiki structure, fields, and expired entries.

Shape plans and initiatives

A run produces evidence. An initiative owns progress. Initiatives are opt-in; a one-off run does not silently attach to one.

Command	What it does
/guild:goal from-spec slug	Creates portable P.O.V.E.R. goals or task groups from an approved spec.
/guild:goal new slug	Starts a goal body manually.
/guild:goal list	Lists goals.
/guild:goal show goal-id	Shows a goal.
/guild:initiative new [id]	Creates an opt-in durable work scope.
/guild:initiative status [id]	Shows initiative state, spec, and plan.
/guild:initiative list [--archived]	Lists active and archived initiatives.
/guild:initiative resume [id]	Resumes an initiative.
/guild:initiative update [id]	Updates the initiative definition ledger.
/guild:initiative archive [id]	Archives without the close-gate release path.
/guild:initiative restore [id]	Restores an archived initiative.
/guild:initiative close [id]	Closes only after the D8 close gate resolves: execution verified, release readiness resolved, and documentation sync resolved.

Configure behavior

Guild Stack uses one config file: .guild/settings.json. Settings resolve through seven sources, with CLI flags winning, and validation rejects unknown keys.

Command	What it does
/guild:config init	Scaffolds or reconciles .guild/settings.json without clobbering user values.
/guild:config show --sources	Prints resolved settings with the inheritance layer that won for each key.
/guild:config show --render	Renders the resolved config into supported host-native config shapes.
`/guild:config set key value —scope workspace	project
/guild:config role role host_id-or-null --scope scope	Pins or clears a per-run role host. role is host, advisory, or adversarial.
/guild:config validate [--effective]	Runs closed-key validation on raw or resolved config.
/guild:config providers detect	Probes available cross-review providers and prints a read-only table.
`/guild:config ui list	get
`/guild:config reconcile check	sync
/guild:config update-mcp-hashes	Re-pins MCP tool-description hashes.

Model choice is expressed through tiers: cheap, mid, and powerful. Exact model ids belong in configuration and lane routing; do not rely on bare family shorthand.

Maintain Guild Stack itself

Command	What it does
`/guild:fix [run-id	”symptom”] [—review=cross]`
`/guild:migrate [—root=path] [—mode=migrate	dry-run
/guild:evolve [id] [--auto] [--to-template=vN]	Runs the skill evolution pipeline. --auto keeps the promotion gate respected; it does not bypass human-gated promotion policy.
/guild:rollback skill [n]	Restores a previous skill version by snapshotting current state and restoring the selected version.
/guild:stats [--rebuild-index] [--no-index]	Shows usage and telemetry stats.
/guild:audit	Runs read-only static security and boundary checks over installed Guild Stack scripts.

Reference: global and common flags

Lifecycle entries share the run-shaping flags below. Some maintenance and noun commands accept only their local flags; when in doubt, use the command-specific usage row above.

Flag	Values	What it controls
--rigor	quick, standard, deep	Expands loop, cap, and review settings. deep enables the strongest built-in loop posture.
--review	local, cross, off	Selects review posture. cross is strongest when a different-family result adapter is shipped and available; weaker fallbacks are recorded.
--host	canonical host id, legacy alias claude or codex, or auto	Selects the host adapter for the run. Legacy aliases normalize to canonical ids; auto means the originating host executes.
--auto-approve	spec, plan, build, qa, all	Clears soft approval pauses. Destructive, network, spend, production-sensitive actions, and Quality BLOCK overrides still ask. There is no ops token.
--initiative	id or new	Attaches the run to an explicit initiative.
--dry-run	flag	Prints the plan without executing or writing task artifacts where the command supports simulation.
--model-tier	cheap, mid, powerful	Pins the model tier for the run.
--agent-mode	team, agent, subagent, auto	Pins the dispatch backend selection for the run.
--team-size	integer	Local to /guild:plan; lifts the default team-size cap with a warning above 6.
--learn	flag	Local to /guild:init; runs Init’s learn subset.

Running hands-off

The maximum-autonomy green path is:

/guild:guild "<brief>" --auto-approve=all --rigor=standard

This can clear spec, plan, build, and PASS-ing Quality pauses. The always-ask hard set remains: destructive writes, non-localhost network work, spend, production-sensitive actions, Quality BLOCK override, and Operations safety rails still interrupt.

Add cross review when you want stronger adversarial pressure:

/guild:guild "<brief>" --review=cross

Today the shipped strong result-adapter family is Codex, so Claude-authored work can be reviewed by Codex. Other author/reviewer pairings remain design targets until their result adapters ship; Guild Stack records weak or skipped review rather than claiming equal parity.

Harness developer note

The command surface is intentionally flat. Users type commands; Guild Stack invokes skills such as guild:brainstorm, guild:team-compose, and guild:review-broker as model-invoked workflow pieces. Command files are the public surface, while phase logic, routing, config resolution, dispatch, review, and telemetry live in the owned modules and scripts behind that surface.

v1 command removals

These v1 command names were removed in v2.0:

v1 command	v2 replacement
/guild:guild-wiki	/guild:wiki ingest|query|lint
/guild:guild-evolve	/guild:evolve [skill] [--auto]
/guild:guild-rollback	/guild:rollback skill [n]
/guild:guild-stats	/guild:stats
/guild:guild-audit	/guild:audit
/guild:guild-diagnose	`/guild:fix [run-id

/guild:guild-team was removed outright. Team composition is now part of /guild:plan.

Related

• How Guild Stack works - the lifecycle these commands drive.
• Get Started with Guild Stack - install, host Support labels, and first run.
• Configuration Reference - persistent settings and inheritance.
• Adversarial review - review modes, trails, and weak fallback.
• Quality & operations - /guild:qa and /guild:ops.
• Project Memory & Wiki - canonical knowledge and derived indexes.
• v1 to v2 Migration - full migration guide.