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

Глобальные опции

02Каждая команда принимает --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

04 CLI defaults to human-readable Markdown-flavored output; --json for machine-readable; --quiet for one-line summaries.

Проекты и пакеты

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')

Машина и сам vibe

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')