CLI commands

Scan PATH for known local coding CLIs (claude/codex/opencode/aider/ollama).

Show providers configured in this project.

Send a tiny no-op prompt to a configured provider and look for the magic token.

Assign every default agent to use the given provider.

Guided provider setup wizard.

Remove a provider from project.yml (refuses if a role still uses it).

Show the provider capability catalog (built-in + your .vibestrate/providers-catalog.yml overlay).

Detect each provider's real models/efforts (codex `debug models` JSON, else --help scraping) and write them to the catalog overlay. Refreshes stale built-in lists; local only.

Readable, grouped view of the config - each section shows where it's editable.

Print the raw config YAML and validate it.

Print a single config value (dot-path, e.g. commands.validate).

Set a config value. Booleans/numbers/strings parsed automatically; arrays/objects via JSON (e.g. 'vibe config set commands.validate "[\"pnpm test\"]"').

List every settable config key with its type, allowed values, and default (from the schema).

Validate the project.yml file against the Vibestrate schema.

Show every discovered skill and which agents use it.

Print a skill's full SKILL.md body.

Attach a skill to an agent (writes to .vibestrate/project.yml).

Remove a skill from an agent.

Fetch a skill markdown from an http(s) URL into .vibestrate/skills/ (guarded + secret-redacted).

Show every discovered Flow.

Print a Flow's seats, ordered steps, and crew seat-coverage.

Set the default Flow applied to runs without --flow (always shown), or --clear it.

Suggest a Flow from task risk signals and local Flow outcomes.

Turn an English description into an editable Flow draft (supervisor-assisted). Draft only - never writes; adopt it with `flows import`.

Build a Flow around a specific task: a shaping turn decomposes the work, deterministic code compiles the graph. Draft only - never writes; adopt it with `flows import`.

Export a Flow as canonical YAML (for sharing / backup).

Import a Flow from a local file path or an http(s) URL into .vibestrate/flows/.

Export a Quality Arbitration run as local JSON evidence for later evaluation.

Browse + install Flows from the community hub (vibestrate.com/api/hub).

List the resolved supervisor personas (built-ins + project).

List the curated supervisor archetypes you can adopt.

Adopt a curated archetype into this project's personas.

Set the project's default supervisor (built-in or a project persona).

Remove a project persona (not a built-in or the active default).

Stop the supervisor acting. It still answers.

Let the supervisor act again.

Whether the supervisor may act right now.

List profiles, grouped by provider, with how many roles use each.

Create a new profile.

Edit an existing profile's fields.

Copy a profile under a new id (e.g. claude -> claude-cheap).

Delete a profile (refuses if a role uses it, unless --force).

List every stored param answer (secrets shown as env refs).

Print one stored value (secrets shown as env refs).

Set one or more values: `vibe params set --flow <id> name=Acme niche=SaaS`. With --flow, keys are flow params (type-checked, secret-aware). Without it, keys are raw param keys (bare = project-global).

Draft a value for a `generate`-enabled param via a provider (optional, user-initiated, reviewed). Prints a suggestion; --accept stores it.

Remove stored values by key (explicit, never automatic).

List configured crews (the default is marked).

Show a crew's roles, profiles, and seats (default crew if omitted).

Set the default ("active") crew - runs without --crew use it.

Turn an English description into an editable Crew draft (supervisor-assisted). Draft only - never writes; adopting it means saving the printed role files, then the block, into project.yml.

Ready-made crews (fast / thorough / cheap / local) tuned by provider effort.

Show all approval requests for a run.

Show a single approval request in detail.

Approve a pending approval. Resumes the run if it is waiting.

Reject a pending approval. The run will be marked `blocked`.

Return an agent-requested gate with guidance; the stage re-runs with it.

Create the .vibestrate/roadmap/ scaffold if missing.

Add a roadmap item.

List roadmap items.

Show a single roadmap item.

Update a roadmap item.

Archive a roadmap item (keeps history).

List roadmap proposals stored in .vibestrate/roadmap/proposals/.

Inspect, parse, and accept individual proposals.

Accept a parsed proposal (creates roadmap items + tasks atomically). Omit the id to pick one with TAB.

Run the configured local planner provider on a broad goal and save the output as a proposal draft.

Start spec-up: launch the intake run that asks the gap questions.

Show the intake run's gap questions (and their ids).

Answer a round's questions; loops to a gap-check round or builds the spec.

Explain a question in plain language (what it asks + what it affects).

Draft an answer grounded in your prior answers (you still decide). --all for every blank.

Approve the spec-up draft and launch the roadmap synthesis run.

Approve the spec-up draft and BUILD it: run the chosen flow seeded with the approved spec.

Turn a finished spec-up-roadmap run into a reviewable proposal.

Edit a spec-up section (scope/spec/architecture/risks) before the build, via $EDITOR or --file. Guarded: secret-refusing, blocked after approve.

Create a task.

List tasks.

Suggest which backlog card to pick up next (ready + priority).

Show a task with comments and run history.

Add a comment to a task.

Write the board as CSV (Jira / Trello / Monday / Linear all import it).

Create tasks from a CSV exported by another tracker. Additive: never updates or deletes an existing card.

File a task under a workflow stage (free label). No arguments clears it. Re-filing runs nothing - it only moves the label.

Mark a task ready to run.

Cancel a task.

Archive a task (files it into the board's Archived column).

Un-archive a task.

Permanently remove a task card (refuses while its run is live).

Add a task to the scheduler queue.

Run this task now (foreground). A supervised task sequences its steps (the Conductor); a plain task runs the default flow once.

Sequence a supervised task's steps in order (the Conductor). The stable entry the scheduler spawns; `run` delegates here for supervised tasks.

Show a supervised task's live conductor status (lifecycle, steps, invariants, halt).

Pause a supervised task's live run (between steps).

Resume a paused supervised task, or re-sequence a halted one from the clean tip.

Execute the task's checklist item-by-item (pick-up flow). Continuous by default; --step pauses between items.

Manage a task's in-card checklist (the ordered breakdown of items).

Propose a checklist for a task with an AI assist (read-only). Add --apply to append the items.

Generate a Markdown task report at .vibestrate/roadmap/tasks/<id>-report.md.

List merge-ready runs (integration candidates).

Dry-run merge the selected (or all) merge-ready branches; show conflicts.

Read-only merge advice for the selected (or all) merge-ready runs: risk flags, assurance lanes, topology, dry-run conflicts, and a deterministic recommendation. Mutates nothing.

Prepare a pull request for a run: writes the body from the run's own record and prints the `gh pr create` line. Vibestrate never pushes - you run it.

Optional read-only LLM pass over the run's redacted diff vs main: semantic risk narrative (never a merge verdict). Spawns a local provider; caches markdown under the run.

Integrate the selected (or all) merge-ready branches into --into <branch>.

Merge a complete, clean integration branch into main - locally, with explicit confirmation, never pushed. Refuses partial integrations, dirty trees, and conflicts.

Show the queue and running tasks.

Add a task to the queue.

Remove a task from the queue.

Start the local scheduler loop and process queued tasks.

Pause the scheduler (new tasks will not start).

Resume the scheduler.

Print a launchd/systemd unit that brings the scheduler back after a reboot. Prints it - installing is yours to do.

Print scheduler state and recent conflict warnings.

Print the OTLP trace JSON for a run (no network - inspect before exporting).

Export a run's metrics as an OTLP trace to a collector (Langfuse, Tempo, Jaeger…).

List registered projects (live ● / dormant ○).

Register a project directory (default: the current directory).

Remove a project from the workspace registry (leaves it on disk).

Open a project's dashboard, starting it (server + scheduler) if dormant.

Shut down a project's dashboard + scheduler (refuses if busy unless --force).

Cross-project rollup: runs + cost across every registered project.

Show notifications.

Mark a notification read.

Mark a notification resolved.

Mark every unread notification as read.

Show current notification settings and configured gateways.

Send a tiny test notification through a configured gateway.

Show available gateways and their enabled/valid status.

Send a test message through a gateway (no real notification persisted).

Enable a configured gateway.

Disable a gateway. Existing config is preserved.

Probe known editors (code, code-insiders, cursor) for availability.

Enable editor handoff and store the command (default args use --goto path:line:column).

Open a file (default: README.md) using the configured editor command.

List every suggestion attached to a run.

Show one suggestion in detail (including any proposed patch).

Approve a suggestion (creates and resolves an approval record).

Reject a suggestion. Records a rejection in approvals.json.

Apply an approved suggestion's proposedPatch inside the run's worktree (git apply, never push/merge).

Run the project's commands.validate inside the run's worktree against an applied suggestion.

Revert a previously-applied suggestion using the captured patch (git apply -R).

Read or edit a suggestion's validation profile metadata.

List every bundle (review pass) attached to a run.

Create a new review pass (bundle) for a run.

Add a suggestion to a draft bundle.

Remove a suggestion from a draft bundle.

Approve a review pass (gate before apply).

Reject a review pass.

Apply every suggestion in the review pass to the run worktree (all-or-nothing with rollback).

Apply suggestions one-by-one in order. Earlier successes stay applied if a later step fails.

Run commands.validate against the run worktree, attached to a bundle.

Revert every suggestion in the review pass via git apply -R (worktree only).

Run a static-only preflight without modifying the worktree.

Read or edit a review pass's validation profile metadata.

List the implicit default + every named validation profile.

Show how often each validation profile has actually run (`commands.validate` use counts as 'default').

Inspect, manage, and migrate validation profile references.

List every terminal session ever opened in this project (live + closed).

Mark a terminal session as closed. Only affects live sessions in the running dashboard process; closed sessions are already terminal.

Add a project policy (active immediately). advise by default; --block for a deterministic merge-cap.

Remove a project policy.

Confirm a pending (supervisor-proposed) policy - it goes live.

Reject a pending (supervisor-proposed) policy - removes it.

Lift legacy persona-scoped preferences into project policies and remove the old keys.

Turn an English rule into an editable policy draft (supervisor-assisted). Draft only - never writes; adopt it with `policies add`.

Propose candidate policies from recent runs' diffs (supervisor-assisted). Draft only - never writes.

Dry-run a matcher against a diff snippet or recent runs (read-only). Give an existing block-policy id, or --regex.

List the project's policies (owner-authored tiered rules) and the hard security gates in .vibestrate/policies/*.yml.

Apply the loaded policy rules to a patch file (unified diff). Read-only - never applies, never executes.

Validate rule YAML, list malformed files, surface duplicate ids and empty-rule files.

Show or set the safety behavior toggles (strict apply-only, terminal, forbid-* guards).

Hand-add a ledger entry - the same write path the dashboard's "Add entry" form uses.

Print the current CODEBASE.md (run `vibe learn` first if there is none).

Print the harvested TODO counts. `vibe todos` reviews and promotes them.

Promote harvested TODOs onto the Board. Omit the fingerprint to pick one with TAB.

Set TODOs aside so later scans stop offering them. Reversible with `undismiss`.

Bring dismissed TODOs back into the review list.

Show the configured cap, action, and today's spend so far.

Set the daily spend cap and/or the action taken when it's reached.

Remove the daily spend cap.

Print the project's VIBESTRATE.md (or note that there is none).

Scaffold a starter VIBESTRATE.md at the project root (refuses if one exists).

List open VIBESTRATE.md proposals (e.g. from consult).

Apply a proposal - append its text to VIBESTRATE.md (guarded write).

Reject a proposal (keeps it on record, marked rejected).

Delete rewind-snapshot refs you choose to drop: orphans (run dir gone), beyond a keep-N window, or one run. Shows the plan and confirms first; never purges on its own.