Справочник команд

Каждая команда, которую принимает vibe, с её опциями, словами самой программы. Ничто на этой странице не написано руками.

Каждая команда принимает `--json` для машинного вывода, `--quiet` для однострочной сводки, `--invoked-by <agent>`, чтобы проставить вызывающего в отчёты, `--unattended`, чтобы ответить на все подтверждения, `--offline`, чтобы запретить доступ к сети, и `--agent-mode`, чтобы сказать, как выполняются агентные шаги. Полный текст:

vibevm: a CLI software project manager for spec-driven AI-assisted development. Manages installable building blocks — flow, feat, stack, tool, mcp, lang, doc, app — and assembles them into project-level spec content that AI agents read at session boot. Usage: vibe [OPTIONS] <COMMAND> Commands: init Scaffold a new vibevm project in the target directory list List the packages recorded in the project's lockfile extensions List every extension declaration in the selected installed world validate Validate the workspace, without network access or materialisation install Install one or more packages into the current project generate Run the default lifecycle through generated-source production build Run the default lifecycle through deterministic build work test Run the default lifecycle through deterministic tests create Run the default lifecycle through agentic creation verify Run the default lifecycle through output verification package Run the default lifecycle through distributable assembly deploy Run all nine default-lifecycle phases through deployment, then reconcile the selected deploy profile's targets. `--plan` reports the planned work read-only instead of running the chain undeploy Reverse the selected deploy profile: remove every receipt-owned resource, in reverse dependency order. It removes only what a receipt still owns, and refuses a path changed after deployment deployments List the deployments this machine holds receipts for — project, profile, target, generation, status, scope and timestamps. Never secrets. Read-only; `--json` emits the machine form clean Remove the derived prompt state — dependency slots and generated boot artifacts — keeping every authored file, the lock, and the machine cache. Any lifecycle phase may follow the clean prefix scrape Plan or perform terminal removal of the selected VibeVM project layer. `attach` and `detach` remain reserved for a future live-tool surface outdated Show installed packages whose registry-side latest version is newer than what the lockfile currently pins. Read-only — does not touch the lockfile or fetch package content. Per PROP-003 §M1.10 search Search the configured `[[registry]]` entries for packages whose description, name, keywords, or capabilities match a query. Walks each registry's index server (resolved via `VIBEVM_INDEX_URL_<R>` per PROP-005); registries without an index URL or unreachable servers are reported but do not abort the run. Per ROADMAP §M2.10 mcp Start the MCP (Model Context Protocol) server over stdio, exposing the project's lockfile and active subskills to a connected coding agent (Claude Code, Cursor, etc.). Per PROP-004 §5.1 / ROADMAP §M1.7. Reads JSON-RPC 2.0 requests line-by-line from stdin; writes responses to stdout aiui The agent-facing observation surface (PROP-042). `vibe aiui render` renders the `vibe tree` TUI headlessly to a symbolic snapshot (text or cells) — no terminal, deterministic — so an agent can *see* the interface and golden tests can diff it. Read-only term Launch the vibeterm terminal app hosting a detected interactive shell (Windows prefers PowerShell 7 `pwsh`; unix uses `$SHELL`). The terminal an agent or human can observe; `--exec` overrides the shell (PROP-042 §5) frame Launch the vibeframe terminal — the simple terminal frame VibeTree runs in (a copy of vibeterm's minimal single-window terminal). Same flags as `term`; hosts the detected shell or `--exec` skill Project package-declared skills into coding agents — vibevm's standalone mode (PROP-018 §2.6). `vibe skill list` shows what the installed packages (and the project itself) declare via `[[skill]]`; `vibe skill install` writes each into the target agents' skill directories. No LLM required agentic Compose an LLM instruction for the calling agent and park it in the relay — vibevm's agentic mode (PROP-018 §2.7, §2.10). vibevm has no inference engine yet, so `vibe agentic explain` does not act: it queues a project-explanation task that the agent fetches with `vibe command` and runs on its own LLM command Drain the agentic relay: print the instruction a `vibe agentic …` command parked in `.vibe/agentic/command.md` (PROP-018 §2.7) and clear the slot. Prints "no pending command" when the mailbox is empty. The calling agent runs this, then carries out the printed instruction uninstall Remove an installed package from the current project update Re-fetch and apply changes for one or more installed packages reinstall Recompute the materialised dependencies and the boot artifacts of a workspace without re-resolving (PROP-009 §2.10) check Run the spec-consistency linter against the project tree doc Work with a documentation package (PROP-057). `vibe doc check --examples` runs every documented command in a sandbox and compares its output with what the page promises, exactly facts Inspect and edit the project's consumer-owned adoption-facts registry requirements One bounded, read-only metadata answer about what the selected project's specs declare and what it recorded about them (PROP-054 `##REF-REQUIREMENTS-SURFACES`): per addressed fact its authoring status, this project's consumer adoption, and — with `--relations` — the edges a specmap carries. `--json` is the generated report exactly; combining the axes into a verdict is never this query's why Explain why a package is in (or out of) this project's effective world: the admitting chain with its rule, or the blocked edges and what blocked them (PROP-050 ##VIBE-WHY) refactor Meaning-preserving rewrites of authored source trees friends The sealed-circle report for one provider: open / sealed / the named circle, who actually befriends it, which grants its allow-friends rejects, and whether it is in the root's friend closure (PROP-050 ##ALLOW-FRIENDS-EXHAUSTIVE) show Inspect computed project state (effective spec, configuration) prefs Inspect and edit application/user preferences — the three-level app-prefs store (`vibe-settings`, PROP-040 §8). `vibe prefs get/set/ list/check/migrate` plus `vibe prefs show-origins`. Distinct from `vibe show config` (the project-config view) tree Analyze the resolved spec/dependency tree (PROP-036): the effective boot load type per package (`static` / `dynamic` / `none`), the transitive / condition / static-lane flags, the two boot lanes, and the in-place `@spec` markers. Read-only. `--json` emits the machine model (validated against the shipped `package-tree.schema.v1.json`); a non-tty or `--plain` renders a static ASCII tree registry Manage the registry cache (clone, sync) cache Operate on the machine-global package store `~/.vibe/cache/` (PROP-010 §2.8): `path` prints its root, `list` the offline-resolvable inventory, `add` pre-warms packages (and their dependency closure) into it without touching any project, `clean` reclaims space — all, by age, or by package, always as an explicit operator action. Top-level on purpose: the store is machine-global and its headline case is work that has no project yet workspace Operate on a multi-package workspace (PROP-007). Today the one subcommand is `publish` — walk the workspace's self-publishing members in dependency order and publish each as its own repository self Manage vibevm's own versions on this machine — the VibeVM Version Manager (VVM, PROP-019). `vibe self install <selector>` builds and installs a version from source; `vibe self use` switches the active one; `vibe self ls` lists what is installed. Self-distribution: the `vibe` binary manages its own versions tools The registry of what this project can invoke: every `[[binary]]` and every `[[mcp_server]]` the installed packages declare, in one table. The boot lane already names which language disciplines are installed; this names what they brought that can be RUN. `--json` for agents bin Build and dispatch the tools installed packages declare via `[[binary]]` (PROP-025): `list` the table, `build` (consent-gated) into the slot, `path` an artifact, `exec` through the project's lockfile — the rustup dispatch model explain Traceability explain over THIS tree (PROP-014 §2.6): build the specmap fresh in memory and render what implements, verifies, documents, or deviates from a spec unit or code symbol — the host's built-in answer to the canonical "which test verifies this rule?" (`vibe explain "spec://…#anchor"`). `--json` emits the raw one-hop subgraph; the default is the deterministic text view. Contrast `vibe trace`, a delegating alias to the installed stack's `trace` query Search the code↔spec map by independent filters (A5A-MAPSEARCH): `--uri` (exact spec address), `--symbol` (substring of a code symbol), and `--kind` (a code `item_kind` or a spec unit kind), AND-joined, over a hard result ceiling (`--limit`, default 50, max 200; no unbounded mode). None is required — bare `vibe query` shows a bounded slice of the whole map, with truncation named. The grep-like counterpart to `vibe explain` (a point lookup): `explain` looks at ONE target's subgraph; `query` FINDS the many nodes that fit. `--json` emits the machine-readable form. Read-only select Search the code↔spec map by a conjunctive predicate query and walk the bipartite graph (E-A5B-QUERYLANG) — the traversal layer over `vibe query`. `--where` carries the query: `uri:`/`symbol:`/`kind:` (the same filters as `query`), `scope:` (a `spec://` prefix), `has:`/`lacks:` (a verb an edge does/does not touch), and `depth:<0..3>` (an undirected walk; seeds stay at `d0`). Predicates are whitespace-AND-joined. Reach for `select` over `query` when the answer is relational — "every spec rule with NO verifier" (`lacks:verifies`), "the implementers of this rule and one hop around them" (`uri:… depth:1`); reach for `query` for a flat filter, and `explain` for one target's subgraph. `--json` emits the machine-readable form. Read-only specmap Generate the package's carried traceability map (V5-PACKAGE-MAP §2.2). Reads the package's `vibe.toml` (for its `(group, name)` coordinate) and `specmap.toml` (its scan policy; presence is the opt-in), and writes the map — built fresh with the same engine `vibe explain` uses — minted under the coordinate `spec://<group>/<name>/…` (globally unique, where the local `specmap.toml` nickname is not), so a consumer can query an installed package without rebuilding. A package without a `specmap.toml` is left untouched. Read-only to the tree outside the one map file trace Traceability queries over the project's specmap (PROP-014 §2.6) — a delegating alias: arguments pass through verbatim to the installed `rust-ai-native trace` (the engine ships with the discipline stack and versions with the project, not with vibe). Example: `vibe trace explain "spec://<ns>/<doc>#<anchor>"` vars Print the runtime variable context — the values vibevm actually uses (derived from the running binary's location) versus the environment, so scripts can reconcile a stale `$VIBEVM_HOME` (PROP-019 §2.14). Modes: `vibe vars`, `vibe vars diff`, `vibe vars full`, `vibe vars full diff` progress Progress Control (PROP-043): scan/validate the inline `<status>` markup, render reports, and drive the actualization campaign (mirror, weave, rescan, resume) version Print version information help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') -V, --version Print version
Scaffold a new vibevm project in the target directory Usage: vibe init [OPTIONS] [POSITIONAL]... Arguments: [POSITIONAL]... Positional arguments: `[package|group] [pkgref] [path]`. Forms: vibe init — project in CWD (legacy) vibe init projectname — project in projectname/ vibe init org.vibevm.apple projectname — project + package in projectname/ vibe init org.vibevm.apple — project + package in CWD vibe init org.vibevm.apple/orange — project + package in CWD vibe init package org.vibevm.apple/orange [path] — add package vibe init group org.vibevm.apple [path] — add group Options: --json Produce machine-readable JSON output --path <PATH> Directory to initialize (back-compat with `--path .`). When positional path is also given, the positional wins --quiet Reduce output to a single summary line (useful in scripts / CI) --stack <STACK> Pre-set the active stack name (still requires installation separately) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --name <NAME> Project name; defaults to the basename of the target directory --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --registry-url <REGISTRY_URL> Override the default registry URL written into `vibe.toml` --registry-ref <REGISTRY_REF> Override the default ref (`main`) recorded under `[registry]` --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-registry Do not write a `[registry]` section into `vibe.toml` --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --kind <KIND> Package kind: flow, feat, stack, tool, mcp, lang, doc, app. Default: tool --translates <COORDINATE> Scaffold a translation of the documentation at `<group>/<name>`: mirrors the source's pages and copies its `[[documents]]`. Requires `--kind doc`; the language comes from this package's own name, which a translation spells `<docname>-<lang>` --version <VERSION> Package/project version. Default: 0.1.0 for packages, 0.0.1 for projects --author <AUTHORS> Author name (can be repeated). Default: detected from git config --license <LICENSE> License. Default: UPL-1.0 --description <DESCRIPTION> One-line description --format <FORMAT> Package format: simple or normal. Default: simple --link <LINK> Link type for the boot snippet: static or dynamic. Default: static for project+package, dynamic for `init package` -h, --help Print help (see a summary with '-h') Install one or more packages into the current project Usage: vibe install [OPTIONS] [PACKAGES]... Arguments: [PACKAGES]... Zero or more package references, each `<kind>:<name>[@<version>]`. When empty, `vibe install` reads the project's `vibe.toml` `[requires].packages` and installs every entry — same shape as `cargo build` / `npm install` against an existing manifest. When non-empty, each pkgref is added to (or updates the constraint on) `vibe.toml` `[requires].packages` Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry (M0 only; M1 adds git registry) --assume-yes Skip the interactive confirmation prompt (non-interactive envs) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this install (PROP-003 §2.7). BCP-47 tag (`ru`, `ja`, `pt-BR`). When set, supplies the head of the language fallback chain; canonical (no-suffix) content is always the last fallback. Without this flag, the project-level `[i18n]` block in `vibe.toml` decides; absent any declaration, English-only --features <FEATURES> Activate one or more features on every root package (PROP-003 §2.4). Repeatable, and accepts comma-separated lists: `--features a,b --features c` is equivalent to passing `a`, `b`, `c` together. Underscore-prefixed implementation-detail features cannot be activated this way. Default features are also included unless `--no-default-features` is set --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Skip activation of `[features].default` entries on every root package. Combined with `--features X,Y`, only the explicitly listed features are active --all-features Activate every non-private (no `_`-prefixed) feature on every root package. Mutually exclusive with `--features`; when both are set, `--all-features` wins --exact Pin the resolved version exactly (`=x.y.z`) instead of the default caret constraint (`^x.y.z`) when writing pkgrefs to `vibe.toml` `[requires].packages`. Same semantics as npm's `--save-exact`. Overrides whatever constraint shape the user supplied on the CLI, including explicit caret / tilde / range --auth-required Strict authentication gate — when set, a 401 / 403 against an `auth = "none"` (public) registry halts the install instead of walking to the next registry. Default behaviour (without this flag) follows PROP-002 §2.3.1: public-401 means "no public answer here", walk past, useful when the host returns 401 for missing public repos (GitVerse). Strict mode is for CI / cron where an authenticated registry is supposed to answer; if its 401 leaks through to a public fallback, you want to know rather than silently install a different package. Per-registry `auth = "token-env"` / `"credential-helper"` halt on 401 regardless of this flag --solver <naive|sat|resolvo> Select the dependency solver cell (PROP-017). Defaults to `resolvo` (CDCL SAT); `naive` (DFS fast path) and `sat` (backtracking) are selectable fallbacks --prefer-embedded PROP-030: prefer the embedded registry (a source install's in-tree `packages/`) over the declared `[[registry]]` walk on a coordinate clash — already the default for a source-installed developer; this flag forces it. Mutually exclusive with `--no-prefer-embedded` --no-prefer-embedded PROP-030: consult the declared `[[registry]]` walk before the embedded registry, so a published package wins a coordinate clash and the embedded copy only fills gaps. Mutually exclusive with `--prefer-embedded` --no-default-registry PROP-030: ignore the ambient embedded registry entirely for this command — resolve only from the declared `[[registry]]` walk. Also set by `VIBE_NO_DEFAULT_REGISTRY=1` --offline PROP-030 §3.1: resolve strictly offline — consult only the embedded registry and explicit local / path sources, never a network `[[registry]]`. No git host is contacted; a package not available locally fails without a single network request (and thus without any credential prompt). Contrast `--embedded-short-circuit`, which still reaches the network for coordinates the embedded registry lacks --embedded-short-circuit PROP-030 §3.1: prefer the embedded registry and short-circuit the network for every coordinate it already provides — the declared `[[registry]]` walk is consulted ONLY for packages the embedded registry does not carry. A fully-embedded dependency graph resolves with zero network access (no version-enumeration round-trip, no credential prompt), while a genuinely missing package is still fetched from the network. Implies embedded-first precedence; mutually exclusive with `--no-prefer-embedded` --prefer-local PROP-030 §3.3: explicitly opt in to project-local packages (the `<project_root>/packages/` directory) winning a clash inside the local-registry family. This is already the default when project-packages are discovered; the flag is an explicit affirmation (mirrors `--prefer-embedded`'s relationship to its default). Mutually exclusive with `--no-prefer-local` --no-prefer-local PROP-030 §3.3: ignore the project-local `packages/` directory for this command — resolve only from vibe-embedded (when available) and the declared `[[registry]]` walk. Use when a project's `packages/` is stale, broken, or being deliberately bypassed. Mutually exclusive with `--prefer-local`. Does NOT suppress vibe-embedded — for that, use `--no-default-registry` --git <URL> Add a git-source declaration for the single positional pkgref — fetches the package directly from this git URL rather than resolving it through `[[registry]]`. PROP-002 §2.4.1. Requires exactly one of `--tag`, `--branch`, or `--rev`. Cannot be combined with `--exact` (constraint shape is orthogonal to git-source) or with `--registry` (git-source bypasses the registry layer) --tag <TAG> Git tag to pin against when `--git <url>` is set. Mutually exclusive with `--branch` / `--rev`. Immutable; force-pushed tag rewrite caught as `IntegrityError` on next install via content-hash. PROP-002 §2.4.1 --branch <BRANCH> Git branch to track when `--git <url>` is set. Mutually exclusive with `--tag` / `--rev`. Mutable: `vibe install` (no `update`) sticks to the lockfile-pinned commit; `vibe update` re-walks branch HEAD. PROP-002 §2.4.1 --rev <REV> Git commit SHA to pin against when `--git <url>` is set. Mutually exclusive with `--tag` / `--branch`. Most strict; the lockfile records the same SHA. PROP-002 §2.4.1 --git-auth <AUTH> Auth regime for the `--git <url>` target — same enum as `[[registry]] auth`: `none` / `token-env` / `credential-helper` / `ssh`. Default `none`. PROP-002 §2.4.1 --git-token-env <ENV_VAR> Env-var name when `--git-auth token-env`. Default derived from URL host (e.g. `https://gitlab.acme.example/...` → `VIBEVM_REGISTRY_TOKEN_GITLAB_ACME_EXAMPLE`) --force Ignore reusable lifecycle contribution fingerprints for this install's post-durability callback. Resolution/materialisation semantics are unchanged --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this invocation runs into `.vibe/trace/<run-id>/`. The flag is one half of the activation — the selected project's own `[compile] trace = true` is the other, and either alone enables it. Neither can switch the other off -h, --help Print help (see a summary with '-h') Re-fetch and apply changes for one or more installed packages Usage: vibe update [OPTIONS] [PACKAGES]... Arguments: [PACKAGES]... Package references `<kind>:<name>` to update. Each must be currently installed. Mutually exclusive with `--all` Options: --all Update every package in the lockfile. Mutually exclusive with `<packages>` --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --assume-yes Skip the interactive confirmation prompt --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --exact Pin the resolved version exactly (`=x.y.z`) in `vibe.toml` `[requires].packages` instead of preserving the existing constraint shape. Same flag as `vibe install`'s. Useful for "bump and pin" — re-resolve to a newer version AND tighten the manifest constraint to that exact version in one step. Without this flag, `vibe update` only refreshes the lockfile pin and leaves the manifest's `^` / `~` / range constraint untouched (cargo's default behaviour) --auth-required Strict authentication gate — same semantics as `vibe install --auth-required`. When set, a 401 / 403 against an `auth = "none"` (public) registry halts the update instead of walking past. Useful in CI / cron where a fallback to a public substitute would mask a private- registry outage --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this invocation runs into `.vibe/trace/<run-id>/`. The flag is one half of the activation — the selected project's own `[compile] trace = true` is the other, and either alone enables it. Neither can switch the other off -h, --help Print help (see a summary with '-h') Remove an installed package from the current project Usage: vibe uninstall [OPTIONS] <PACKAGE> Arguments: <PACKAGE> Package reference `<kind>:<name>` (version is ignored on uninstall) Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --assume-yes Skip the interactive confirmation prompt --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Recompute the materialised dependencies and the boot artifacts of a workspace without re-resolving (PROP-009 §2.10) Usage: vibe reinstall [OPTIONS] [PATH] Arguments: [PATH] Any directory inside the workspace. Discovery bubbles up to the absolute workspace root; `vibe reinstall` regenerates the boot artifacts of every node. Defaults to the current directory [default: .] Options: --force Re-fetch every locked package's content from its source repository — at the version `vibe.lock` pins, never re-resolving — bypassing the local cache and overwriting the current `vibedeps/` files. The escape hatch for a corrupted or hand-edited `vibedeps/` subtree. Without this flag, `vibe reinstall` only recomputes the boot artifacts from the materialised tree already on disk — no fetch, no network — which is the fix for a stale or wrongly-generated `INDEX.md` --json Produce machine-readable JSON output --assume-yes Skip the interactive confirmation prompt --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this invocation runs into `.vibe/trace/<run-id>/`. The flag is one half of the activation — the selected project's own `[compile] trace = true` is the other, and either alone enables it. Neither can switch the other off. `--force` is a MATERIALISATION force and unrelated: it re-fetches from source, while this only asks the compiler to narrate itself. --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') List the packages recorded in the project's lockfile Usage: vibe list [OPTIONS] Options: --json Produce machine-readable JSON output --kind <KIND> Filter by package kind (flow, feat, stack, tool, mcp, lang, doc, app) --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --verbose Append per-package active features and subskill paths to the text-mode output. JSON output already carries these fields regardless. Off by default to preserve table width --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Show installed packages whose registry-side latest version is newer than what the lockfile currently pins. Read-only — does not touch the lockfile or fetch package content. Per PROP-003 §M1.10 Usage: vibe outdated [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Project root with `vibe.toml`. Defaults to current directory [default: .] --auth-required Strict authentication gate — same semantics as `vibe install --auth-required` / `vibe update --auth-required`. When set, a 401 / 403 from an `auth = "none"` (public) registry halts the probe instead of walking past. The probe is read-only, so the trade-off is mostly diagnostic clarity — you want to see "this private registry is down" rather than silently miss its packages --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --upstream Also compare GitHub upstream releases declared by locked `describes` PURLs. Only `pkg:github/<owner>/<repo>@<semver>` is supported; the package-registry check remains separate --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Run the spec-consistency linter against the project tree Usage: vibe check [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Project root with `vibe.toml`. Defaults to current directory [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --wal-max-age-hours <WAL_MAX_AGE_HOURS> WAL is "stale" past this age. Default 24h matches the boot snippet's freshness rule [default: 24] --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --review-max-age-days <REVIEW_MAX_AGE_DAYS> REVIEW marker age threshold in days (`<!-- REVIEW: YYYY-MM-DD ... -->`). Default 14d per `VIBEVM-SPEC.md` §12 [default: 14] --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Analyze the resolved spec/dependency tree (PROP-036): the effective boot load type per package (`static` / `dynamic` / `none`), the transitive / condition / static-lane flags, the two boot lanes, and the in-place `@spec` markers. Read-only. `--json` emits the machine model (validated against the shipped `package-tree.schema.v1.json`); a non-tty or `--plain` renders a static ASCII tree Usage: vibe tree [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Project root. Defaults to the current directory [default: .] --plain Force the plain ASCII tree instead of the interactive TUI — on a tty as well as off it (PROP-036 §2.11: `--plain` and a non-tty both render the static tree; neither enters interactive mode). Legal together with `-c`/`-t` and wins over both, so `--plain -t` prints the tree here rather than opening vibeterm --quiet Reduce output to a single summary line (useful in scripts / CI) -c, --console Open the in-terminal console TUI (today's default). Mutually exclusive with `-t` (TERMINAL-AIUI §6.2) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] -t, --terminal Open in the vibeterm desktop terminal instead of the current terminal. Mutually exclusive with `-c` (TERMINAL-AIUI §6.2) --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Inspect computed project state (effective spec, configuration) Usage: vibe show [OPTIONS] <COMMAND> Commands: effective Print the effective spec — every boot-lane file plus every installed package's `files_written`, concatenated with `spec://` provenance headers in stable order config Print the effective configuration with per-value provenance (default / vibe.toml / env-var) features Print every active feature recorded in the lockfile, grouped by package. Per PROP-003 §2.10 / `vibe show features` subskills Print every active subskill recorded in the lockfile, grouped by package, with delivery mode and any `describes` PURL purls Print every PURL the project's lockfile binds to (the union of per-package `describes` declarations). Useful as a sanity check for upstream-version drift source-path Print the canonical on-disk root of an installed package or one of its authenticated embedded sources help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Explain why a package is in (or out of) this project's effective world: the admitting chain with its rule, or the blocked edges and what blocked them (PROP-050 ##VIBE-WHY) Usage: vibe why [OPTIONS] <COORDINATE> Arguments: <COORDINATE> The package coordinate to explain, in `<group>/<name>` form Options: --json Produce machine-readable JSON output --path <PATH> Project root with `vibe.toml`. Defaults to the current directory [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') The sealed-circle report for one provider: open / sealed / the named circle, who actually befriends it, which grants its allow-friends rejects, and whether it is in the root's friend closure (PROP-050 ##ALLOW-FRIENDS-EXHAUSTIVE) Usage: vibe friends [OPTIONS] <COORDINATE> Arguments: <COORDINATE> The provider coordinate to report on, in `<group>/<name>` form Options: --json Produce machine-readable JSON output --path <PATH> Project root with `vibe.toml`. Defaults to the current directory [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Operate on a multi-package workspace (PROP-007). Today the one subcommand is `publish` — walk the workspace's self-publishing members in dependency order and publish each as its own repository Usage: vibe workspace [OPTIONS] <COMMAND> Commands: publish Publish the workspace's self-publishing members. Discovers the workspace enclosing the current directory, selects every node (root and members) carrying `[package]` whose `publish` posture does not exclude it, orders them dependency-first via inter-member `path` dependencies, and publishes each as its own repository in the workspace's primary `[[registry]]` org — reusing the same per-package machinery as `vibe registry publish`. Each published copy carries an `[origin]` provenance marker, a "generated copy" README banner, and a `.github/PULL_REQUEST_TEMPLATE.md` STOP notice. Publishing is **not atomic**: on the first failure the command stops and reports which nodes were already published and which remain (PROP-007 §2.7). Maintainers only — needs the same publish token used by `vibe registry publish` help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')
Manage the registry cache (clone, sync) Usage: vibe registry [OPTIONS] <COMMAND> Commands: sync Force a `git fetch` on the configured registry cache publish Publish a package directory as a tagged release in the configured registry organization. Maintainers only — needs a publish token (see RUNTIME-GUIDE.md) list Print the project's configured `[[registry]]` / `[[mirror]]` / `[[override]]` entries and the host adapter each registry will dispatch to add Add a new `[[registry]]` block to `vibe.toml` set-mirror Add a `[[mirror]]` block targeting a registry (or `*` for any) remove Remove a `[[registry]]` or `[[mirror]]` block from `vibe.toml` test Probe each configured `[[registry]]` for reachability + authentication status. Read-only diagnostic — does not fetch or write anything. Per-registry status: `reachable` (org URL responded), `auth-required` (got 401 / 403 — for public registries this is "host policy on missing repos is 401"; for authenticated registries this means the configured credentials are missing or wrong), `unreachable` (network / DNS / cert error), or `missing-token` (registry declares `auth = "token-env"` but the env-var resolves empty). Useful when first wiring a private registry to confirm credentials line up redirect Create a registry stub that delegates a package to an external target URL (PROP-002 §2.4.2). Makes the configured `[[registry]]` org host a stub repo carrying `vibe-redirect.toml` instead of the package content. Consumers `vibe install <pkgref>` resolve through the stub transparently; the resolver follows the marker to the target. Maintainers only — needs the same publish token used by `vibe registry publish` redirect-sync Mirror target tags into a registry stub (PROP-002 §2.4.2, `pass-through-tag` policy). Reads the stub's `vibe-redirect.toml`, enumerates target tags, and pushes the missing ones into the stub so consumers `vibe install <pkgref>@<ver>` see the same versions the target offers. Pinned-policy stubs have nothing to sync — command refuses with a clear message redirect-update Rewrite an existing registry stub's `vibe-redirect.toml` (PROP-002 §2.4.2). Each flag is optional — fields not specified retain their current value, so this is a true partial update. Changes that affect resolution outcomes for consumers (`--to` rewriting the target URL, `--ref-policy` flipping the resolution mode) require `--trust-redirect` per PROP-002 §2.4.2's trust model: such a switch is never silent and must be operator-initiated. Refuses if the computed marker is byte-identical to the stub's current marker vendor Generate a local mirror directory containing every package referenced by `vibe.lock`, suitable for use as a `[[mirror]] url = "file:///<abs-path>"` for offline / air-gapped installs help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Search the configured `[[registry]]` entries for packages whose description, name, keywords, or capabilities match a query. Walks each registry's index server (resolved via `VIBEVM_INDEX_URL_<R>` per PROP-005); registries without an index URL or unreachable servers are reported but do not abort the run. Per ROADMAP §M2.10 Usage: vibe search [OPTIONS] <QUERY|--purl <PURL>> Arguments: [QUERY]... Free-text query. Tokenised on the server side: lowercase ASCII alphanumeric runs, common stopwords filtered, single-character tokens dropped. At least one 2+ character non-stopword must remain after filtering for the query to match anything. Mutually exclusive with `--purl` Options: --json Produce machine-readable JSON output --purl <PURL> Direct PURL lookup — find every package whose `[package].describes` or any subskill's `describes` equals this Package URL. Mutually exclusive with the positional free-text query. Hits carry a `binding_site` field (`package` vs `subskill`) so consumers see where the match originated --kind <KIND> Restrict results to a single package kind (`flow`, `feat`, `stack`, `tool`, `mcp`, `lang`, `doc`, `app`). Applies only to free-text search; PURL lookup ignores it --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --registry <REGISTRY> Restrict to one configured `[[registry]]` by name. Default: walk every registry that has `VIBEVM_INDEX_URL_<R>` set in the environment --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --limit <LIMIT> Maximum hits to fetch from each registry's index server. The server may apply its own cap; the union is then deduplicated by `(kind, name)` keeping the highest-score hit. Defaults to 20 — large enough to be useful, small enough that no single registry dominates. Ignored on `--purl` lookups (PURL match is exact and saturates well below any reasonable limit) [default: 20] --full-scan For registries without a configured `VIBEVM_INDEX_URL_<R>`, fall back to a naive org-walk via the host's REST API. v0 supports GitHub-hosted registries only (`github.com`); other hosts are reported as unsupported. Slower than an index; rate-limited; reads `vibe.toml` from each repo's HEAD via the GitHub Contents API. Ignored on `--purl` lookups --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-cache Bypass the persistent search cache under `~/.vibe/search-cache/`. Reads still go to the network even when a fresh entry exists; freshly fetched results are not written back. Useful for testing or when an index update landed and the operator wants to force a refresh without waiting for the TTL to expire --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --cache-ttl <CACHE_TTL> Override the default cache TTL (1 hour) — entries older than this many seconds are treated as misses. Ignored when `--no-cache` is set --path <PATH> Project root with `vibe.toml`. Defaults to current directory [default: .] -h, --help Print help (see a summary with '-h') Operate on the machine-global package store `~/.vibe/cache/` (PROP-010 §2.8): `path` prints its root, `list` the offline-resolvable inventory, `add` pre-warms packages (and their dependency closure) into it without touching any project, `clean` reclaims space — all, by age, or by package, always as an explicit operator action. Top-level on purpose: the store is machine-global and its headline case is work that has no project yet Usage: vibe cache [OPTIONS] <COMMAND> Commands: path Print the machine store root (`~/.vibe/cache/`) — where fetched package content lives. Works anywhere, project or not: the store is machine-global and moves with `$VIBE_SETTINGS` list List the packages and versions present in the machine store — the offline-resolvable inventory. Works anywhere add Deliberately pre-warm the store: resolve the named package(s) and their whole dependency closure and fetch every node into the machine store — nothing is materialised into any project (no `vibe.lock`, no `vibedeps/`, `vibe.toml` untouched). Inside a project, the project's `[[registry]]` entries are the source; outside one, the user-level `~/.vibe/registry.toml` registries. The "I am about to go offline, pull down what I will need" workflow (PROP-010 §2.8) clean Reclaim store space — an explicit operator action, never a surprise and never automatic (PROP-010 §2.1). Requires exactly one target: `--all`, `--package`, or `--older-than` check The integrity sweep (PROP-010 §2.8 CMD-CHECK): walk every store entry, recompute its content hash, and compare against the recorded `v<version>.sha256` sidecar. **The only place the store is fully re-hashed** — verification is a command an operator runs, not a tax every install pays. Reports `ok` / `mismatch` (identity, path, both hashes) / `unrecorded` (no sidecar); exits non-zero when anything is not ok. `--repair` then fixes what the sweep found, cheapest first: unrecorded entries get a sidecar recorded from their current bytes; mismatched entries are re-fetched at the SAME version (`REPAIR-DOES-NOT-PULL` — never advanced, that is `vibe update`'s job) help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')
Validate the workspace, without network access or materialisation Usage: vibe validate [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run the default lifecycle through generated-source production Usage: vibe generate [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run the default lifecycle through deterministic build work Usage: vibe build [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run the default lifecycle through deterministic tests Usage: vibe test [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run the default lifecycle through agentic creation Usage: vibe create [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run the default lifecycle through output verification Usage: vibe verify [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run the default lifecycle through distributable assembly Usage: vibe package [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` -h, --help Print help (see a summary with '-h') Run all nine default-lifecycle phases through deployment, then reconcile the selected deploy profile's targets. `--plan` reports the planned work read-only instead of running the chain Usage: vibe deploy [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --registry <REGISTRY> Path to a local-directory registry --assume-yes Skip interactive confirmation for the prerequisite install --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --language <LANGUAGE> Override the project's resolved language preference for this run --features <FEATURES> Activate features on every root package during prerequisite install --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --no-default-features Do not activate `[features].default` during prerequisite install --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --all-features Activate every non-private feature during prerequisite install --auth-required Halt on public-registry authentication failures --solver <naive|sat|resolvo> Select the dependency solver used by prerequisite install --prefer-embedded Prefer the embedded registry over declared registries --no-prefer-embedded Prefer declared registries over the embedded registry --no-default-registry Ignore the ambient embedded registry --embedded-short-circuit Short-circuit registry traffic for embedded coordinates --prefer-local Prefer project-local packages over other local sources --no-prefer-local Ignore project-local packages --force Ignore reusable lifecycle fingerprints for this invocation --trace-compile PROP-054 `##OBS-TRACE`: record every compiler pass this phase runs — including its prerequisite install's — into `.vibe/trace/<run-id>/`. Same two-sided activation as `vibe install --trace-compile`: this flag OR the selected project's `[compile] trace` --profile <PROFILE> The deploy profile to reconcile. Legal to omit only when the manifest names an explicit `default_profile` or defines exactly one profile (PROP-054 ##OPEN-DEPLOY-TARGETS). Environment variables and the presence of secrets never choose a profile --plan Report what would be deployed and stop. A plan reads records and receipts, calls each provider's `plan` verb and nothing else, and never reads a token, opens a socket, builds or mutates a destination -h, --help Print help (see a summary with '-h') Reverse the selected deploy profile: remove every receipt-owned resource, in reverse dependency order. It removes only what a receipt still owns, and refuses a path changed after deployment Usage: vibe undeploy [OPTIONS] --profile <PROFILE> Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project (defaults to current) [default: .] --profile <PROFILE> The deploy profile whose targets are removed, in reverse order --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') List the deployments this machine holds receipts for — project, profile, target, generation, status, scope and timestamps. Never secrets. Read-only; `--json` emits the machine form Usage: vibe deployments [OPTIONS] Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Remove the derived prompt state — dependency slots and generated boot artifacts — keeping every authored file, the lock, and the machine cache. Any lifecycle phase may follow the clean prefix Usage: vibe clean [OPTIONS] [COMMAND] Commands: validate Shared flags for every default-lifecycle verb except `install` install generate Shared flags for every default-lifecycle verb except `install` build Shared flags for every default-lifecycle verb except `install` test Shared flags for every default-lifecycle verb except `install` create Shared flags for every default-lifecycle verb except `install` verify Shared flags for every default-lifecycle verb except `install` package Shared flags for every default-lifecycle verb except `install` deploy The clean-prefixed ninth verb carries the SAME arguments the bare one does: a clean prefix changes what a run starts from, never what the run means, so `vibe clean deploy --profile X` reconciles exactly what `vibe deploy --profile X` would help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project. When left at `.`, a chained phase's own `--path` selects the project for both lifecycles [default: .] --assume-yes Skip the clean confirmation --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Plan or perform terminal removal of the selected VibeVM project layer. `attach` and `detach` remain reserved for a future live-tool surface Usage: vibe scrape [OPTIONS] vibe scrape <COMMAND> Commands: contract Create or validate the project-owned scrape contract help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --plan Render the complete deterministic plan without writing anything --output <DIR> Create a scraped project at this new, absent directory --quiet Reduce output to a single summary line (useful in scripts / CI) --in-place Scrape the selected project through the recoverable in-place transaction --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --recover Settle the pending user-local transaction for the selected project --contract <FILE> Read this contract instead of `vibevm/scrape/contract.toml` --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input --path <ROOT> Project root to inspect or mutate. Recovery requires this explicitly --assume-yes Explicitly authorize the destructive in-place transaction -h, --help Print help (see a summary with '-h') List every extension declaration in the selected installed world Usage: vibe extensions [OPTIONS] [COMMAND] Commands: compile Compile the selected node through one activated custom backend analyze Compile the selected node's static lane in process and report the attribution evidence (R4.3): per-provider contribution bytes, frame overhead, and every transform pass's byte effect help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --path <PATH> Directory of the project/package/workspace node (defaults to current) [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') The registry of what this project can invoke: every `[[binary]]` and every `[[mcp_server]]` the installed packages declare, in one table. The boot lane already names which language disciplines are installed; this names what they brought that can be RUN. `--json` for agents Usage: vibe tools [OPTIONS] Options: --json Emit the registry as JSON rather than a table --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Build and dispatch the tools installed packages declare via `[[binary]]` (PROP-025): `list` the table, `build` (consent-gated) into the slot, `path` an artifact, `exec` through the project's lockfile — the rustup dispatch model Usage: vibe bin [OPTIONS] <COMMAND> Commands: list Every `[[binary]]` declared by the project's installed packages, with build state and description build Build the named tools (default: all declared) release-mode in their slots. Consent-gated: a non-`org.vibevm` group requires `--assume-yes` (the build runs the package's build scripts) path Print the artifact path (non-zero exit when not built) exec Resolve through THIS project's lockfile and run the tool, building it first if absent. The exit code passes through help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')
Start the MCP (Model Context Protocol) server over stdio, exposing the project's lockfile and active subskills to a connected coding agent (Claude Code, Cursor, etc.). Per PROP-004 §5.1 / ROADMAP §M1.7. Reads JSON-RPC 2.0 requests line-by-line from stdin; writes responses to stdout Usage: vibe mcp [OPTIONS] <COMMAND> Commands: serve Run the MCP server over stdio. Blocks until the client disconnects (EOF on stdin) install Detect supported coding agents and write the per-agent MCP server configuration plus an optional `vibevm` SKILL.md so the agent picks up vibevm automatically on its next session start. Five agents supported: Claude Code, Claude Desktop, Cursor, OpenCode, Codex. Idempotent — already-correct configs surface as `unchanged` status Same as `install` but printing the planned config diff without writing any files. Useful for CI / review upgrade Refresh existing vibevm MCP integrations to the version shipped in this binary. Scans known paths, compares the on-disk MCP-server entry / SKILL.md to what `install` would write today, and rewrites only the diverged ones. Does NOT create new installations — use `mcp install` for that. Useful after `cargo install --path crates/vibe-cli` (or any vibe upgrade) to pull the new SKILL.md / wire shape into agents that already had vibevm wired uninstall Remove vibevm MCP integration from one or more agents. Drops the `vibevm` key from each agent's MCP config (foreign keys preserved) and deletes the SKILL.md file (and its parent `vibevm/` skill dir if it becomes empty). Same scope axis as install / upgrade: project, user, both. Wizard-driven without flags; fully scriptable with `--scope` / `--what` / `--agent` help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Project package-declared skills into coding agents — vibevm's standalone mode (PROP-018 §2.6). `vibe skill list` shows what the installed packages (and the project itself) declare via `[[skill]]`; `vibe skill install` writes each into the target agents' skill directories. No LLM required Usage: vibe skill [OPTIONS] <COMMAND> Commands: list List the skills declared by installed packages (and the project itself) that `vibe skill install` can project into agents. Read-only install Project declared skills into coding agents' skill directories (`.<agent>/skills/<name>/…`). Default: every declared skill into every skill-supporting agent (Claude Code, OpenCode, Codex). Idempotent — an identical projection surfaces as `unchanged` uninstall Remove vibevm-projected skills from agents. Strips only the named skills' own directories; foreign skill dirs are left untouched help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Compose an LLM instruction for the calling agent and park it in the relay — vibevm's agentic mode (PROP-018 §2.7, §2.10). vibevm has no inference engine yet, so `vibe agentic explain` does not act: it queues a project-explanation task that the agent fetches with `vibe command` and runs on its own LLM Usage: vibe agentic [OPTIONS] <COMMAND> Commands: explain Compose an "explain this project" instruction and park it for the calling agent to execute (PROP-018 §2.10). Does no LLM work itself and writes nothing but the relay mailbox — fetch the instruction with `vibe command`, then carry it out help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Drain the agentic relay: print the instruction a `vibe agentic …` command parked in `.vibe/agentic/command.md` (PROP-018 §2.7) and clear the slot. Prints "no pending command" when the mailbox is empty. The calling agent runs this, then carries out the printed instruction Usage: vibe command [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Project root with `vibe.toml`. Defaults to current directory [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') The agent-facing observation surface (PROP-042). `vibe aiui render` renders the `vibe tree` TUI headlessly to a symbolic snapshot (text or cells) — no terminal, deterministic — so an agent can *see* the interface and golden tests can diff it. Read-only Usage: vibe aiui [OPTIONS] <COMMAND> Commands: render Render the `vibe tree` TUI **headlessly** to a symbolic snapshot — no terminal, deterministic (PROP-042 §1/§4). Optionally drive a key script with `--send` (e.g. "F2 Down Enter"; `F4`/`F6` are refused), set the grid with `--size COLSxROWS`, and pick `--format text|cells`. Read-only state Project the `vibe tree` TUI state to a serialisable `ModelView` — the model plane (PROP-039 §11.2/§11.3, PROP-042 §4). Builds the model at `--path`, drives `--send`, prints the structured state (display mode, selection, open modals, visible rows) as JSON. Read-only, headless open Launch vibeterm with a control server and wait for it to be ready (PROP-042 §4). Prints the session id (the vibeterm pid) so later verbs can target it send Send key names and/or literal text to a running vibeterm session snapshot Read a symbolic text snapshot from a running vibeterm session wait Wait for a running vibeterm session to go idle — deterministic snapshots close Close a running vibeterm session inspect Evaluate a JavaScript expression in the live vibeterm renderer page over CDP — read its REAL state (the xterm grid's cols/cell metrics, the scrollbar box) straight from the runtime, with no screenshot. Requires a `--control` session (PROP-042 §4) pty-stop Stop the hosted program (the PTY child) WITHOUT restarting Electron — frees its binary for a rebuild. The renderer, the CDP endpoint, and the discovery file all stay live. Pair with `pty-start` for a fast TUI preview loop (PROP-042 §4) pty-start (Re)spawn the hosted program at the current grid. Pair with `pty-stop` around a rebuild for a live TUI preview — the agent sees the change without reconnecting CDP or relaunching Electron (PROP-042 §4) scrollbar Set the scrollbar policy live: `auto` (hidden for a full-screen TUI, shown for a shell), `on` (always), `off` (never). The renderer refits the grid — no Electron restart. Requires a `--control` session (PROP-042 §4) help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Launch the vibeterm terminal app hosting a detected interactive shell (Windows prefers PowerShell 7 `pwsh`; unix uses `$SHELL`). The terminal an agent or human can observe; `--exec` overrides the shell (PROP-042 §5) Usage: vibe term [OPTIONS] Options: --exec <EXEC> The command to run in the terminal. Defaults to the detected interactive shell (Windows: PowerShell 7 `pwsh` if present, else Windows PowerShell 5.1; other platforms: `$SHELL`, else `/bin/sh`) --json Produce machine-readable JSON output --cols <COLS> Terminal columns (passed through to vibeterm) --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --rows <ROWS> Terminal rows (passed through to vibeterm) --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Launch the vibeframe terminal — the simple terminal frame VibeTree runs in (a copy of vibeterm's minimal single-window terminal). Same flags as `term`; hosts the detected shell or `--exec` Usage: vibe frame [OPTIONS] Options: --exec <EXEC> The command to run in the terminal. Defaults to the detected interactive shell (Windows: PowerShell 7 `pwsh` if present, else Windows PowerShell 5.1; other platforms: `$SHELL`, else `/bin/sh`) --json Produce machine-readable JSON output --cols <COLS> Terminal columns (passed through to vibeterm) --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --rows <ROWS> Terminal rows (passed through to vibeterm) --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')
Traceability explain over THIS tree (PROP-014 §2.6): build the specmap fresh in memory and render what implements, verifies, documents, or deviates from a spec unit or code symbol — the host's built-in answer to the canonical "which test verifies this rule?" (`vibe explain "spec://…#anchor"`). `--json` emits the raw one-hop subgraph; the default is the deterministic text view. Contrast `vibe trace`, a delegating alias to the installed stack's `trace` Usage: vibe explain [OPTIONS] <TARGET> Arguments: <TARGET> A `spec://…#anchor` URI or a code symbol to explain — the subgraph of what implements, verifies, documents, or deviates from it Options: --json Produce machine-readable JSON output --path <PATH> Project root. Defaults to the current directory [default: .] --fragment Show the source text of the code element behind `target` instead of the subgraph — the "…and here it is" view (V7-FRAGMENT-DRIFT). When the map recorded a fingerprint, it is recomputed from the element's current source and a drift verdict is printed: the map notices a code edit before a person does. Drift is information, not a refusal — the fragment is printed either way and the exit code stays zero. Works for an installed package too (its carried map is the checkpoint) --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Search the code↔spec map by independent filters (A5A-MAPSEARCH): `--uri` (exact spec address), `--symbol` (substring of a code symbol), and `--kind` (a code `item_kind` or a spec unit kind), AND-joined, over a hard result ceiling (`--limit`, default 50, max 200; no unbounded mode). None is required — bare `vibe query` shows a bounded slice of the whole map, with truncation named. The grep-like counterpart to `vibe explain` (a point lookup): `explain` looks at ONE target's subgraph; `query` FINDS the many nodes that fit. `--json` emits the machine-readable form. Read-only Usage: vibe query [OPTIONS] Options: --json Produce machine-readable JSON output --uri <URI> Exact `spec://…#anchor` URI to match. Only spec units carry an address, so this excludes every code item --quiet Reduce output to a single summary line (useful in scripts / CI) --symbol <SYMBOL> Substring of a code item's symbol to match (case-sensitive, like `grep`). Only code items carry a symbol, so this excludes every spec unit --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --kind <KIND> Element kind to match exactly: a code item's `item_kind` (`fn`, `struct`, `mod`, …) or a spec unit's own kind (`req`, `prop`, …). The two vocabularies never overlap, so one filter serves both families --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --limit <LIMIT> Maximum number of results. Must be at least 1; clamped to a hard ceiling of 200. There is no unbounded mode — the ceiling is part of the design, because an answer that does not fit an agent's context is worthless. Defaults to 50 [default: 50] --path <PATH> Project root. Defaults to the current directory [default: .] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Search the code↔spec map by a conjunctive predicate query and walk the bipartite graph (E-A5B-QUERYLANG) — the traversal layer over `vibe query`. `--where` carries the query: `uri:`/`symbol:`/`kind:` (the same filters as `query`), `scope:` (a `spec://` prefix), `has:`/`lacks:` (a verb an edge does/does not touch), and `depth:<0..3>` (an undirected walk; seeds stay at `d0`). Predicates are whitespace-AND-joined. Reach for `select` over `query` when the answer is relational — "every spec rule with NO verifier" (`lacks:verifies`), "the implementers of this rule and one hop around them" (`uri:… depth:1`); reach for `query` for a flat filter, and `explain` for one target's subgraph. `--json` emits the machine-readable form. Read-only Usage: vibe select [OPTIONS] --where <QUERY> Options: --json Produce machine-readable JSON output --where <QUERY> The query: predicates joined by spaces (AND). Each is `name:value` — `uri:<exact spec:// address>`, `symbol:<code-symbol substring>`, `kind:<item_kind or spec kind>`, `scope:<spec:// uri prefix>`, `has:<verb>` / `lacks:<verb>` (`implements|verifies|documents|deviates| informs`), `depth:<0..3>`. Required: an empty query is an error, not "everything" (use `vibe query` for an unfiltered slice) --limit <LIMIT> Maximum number of results. Must be at least 1; clamped to a hard ceiling of 200. There is no unbounded mode — the ceiling is part of the design, applied AFTER the graph walk. Defaults to 50 [default: 50] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --path <PATH> Project root. Defaults to the current directory [default: .] --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Generate the package's carried traceability map (V5-PACKAGE-MAP §2.2). Reads the package's `vibe.toml` (for its `(group, name)` coordinate) and `specmap.toml` (its scan policy; presence is the opt-in), and writes the map — built fresh with the same engine `vibe explain` uses — minted under the coordinate `spec://<group>/<name>/…` (globally unique, where the local `specmap.toml` nickname is not), so a consumer can query an installed package without rebuilding. A package without a `specmap.toml` is left untouched. Read-only to the tree outside the one map file Usage: vibe specmap [OPTIONS] Options: --json Produce machine-readable JSON output --path <PATH> Package directory carrying the `vibe.toml` to read. Defaults to the current directory [default: .] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Traceability queries over the project's specmap (PROP-014 §2.6) — a delegating alias: arguments pass through verbatim to the installed `rust-ai-native trace` (the engine ships with the discipline stack and versions with the project, not with vibe). Example: `vibe trace explain "spec://<ns>/<doc>#<anchor>"` Usage: vibe trace [OPTIONS] [ARGS]... Arguments: [ARGS]... Arguments handed to `rust-ai-native trace` unchanged Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Inspect and edit the project's consumer-owned adoption-facts registry Usage: vibe facts [OPTIONS] <COMMAND> Commands: check Validate facts markup. This is the durable spelling of the markup lint also available through the transitional `progress check` alias list List registry entries in address order get Show one entry, or report that it is not registered set Create or update an entry rm Remove one entry sync Compare host entries with spec markers; optionally reconcile them adopt Copy authored package statuses into absent consumer records clean Remove registry files whose source packages are no longer installed report Summarise consumer adoption against facts authored by each package help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') One bounded, read-only metadata answer about what the selected project's specs declare and what it recorded about them (PROP-054 `##REF-REQUIREMENTS-SURFACES`): per addressed fact its authoring status, this project's consumer adoption, and — with `--relations` — the edges a specmap carries. `--json` is the generated report exactly; combining the axes into a verdict is never this query's Usage: vibe requirements [OPTIONS] Options: --address-prefix <PREFIX> Scope the answer to one `spec://` address prefix. Absent asks about every addressed fact. A bare fact id is refused: it names nothing a second reader could resolve --json Produce machine-readable JSON output --limit <N> Maximum number of fact rows, inclusive range 1..=256. There is no unbounded mode — an answer that does not fit an agent's context is worthless — and the report restates the bound it was cut by, so a truncated answer says so [default: 100] --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --relations Ask for the optional relation-edge enrichment. Absent means `not-requested`: no specmap config is read and no map is loaded or built. Enrichment never changes the fact rows — a loss is typed per source and the base rows still return --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --path <PATH> Project root — the selected workspace node the answer is about. Defaults to the current directory. A trusted constructor input: the path never rides the answer [default: .] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Progress Control (PROP-043): scan/validate the inline `<status>` markup, render reports, and drive the actualization campaign (mirror, weave, rescan, resume) Usage: vibe progress [OPTIONS] <COMMAND> Commands: scan Parse the observed tree, refresh the campaign cache and the dashboard state projections (when a campaign zone is present) check Validate the markup (read-only: writes nothing by default) and exit non-zero on errors — closed vocabularies (with nearest-value hints), placement law, well-formedness. Unlike `scan`, `check` leaves the campaign zone untouched — neither the cache nor the `state/` projections — so a validation run cannot rewrite a frozen zone the way its name says it would not. Pass `--write-state` to also warm the cache and projections, exactly as `scan` would report Render the tree status: XML natively, `--md` table, `--json` mirror Materialize the per-file cache view under the campaign zone (`run/mirror/`), for LLM batch work weave Stitch the observed corpus into whole-context LLM input: `--digest` map form, or full form sharded by `--max-tokens` rescan Three-way compare against a previous campaign's baseline: new / changed (suspect) / carried-forward units baseline Write `baseline.json` from the campaign's own verdicts — the artifact the next campaign's `rescan` consumes. Reads the cache; verifies nothing and invents no verdict resume Regenerate `RESUME.md` from the campaign journal and print it — the first read of every campaign session gate Record a gate's verdict into the campaign's gate panel. The automation seam: whoever ran the real gate reports the result here, and the dashboard reads it out of `campaign.json` seal Record that a file's verdicts were re-derived against its current text, so the staleness warning stops firing on it. Verifies nothing — the caller did the re-derivation and reports it here — and refuses any file whose markers are not all judged help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Meaning-preserving rewrites of authored source trees Usage: vibe refactor [OPTIONS] <COMMAND> Commands: convert-source Convert selected authored spec sources through the vibe-specdoc pivot [aliases: convert-src] convert-package-src Convert every authored spec source below one or more package roots convert-spec-src Convert only the spec/ tree of a package (the current project by default) help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')
Manage vibevm's own versions on this machine — the VibeVM Version Manager (VVM, PROP-019). `vibe self install <selector>` builds and installs a version from source; `vibe self use` switches the active one; `vibe self ls` lists what is installed. Self-distribution: the `vibe` binary manages its own versions Usage: vibe self [OPTIONS] <COMMAND> Commands: install Install a version: verified release bundle from a binary execution, or a two-binary build from a source execution / explicit mirror import Import a ready-built local vibe executable without network access bootstrap Bootstrap from an aggregate manifest and its release download base update Move a binary installation to the newest release; a source execution rebuilds `latest` reinstall Refetch and reinstall the current version: a binary execution redownloads its own release, a source execution rebuilds it use Switch the active version; `--eval` creates a shell-local override rollback Switch back to the previously active immutable local instance. Repeating the command toggles between the two instances ls List installed versions, marking the active one (`*`) [aliases: list] current Print the running/active payload's exact selector and provenance which Print the active instance's `vibe`, `vibe-index`, or source path source Print exactly the source tree used by the running/active instance doctor Verify the install and environment; `--fix` repairs PATH and shims remove Remove installed version(s) — safe by default (no wipe without `--all`; no selector opens an interactive picker) [aliases: rm, del, uninstall] gc Reclaim disk: clean the Rust build cache, or prune old versions env Print the shell line that activates a version in the current shell relocate Repoint source provenance to a moved checkout and remove the instances built from the abandoned tree (PROP-019 §2.17) help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Print the runtime variable context — the values vibevm actually uses (derived from the running binary's location) versus the environment, so scripts can reconcile a stale `$VIBEVM_HOME` (PROP-019 §2.14). Modes: `vibe vars`, `vibe vars diff`, `vibe vars full`, `vibe vars full diff` Usage: vibe vars [OPTIONS] [MODES]... Arguments: [MODES]... Optional modes: `full` (two tables — actual and environment) and/or `diff` (mark where the environment differs). E.g. `vibe vars full diff` Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Inspect and edit application/user preferences — the three-level app-prefs store (`vibe-settings`, PROP-040 §8). `vibe prefs get/set/ list/check/migrate` plus `vibe prefs show-origins`. Distinct from `vibe show config` (the project-config view) Usage: vibe prefs [OPTIONS] <COMMAND> Commands: get Print the resolved value of one key and which layer set it set Set one key in a file layer — an enriched write: a value equal to the key's built-in default is diffed away, and the layer's comments + role-marker header survive the atomic rewrite list List every resolved key with its value and origin check Validate every layer against the schema (unknown + deprecated keys) migrate Rewrite deprecated keys to their `replaced_by` targets in each layer show-origins Print the full per-layer breakdown — the resolved value and every layer's contribution — for one key or, with no key, for every resolved key (PROP-040 §8 `#show-origins`) ui Open the interactive settings TUI (PROP-041) — a surface over the three-level store: browse pages, see where each value comes from, and (S2) edit per-type fields. Launches when the session is attended help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h') Print version information Usage: vibe version [OPTIONS] Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')
Work with a documentation package (PROP-057). `vibe doc check --examples` runs every documented command in a sandbox and compares its output with what the page promises, exactly Usage: vibe doc [OPTIONS] <COMMAND> Commands: build Render a documentation package: every page in the projection you ask for, the page manifest, the four `llms` tiers and the card's images, at the addresses the site mounts them under build-site Render the whole site: every version the configured registry currently publishes, and the host from the checkout on disk. This is the command the renderer container runs — it reads two sources, compares them with what it last rendered, and rebuilds only what moved check Check a documentation package against the product it documents: run every documented example and compare its output exactly, rebuild every `derived` block and compare it with the last build, resolve every `rule` citation against the current specs, check a translation against the documentation it adapts, measure how much of what the specifications promised is told, and judge the card's images manifest Print what a machine reads about a documentation package: the page manifest, or one tier of `llms.txt` serve Read the documentation locally: an HTTP server on the loopback that renders a page on every request and glues it into the reader's shell — the same shell the public site wears, built into this binary or placed in the machine store, and the bare one when neither is there shell The reader's shell: what this binary carries, and how to get the real one when it carries the bare fallback surface Record what the product's surface looks like on one declared version: the command tree with its flags, the keys the manifest and the lock file accept, the members of every published schema, the text of every documentation obligation, and the format registry. There is no hash, no build date and no state identifier in it — a version is a behavioural contract, and the number the owner declares is the only thing this project compares versions by diff Compare two recorded surfaces and print the pages to update, each with the reason that reached it: a rule the page cites, a command or a schema the page derives its text from, or a promise made to an audience nobody tells. A change no page answers to is reported as a page that does not exist yet todo The maintenance queue by the CURRENT state of the package and the product: obligations nobody tells, citations that no longer resolve, adaptations that do not mirror, pages owed a reading aloud, documentation debt and what the style linter found. It prints the numbers and returns success whatever they say — no technical gate binds a release of the product to its documentation, so this measures rather than stops help Print this message or the help of the given subcommand(s) Options: --json Produce machine-readable JSON output --quiet Reduce output to a single summary line (useful in scripts / CI) --invoked-by <AGENT> Identifier of the agent or harness invoking this command. Free-form string; conventional values are `claude-code`, `claude-desktop`, `cursor`, `opencode`, `codex`. When set, the value is stamped onto every JSON envelope vibe emits (`"invoked_by": "<value>"`) so the caller's context is recoverable from logs and machine-readable output. Falls back to the `VIBE_INVOKED_BY` environment variable when the flag is absent; flag wins on conflict. The `vibevm` skill installed by `vibe mcp install --with-skill` instructs each agent to pass this flag automatically --agent-mode <MODE> PROP-054 `##AGENT-HANDSHAKE`: how this invocation executes `agent` lifecycle contributions. `cli` calls the configured provider and pays for it (the R7.2 behaviour); `agent` never constructs a provider — each selected agent row is PARKED as a Markdown task under `.vibe/agentic/outbox/<run-id>/` for the hosting agent to perform, and the same command resumes the run once the declared outputs exist. The default, `auto`, resolves to `agent` exactly when the resolved `--invoked-by` / `VIBE_INVOKED_BY` value is present (something is hosting this process) and to `cli` otherwise. An explicit `cli`/`agent` always wins over `auto`'s inference Possible values: - auto: Infer from the resolved invoked-by value: present → `agent`, absent → `cli` - cli: Always call the configured provider, as R7.2 did - agent: Never construct a provider; park each agent row for the hosting agent [default: auto] --unattended Run unattended — skip every confirmation prompt and refuse to open any interactive wizard. Equivalent to passing `--assume-yes` (`vibe install` / `vibe uninstall`) or `--yes` (`vibe mcp install` / `upgrade` / `uninstall`) to whichever subcommand needs it. Falls back to the `VIBE_UNATTENDED` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive); flag wins on conflict. Stamps `"unattended": true` on every JSON envelope so log aggregators can tell scripted runs from interactive ones. Designed for first-time-user provisioning, CI, and other fully scripted environments --offline PROP-010 §2.5: forbid network access for the invocation. Under `--offline`, resolution and fetch must be satisfiable entirely from local sources (the cache, `file://` mirrors, the project's own `vibe.lock` + `vibedeps/`); anything not available locally is a hard error with an actionable message — never a silent degrade to a partial result. Falls back to the `VIBE_OFFLINE` environment variable (truthy values: `1`, `true`, `yes`, `on` — case-insensitive), then the user-config `[net].offline` key; the flag wins on conflict. Online remains the default and is unchanged. `vibe install --offline` (PROP-030 §3.1) stays and ORs into the same posture as one more input -h, --help Print help (see a summary with '-h')