vitrinka.docs

CLI command reference

Every vitrinka command and flag, rendered from the CLI itself.

Commands are grouped by what you work with, such as boards, tasks and sets. Help text and flags come from the CLI. Every command also takes --base <url>, which picks the deployment, and --json, which makes ordinary commands, including help, version and failures, emit ONE machine-readable envelope on stdout: {v, ok, verb, data, diagnostics, next}, plus exit_code when the command fails. data is the command's result; each diagnostic carries a code, a plain detail and a recovery instruction in fix. Only executable commands appear in next[].cmd. Protocol/stream exceptions are setup extension host, child commands via qa run, work listen, continuous work watch, auth token (raw token), completion scripts and interactive UI. Exit codes: 0 ok · 1 failure · 2 misuse (unknown command, bad argument or flag) · 3 work watch --once found nothing · 4 authentication required · 5 a step needs a human (rerun with --yes) · 130 cancelled.

Command groups

vitrinka admin — Deployment administration

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka admin projects

The workspace's project registry

Subcommands: check

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka admin projects check

List registry rows that still need a decision (exit 1 while any)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka admin smtp

The deployment mailer (one per install)

Subcommands: set, status, test

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--org—organization slug (default: $VITRINKA_ORG, then the bound workspace's org, then the sole membership)
--yes—accept every proposed plan without asking
vitrinka admin smtp set

Save the SMTP config (or --clear it)

FlagDefaultHelp
--ca—path to a private-CA PEM bundle
--clear—delete the saved config (fall back to the env SMTP_*/RESEND_API_KEY)
--from—from address
--host—relay host
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-ca—drop the stored CA bundle (back to system roots)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--org—organization slug (default: $VITRINKA_ORG, then the bound workspace's org, then the sole membership)
--password—relay password (prefer --password-stdin — argv is visible to ps)
--password-stdin—read the relay password from stdin
--port—relay port (server default 587)
--tls—starttls | implicit | none
--user—relay user ('' switches to an anonymous relay)
--yes—do not ask before --clear
vitrinka admin smtp status

Source, host/tls/from, whether a password is stored

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--org—organization slug (default: $VITRINKA_ORG, then the bound workspace's org, then the sole membership)
--yes—accept every proposed plan without asking
vitrinka admin smtp test

Send a test email to your own address

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--org—organization slug (default: $VITRINKA_ORG, then the bound workspace's org, then the sole membership)
--yes—accept every proposed plan without asking

vitrinka auth — Credentials, one per deployment

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka auth login

Sign this machine in through a browser approval

FlagDefaultHelp
--insecure-storage—consent up front to storing the token in plain text if no credential store exists
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka auth logout

Revoke this machine's credential for a deployment

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka auth status

Deployments this machine holds credentials and bindings for

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka auth token

Print the stored token, for shell substitution

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka board — Annotation boards

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka board artifact

Self-contained interactive pages

Subcommands: create, init, push

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka board artifact create

Build an artifact report from a screenshot set

FlagDefaultHelp
--branch—branch (default: the current branch)
--from—source capture root (default: .vitrinka/screenshots)
--jq—run a jq expression over the envelope and print its results (implies --json)
--kindreportartifact kind
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name (default: this repository)
--quality—JPEG quality (default 85)
--select—shots to embed: "1,3-5" (1-based manifest positions)
--size—longest-edge resize in px (default 720)
--slug—artifact slug (required; becomes the set key)
--source—source set override: project/branchSlug/key
--title—human title (default: the journey title, then the slug)
--yes—accept every proposed plan without asking
vitrinka board artifact init

Scaffold an artifact and its set config

FlagDefaultHelp
--branch—branch (default: the current branch)
--jq—run a jq expression over the envelope and print its results (implies --json)
--kindreportartifact kind (seeds the design direction)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name (default: this repository)
--slug—artifact slug (required; becomes the set key)
--title—human title (default: the slug)
--yes—accept every proposed plan without asking
vitrinka board artifact push <file.html>

Push one self-contained HTML file onto a board as an artifact card

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--board—board slug (required)
--device—the page's device: phone|tablet|web
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--section—land inside the named section (a brainstorm board: the decision chapter)
--title—card title (default: the file name)
--yes—accept every proposed plan without asking

vitrinka board capture <ios|android|macos|web|safari>

Capture a screenshot into the set, then push

FlagDefaultHelp
--action—what was done on this screen (after --next: that branch's wire label)
--boxes—runner text map in source-image pixels (default: <adopted image>.boxes.json)
--device—device name
--file—adopt an existing image instead of capturing
--hidpitrueweb: refuse a 1× file when --viewport is known (default: vitrinka.config.json capture.hidpi, on)
--hq—full-fidelity asset: no lossy re-encode, no resize
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—stable shot label (journey wiring targets it)
--next—journey branch: the target shot's label (repeatable)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--note—caption (required)
--open—deep link to open before capturing
--region—macOS capture region x,y,w,h
--root—capture root (default: .vitrinka/screenshots)
--route—app route (required)
--settle—seconds to wait before capturing (default 4 with --open, else 0)
--src—implementing source file (repeatable or comma-separated)
--state—notable app/auth state
--target—{x,y,w,h} JSON bbox of the clicked element (follows a --next)
--title—human title (also names the file)
--type—safari: css selector of the input to tap for --state keyboard (default: the first text input)
--udid—iOS simulator UDID
--url—provenance URL (beats --open in the manifest); for safari: the page to open (required)
--viewport—WxH or WxH@scale (e.g. 393x852@3)
--yes—accept every proposed plan without asking

vitrinka board cards

Cards on a board

Subcommands: rm

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka board cards rm <board> <id…>

Trash cards on a board (ids, comma lists and ranges such as 362-370)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--why—why these cards go — required to confirm removing cards you did not create
--yes—accept every proposed plan without asking

vitrinka board compose <board>

Compose cards onto a board from compose_board arguments (JSON file or - for stdin)

FlagDefaultHelp
--file—compose_board arguments as JSON (- reads stdin); a board key is ignored
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka board create

Turn a set into an annotation board

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--btitle—board title
--journey—build a branching journey tree instead of a flat flow board
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--root—capture root (default: .vitrinka/screenshots)
--slug—board slug (default: <project>-<branch>-<key>, the set's address)
--title—board title (alias of --btitle)
--yes—accept every proposed plan without asking

vitrinka board diagram

Refreshable architecture diagrams

Subcommands: import, schema

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka board diagram import <file>

Parse OpenAPI, SQL DDL or docker-compose into a diagram

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--board—board slug (required)
--jq—run a jq expression over the envelope and print its results (implies --json)
--kind—auto|openapi|sqlddl|compose (default: auto-detect)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--rev—source revision (git SHA) for the ↻ micro-label
--section—land inside the named section frame
--title—diagram card title
--verbose—print the full card JSON instead of the summary
--yes—accept every proposed plan without asking
vitrinka board diagram schema

Introspect a live Postgres locally and push its schema

Subcommands: push

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka board diagram schema push

Introspect --db locally via psql and push the parsed schema

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--board—board slug (required)
--db—postgres connection URL (required; stays local)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--rev—source revision for the ↻ micro-label
--section—land inside the named section frame
--title—diagram card title
--verbose—print the full card JSON instead of the summary
--yes—accept every proposed plan without asking

vitrinka board dump <dir>

Dump a directory of captures onto a board (create-or-reuse, upload, ledger card)

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--board—board slug (default: render-audit-<date>-<label>-<sha7>)
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—round label used in the default slug, title and ledger (default: the dir name)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--projectbenchmarkingowning project when the board is created
--title—board title when created (default: "Render audit · <date> · <label> @ <sha7>")
--workspace—workspace to write into (default: the bound workspace)
--yes—accept every proposed plan without asking

vitrinka board edit [path]

Open a file or project in the Vitrinka editor

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--print—print the deep link only
--project—project name override for the registry entry
--yes—accept every proposed plan without asking

vitrinka board import-chat [file.ndjson]

Publish a chat transcript (eve run or NDJSON) as a chat card

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--allow-unredacted—publish the transcript as-is despite findings
--assistant-label—assistant bubble label (default: eve / assistant)
--board—board slug (required unless --dry-run)
--dry-run—print the card payload instead of publishing
--eve—eve session/run id — fetched through the vitrinka eve proxy
--jq—run a jq expression over the envelope and print its results (implies --json)
--ndjson—NDJSON transcript file (or pass it as the positional argument)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--redact—mask every sensitive match as "▮▮▮ [redacted-<type>]" and publish
--section—land inside the named section frame
--title—card title (default: the run title / file name)
--user-label—user bubble label (default: the stored operator)
--yes—accept every proposed plan without asking

vitrinka board init

Create a .vitrinka board config for publishing

FlagDefaultHelp
--branch—branch (default: the current branch)
--jq—run a jq expression over the envelope and print its results (implies --json)
--key—set key (default: today's date)
--kindscreenshotsset kind
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name (default: this repository)
--root—capture root (default: .vitrinka/screenshots)
--title—human title
--yes—accept every proposed plan without asking

vitrinka board list

List boards, optionally filtered by project, subgroup, type or tag

FlagDefaultHelp
--archived—include archived boards
--jq—run a jq expression over the envelope and print its results (implies --json)
--match—how to combine tags: all (default) or any
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—only boards owned by this project
--subgroup—only boards in this sidebar subgroup
--tags—comma-separated tags; prefix one with '-' to exclude
--type—only boards of this board type (brainstorm, docs, journeys…)
--yes—accept every proposed plan without asking

vitrinka board meta

Set the journey header (kicker, title, accent, intro, chips)

FlagDefaultHelp
--accent—title substring to accent
--chip—"Key=Value" chip (repeatable; replaces all stored chips)
--intro—journey intro paragraph
--jq—run a jq expression over the envelope and print its results (implies --json)
--kicker—journey kicker
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--root—capture root (default: .vitrinka/screenshots)
--title—journey title
--yes—accept every proposed plan without asking

vitrinka board open

Open the thing you're working on: the set's live board, or vitrinka home

FlagDefaultHelp
--browser—force the https URL even when Vitrinka.app is installed
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--print—print the URL only
--qr—render the URL as a terminal QR code instead of opening it
--root—capture root (default: .vitrinka/screenshots)
--yes—accept every proposed plan without asking

vitrinka board pull

Restore a screenshot set's files into the capture root

FlagDefaultHelp
--branch—branch the set was pushed from (default: the descriptor, else the current branch)
--jq—run a jq expression over the envelope and print its results (implies --json)
--key—set key (default: the descriptor, else today's date)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name (default: the root's descriptor, else this repository)
--root—capture root (default: .vitrinka/screenshots)
--yes—accept every proposed plan without asking

vitrinka board push

Publish the set to vitrinka

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-design—skip sending the repo's DESIGN.md with an artifact push
--no-fix—skip the doc.json preflight autofix (typos, entities, JSON damage)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--no-render—skip the server's post-publish smoke render (and its screenshot download)
--prune—mirror the folder: delete the set's files it no longer holds
--revive—publish onto an artifact that was deleted: its page comes back (same address) instead of the push being refused
--root—capture root (default: .vitrinka/screenshots)
--source—cross-link source set: project/branchSlug/key
--title—human title, re-sent on every push
--yes—accept every proposed plan without asking

vitrinka board rename <project>/<branchSlug>/<selector> [new-name]

Give the set a stable custom name

FlagDefaultHelp
--clear—clear the custom name
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka board share <board>

Mint a share link for outside people, optionally opening on one element

FlagDefaultHelp
--card0open the link on this element (the id in /a/<id>) as a document; the link still grants the whole board
--expires30dlink lifetime: 24h, 7d, 30d, never
--jq—run a jq expression over the envelope and print its results (implies --json)
--modeviewview (read-only) or annotate (link holders can leave feedback)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka board upload <files...>

Upload files onto a board as cards

FlagDefaultHelp
--actor—X-Board-Actor attribution (default: the stored operator)
--anchor—dock beside this card id
--board—board slug (required)
--create-section—create --section as a new frame even when its name is a near match of an existing one
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--section—land inside the named section frame
--side—which side of the anchor: right|below
--yes—accept every proposed plan without asking

vitrinka board view <board>

Open a board in the browser, or print its link

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--webtrueopen in a browser; --web=false only prints the link
--yes—accept every proposed plan without asking

vitrinka config — This machine's vitrinka settings

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka config bind [workspace]

Bind this repo to a workspace on a deployment

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name to bind (default: this repository)
--yes—accept every proposed plan without asking

vitrinka config default [workspace]

Show or set this deployment's default workspace

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka config hidpi [on|off]

Show or set whether this repo's web captures are 2× (default on)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka config operator [name]

Show or set the board-attribution operator persona

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka config prefix [path] [workspace]

Show or set path-prefix workspace rules

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka config reviewer [self|codex]

Show or set the lane this machine's reviews judge on (default self)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka config writes [confirm|auto]

Show or set the write mode for defaulted directories

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka docs — Look up the deploy's unified reference: element kinds, card kinds, artifact components, guides

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka docs ask <request…>

Ask for a vitrinka command in plain words

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—run the proposed command without asking

vitrinka fav — Your bookmark tree — star boards, cards, sessions, tasks and projects

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka fav add <kind> <id|slug>

Star a board, card, session, task or project

FlagDefaultHelp
--folder—file into this folder: an id, or a name (created when missing)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--scope—personal or workspace (default: the workspace's default star scope)
--yes—accept every proposed plan without asking

vitrinka fav list

Print your bookmark tree

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--scopeallwhich root: personal, workspace or all
--yes—accept every proposed plan without asking

vitrinka fav rm <kind> <id|slug>

Remove a star

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--scope—personal or workspace (default: the workspace's default star scope)
--yes—accept every proposed plan without asking

vitrinka intake — The intake queue — drafts proposed by sessions, annotations, reports, PRs and Eve

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka intake accept <id>

Accept a pending draft

FlagDefaultHelp
--family—decide the whole pending family in one verdict: a QA plan draft with its journeys, or the journeys proposed on a live plan
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka intake decline <id>

Decline a pending draft

FlagDefaultHelp
--family—decide the whole pending family in one verdict: a QA plan draft with its journeys, or the journeys proposed on a live plan
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka intake list

List pending intake drafts with their dedupe verdicts (--status declined|merged for closed ones)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--status—pending (default) | accepted | declined | merged
--yes—accept every proposed plan without asking

vitrinka intake merge <id>

Merge a pending draft

FlagDefaultHelp
--into0the task this draft duplicates
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka intake propose <title>

Propose a draft through the intake door (deduped; a human accepts it)

FlagDefaultHelp
--body—markdown body
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--type—task | bug | story | epic | todo
--yes—accept every proposed plan without asking

vitrinka me — Todos, agenda, diary, schedules, work time and your project brief

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka me agenda [today|tomorrow|<day>|week]

Your planned days: list (default today), add a task, done, move, rm

Subcommands: add, done, move, rm

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--people—whose days: me and/or user ids, comma-joined (default me)
--project—only this project's tasks (<project> or <workspace>/<project>)
--yes—accept every proposed plan without asking
vitrinka me agenda add <task>

Plan an existing task on a day (default today): its id, <workspace>/<id>, key or url

FlagDefaultHelp
--at—start HH:MM on the quarter hour (omit for all-day)
--for—length on the quarter hour, e.g. 90m or 1h30m (default 1h)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--on—plan it on a day: YYYY-MM-DD, a weekday, yesterday
--person—plan it on someone else's agenda by user id (workspace admins)
--today—plan it today (the default)
--tomorrow—plan it tomorrow
--yes—accept every proposed plan without asking
vitrinka me agenda done <item>

Tick an agenda item — closes the item only, never the task's state (a todo completes)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me agenda move <item>

Move an agenda item to another day, set its time, or make it all-day

FlagDefaultHelp
--all-day—clear the time block
--at—start HH:MM on the quarter hour (omit for all-day)
--for—length on the quarter hour, e.g. 90m or 1h30m (default 1h)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--to—the new day: today, tomorrow, YYYY-MM-DD, a weekday
--yes—accept every proposed plan without asking
vitrinka me agenda rm <item>

Take an item off its day (the task itself is untouched)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka me brief

The project brief — now, next, blocked, what changed, who holds what, Eve's suggestions

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka me diary

The personal diary — promote a recorded meeting into a project

Subcommands: promote

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me diary promote <card>

Turn a diary meeting card into a meeting task (audio + transcript attached) in a project

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—the project the meeting task lands in (required; must exist there)
--workspace—the workspace the task lands in (default: the bound workspace)
--yes—accept every proposed plan without asking

vitrinka me schedule

Scheduled reminders — add, list, ripe, move, skip, end

Subcommands: add, end, list, move, ripe, skip

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me schedule add <title> --in <dur> | --at <time>

Schedule a todo at a clock time

FlagDefaultHelp
--at—a clock time: RFC 3339, 'YYYY-MM-DD HH:MM', 'tomorrow 17:30', 'fri 09:00', '17:30'
--body—markdown body
--every—recur every … (one segment: 1d · 1w · 4h)
--in—a delay from now (30m · 4h · 3d · 2w)
--jq—run a jq expression over the envelope and print its results (implies --json)
--lead—ripen this long before the time (default 2h)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--priority—low | normal | high
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me schedule end <id>

End a scheduled todo (status done; a recurring series stops)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me schedule list

Open scheduled todos bucketed OVERDUE / TODAY / THIS WEEK / LATER (--all: every project)

FlagDefaultHelp
--all—every project
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me schedule move <id> --in <dur> | --at <time>

Reschedule a todo

FlagDefaultHelp
--at—a clock time: RFC 3339, 'YYYY-MM-DD HH:MM', 'tomorrow 17:30', 'fri 09:00'
--in—a delay from now (30m · 4h · 3d)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me schedule ripe

Todos that are ripe now (--claim: announce each once per cooldown; --all: every project)

FlagDefaultHelp
--all—every project (/api/v1/me/ripe)
--claim—record the announcement; repeat within the cooldown prints nothing
--compact—one line per todo
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me schedule skip <id>

Skip a recurring todo's current occurrence (one step forward)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka me time

Automatic human and agent work tracking

Subcommands: capture, disable, enable, hooks, service, status

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me time capture

Run automatic capture and durable delivery until stopped

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me time disable

Pause local capture immediately

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me time enable

Opt in on this machine and register automatic agent hooks

FlagDefaultHelp
--exclude-application—bundle identifiers never recorded
--humantruecapture foreground human activity with the native sampler
--idle-seconds120idle threshold
--install-hookstrueregister machine hooks (false for isolated harness verification)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project for unassigned human activity
--samplerworktimeVýbava worktime executable
--yes—accept every proposed plan without asking
vitrinka me time hooks

Render hook settings for an isolated harness without installing them

FlagDefaultHelp
--harnessclaudeclaude or codex
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me time service

Automatic capture at login

Subcommands: install

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me time service install

Keep the opted-in collector running at macOS login

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me time status

Show consent, routing and pending capture

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka me todo

Personal todos — add, list, show, done, drop, milestones

Subcommands: add, backfill, done, drop, list, milestone, show

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me todo add <title>

Add a todo — a trigger, a milestone, a due date or a clock time

FlagDefaultHelp
--at—a clock time: RFC 3339, 'YYYY-MM-DD HH:MM', 'tomorrow 17:30', 'fri 09:00', '17:30'
--body—markdown body
--body-file—read the body from a file (- = stdin) — a GUI caller keeps big bodies out of argv
--branch—record the checkout's branch
--commit—record the checkout's HEAD commit
--context—full-context companion text (shows as [ctx])
--context-file—read the context from a file (- = stdin)
--depends—task ids this todo waits on, comma-separated (a blocks link)
--due—a whole-day deadline (YYYY-MM-DD)
--every—recur every … (one segment: 1d · 1w · 4h)
--in—a delay from now (30m · 4h · 3d · 2w)
--jq—run a jq expression over the envelope and print its results (implies --json)
--lead—ripen this long before the time (default 2h)
--milestone—wait for this milestone (by name; created when missing)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--priority—low | normal | high
--project—project slug (default: this checkout's)
--trigger—a free-text trigger the model judges ("when the PR merges")
--when—a typed condition the server fires: 'pr 472 merged' · 'release cut' · 'deployed prod' · 'path internal/x/**' · 'task 12' · 'after 31' (other text stays prose)
--yes—accept every proposed plan without asking
vitrinka me todo backfill

Propose typed when conditions for the project's prose-trigger todos (--dry-run shows the plan; each proposal needs a human verdict)

FlagDefaultHelp
--dry-run—print the plan without filing proposals
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me todo done <id>

Complete a todo (a recurring one rolls to its next occurrence)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me todo drop <id>

Drop a todo (status cancelled)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me todo list

List todos (open by default; --all every project; --here the checkout's, silent when none)

FlagDefaultHelp
--all—every project
--closed—include done and dropped todos
--compact—one line per todo: - #id title [ctx] [project] — when (high)
--here—the checkout's project; prints nothing when none resolves
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--opentrueopen todos only (the default)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me todo milestone

Milestones the todos wait on — add, list, reach, unreach

Subcommands: add, list, reach, unreach

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka me todo milestone add <name>

Create a milestone (--due YYYY-MM-DD)

FlagDefaultHelp
--due—target date (YYYY-MM-DD)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me todo milestone list

List the project's milestones (✓ = reached)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me todo milestone reach <name|id>

Mark a milestone reached — the todos waiting on it ripen now

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me todo milestone unreach <name|id>

Clear a milestone's reached mark

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka me todo show <id>

Read one todo in full — fields, context, body, links, milestone

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka outbox — Writes queued while the deployment was unreachable — list, flush, retry, drop

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka outbox drop <id>

Give up a queued write for good (asks first; --yes skips)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka outbox flush

Replay the pending writes now, oldest first, each exactly once

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka outbox list

Show pending, parked and recently replayed writes

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka outbox retry <id>

Put a parked write back in the queue (--new-key: send it as a new request)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--new-key—send under a fresh Idempotency-Key — only after checking the change did NOT land (a request_in_doubt park)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka project — This repository's vitrinka wiring

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka project commits

The commit convention: show it, or turn the subject prefix on/off for this project

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--subject—on|off — prefix commit subjects with the task id in the workspace style
--yes—accept every proposed plan without asking

vitrinka project copilot

Read the project Overview: Eve's brief, needs you, gating bugs, next, active sprints, week

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--tz—IANA zone placing today (default: your timezone pref)
--yes—accept every proposed plan without asking

vitrinka project deploy-mark <env> <sha>

Record that a commit reached an environment (prod · staging · …) so deployed <env> todos fire

FlagDefaultHelp
--at—when it reached the environment (RFC 3339; default now)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka project fields

A project's custom-field definitions — list, add, update, remove

Subcommands: add, list, remove, update

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka project fields add <key> <label> --kind <kind>

Define a field (kinds: text longtext select multiselect checklist number date url relation)

FlagDefaultHelp
--applies-to—task type this field belongs to: * | task | bug | story | epic
--default—select default (one of the options)
--jq—run a jq expression over the envelope and print its results (implies --json)
--kind—value kind
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--options—select/multiselect values, comma-separated
--position0sort position
--project—project slug (default: this checkout's)
--required—mark the field required
--yes—accept every proposed plan without asking
vitrinka project fields list

List the project's field definitions

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka project fields remove <key>

Delete a definition and every value stored under it

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka project fields update <key>

Patch a definition — only the flags you pass change (key and kind are immutable)

FlagDefaultHelp
--applies-to—task type this field belongs to: * | task | bug | story | epic
--default—select default (one of the options)
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—new label
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--options—select/multiselect values, comma-separated
--position0sort position
--project—project slug (default: this checkout's)
--required—mark the field required
--yes—accept every proposed plan without asking

vitrinka project history

Product snapshot, stable chapters and original source versions

Subcommands: chapter, chapters, snapshot

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka project history chapter <id>

Read original product history with stable snapshot cursors

FlagDefaultHelp
--cursor—opaque next cursor; never mix snapshot cursors
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit20bounded page size (1–50 chapters; 1–200 sources)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--snapshot—snapshot watermark for the first page; continuation cursor already carries it
--yes—accept every proposed plan without asking
vitrinka project history chapters

Read original product history with stable snapshot cursors

FlagDefaultHelp
--cursor—opaque next cursor; never mix snapshot cursors
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit20bounded page size (1–50 chapters; 1–200 sources)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--snapshot—snapshot watermark for the first page; continuation cursor already carries it
--yes—accept every proposed plan without asking
vitrinka project history snapshot

Read the product snapshot without fetching its history

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka project index

Configure and refresh the path autocomplete index

Subcommands: configure, status

FlagDefaultHelp
--components—scan a UI library and push the component index instead
--dry—with --components: print the scan as JSON and push nothing
--dry-run—print the exact manifest and upload nothing
--explain—explain whether one repository-relative path is indexed, and why
--from—push an enriched components JSON file instead of scanning (with --components)
--jq—run a jq expression over the envelope and print its results (implies --json)
--library—UI kit name, one per library in a monorepo (with --components)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name (defaults to the repository name)
--root—capture root of the repo to index (defaults to the current repository)
--src—comma-separated component dirs to scan (with --components)
--yes—accept every proposed plan without asking
vitrinka project index configure

Interactively define, preview and approve the index policy

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka project index status

Show the policy, approval and last-upload state — read-only

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

File this checkout under an existing vitrinka project (a multi-repo project's next repository)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—take every default without prompting

vitrinka project merge <from> --into <to>

Merge a project into another project of the same workspace

FlagDefaultHelp
--adopt—mint one epic in <to> (titled by --title) and re-parent <from>'s root tasks under it
--allow-mirror-push—merge even though <to> mirrors to a tracker with local truth (the moved tasks will be pushed)
--apply—write the merge (default: dry run)
--dry-run—print what would move and write nothing — the default, spelled out
--into—the project <from> merges into — it survives (required)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--title—the epic's title (with --adopt)
--yes—accept every proposed plan without asking

vitrinka project merge-plan --into <project>

List the stray projects a merge into <project> would move — a dry run, nothing is written

FlagDefaultHelp
--into—the target project the strays would merge into (required)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka project now

Read needs-you, outcomes and next work at project or sprint scope

FlagDefaultHelp
--category—category ids (repeatable or comma-separated); omit for all categories
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--sprint0scope sprint id; 0 reads the project
--yes—accept every proposed plan without asking

vitrinka project release

The release track: show each repository's window, --refresh to sweep them, --cut to freeze the release

FlagDefaultHelp
--cut—freeze the release page and open the next window (asks first; --yes confirms)
--expect-head—with --cut: refuse unless the window's head is this commit (the SHA you checked)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--notes—link the release's notes document: <project>/<branch>/<key> | <card URL> | <card id>
--notes-clear—unlink the release's notes document and drop its preview from the board
--project—project slug (default: this checkout's)
--refresh—sweep every repository of the release and ask Eve to rewrite the page
--repo—with --refresh: <owner>/<name>[:<branch>][@<sha|RFC3339>], once per repository (the first refresh names every repository and its start)
--title—with --cut: the release's name (default: the page's own, else the date)
--until—with --refresh: pin the primary repository's window end to this commit on its branch (full SHA); only merges it contains are swept
--version—with --cut: the release's version
--yes—accept every proposed plan without asking

vitrinka project tidy

Sweep legacy roots and stray shots into .vitrinka/

FlagDefaultHelp
--all—also move loose images and audit files (not just shot-*.png litter)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—apply the planned moves

vitrinka project transfer [project] --to <workspace>

Copy a whole project into another workspace you own

FlagDefaultHelp
--archive-source—after the destination commits, retire the source: boards archived, tasks trashed, name marked moved
--dry-run—count rows and blobs, write nothing
--jq—run a jq expression over the envelope and print its results (implies --json)
--merge—the destination already has this project: merge vocabulary by key, append content, rename colliding boards/sets
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--to—destination workspace slug (required)
--yes—accept every proposed plan without asking

Drop this checkout from its project: the ledger row and the origin's line in the project's repositories

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka qa — Runs, exploratory sessions, pairing and session archives

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka qa pair

Supervise the app under test for live pairing

Subcommands: logs, relay, restart, run, status, stop

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa pair logs <stack>

Print a stack's log path and tail

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--lines60how many trailing lines to print
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa pair relay

Relay the local Claude session's replies to the pair panel (opt-in)

FlagDefaultHelp
--dir—repo directory whose Claude transcript to tail (default: this repo's root)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--session0recorder session id (default: the project's newest live session)
--transcript—exact transcript .jsonl to relay (default: the repo's newest at start — PINNED for the whole run, never switched)
--yes—accept every proposed plan without asking
vitrinka qa pair restart [stack…]

Restart supervised stacks so a fix reaches the running app

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa pair run [stack…]

Start the project's run stacks (reuse when already healthy)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa pair status

Show each stack's supervision, liveness and readiness

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa pair stop [stack…]

Stop supervised stacks

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka qa run [flags] -- <test command> [args…]

Run a test command and publish its results onto the feature's QA record — one verb, no manifest to write

Subcommands: publish

FlagDefaultHelp
--app—app name stamped on the manifest
--bugsintakewhat a failing case becomes: intake (a bug draft blocking the journey) · direct (a live bug task) · none
--dry-run—run and fold, print the manifest, publish nothing
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--no-shots—send the manifest only — no screenshots, no log
--pr—the run's pull request as owner/repo#n
--project—the project for an unplanned run (default: the repo's project)
--results—the result file or directory to fold (skips the scan)
--runner—runner name stamped on the manifest (default: from the result format)
--task0the target task: a qa task, a journey, a story or an epic (default: the checkout's vt-<id>, else Unplanned runs)
--yes—accept every proposed plan without asking
vitrinka qa run publish <manifest.json>

Publish a test run manifest: create or extend the qa task + journeys, set verdicts, compose the qa board, attach shots and log, file failing cases

FlagDefaultHelp
--bugsintakewhat a failing case becomes: intake (a bug draft blocking the journey) · direct (a live bug task) · none
--jq—run a jq expression over the envelope and print its results (implies --json)
--log—the run log to attach (default: the manifest's log)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--no-shots—send the manifest only — no screenshots, no log
--pr—the run's pull request as owner/repo#n (attached to the epic as a pr ref)
--project—the project for an unplanned run (default: the repo's project)
--task0the target task: a qa task, a journey, a story or an epic (default: the checkout's vt-<id>, else Unplanned runs)
--yes—accept every proposed plan without asking

vitrinka qa session

Archive, continue and launch coding-agent sessions behind tasks

Subcommands: archive, continue, launch

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa session archive <transcript.jsonl> --task <id>

Archive a harness transcript behind a task (redacted, paths made portable) — a hand-off act, never automatic

FlagDefaultHelp
--hint—when a reader should load this transcript ("load when …")
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--task—task id the session belongs to
--version-of—ref id this upload is a new version of (default: same filename on the task)
--yes—accept every proposed plan without asking
vitrinka qa session continue <task-id>

Print the task's latest distill as a /continue brief; offer native resume when the transcript's harness is yours

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--ref—read this distill ref instead of the latest
--yes—accept every proposed plan without asking
vitrinka qa session launch <task-url|slug> <dir>

Open a fresh coding-agent session through $VITRINKA_SESSION_LAUNCHER, or say which /continue line to run by hand

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka qa usertest

Exploratory testing as one session: start · case · (snap…) · verdict · finish → the QA record

Subcommands: case, finish, start, status, verdict

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa usertest case <title>

Open a case — every following snap attaches to it until its verdict

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--key—journey key (default: the title's slug)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa usertest finish

Fold the session into a run manifest and publish it: qa task, one journey per case, verdicts, shots, bug drafts

FlagDefaultHelp
--bugsintakewhat a failing case becomes: intake · direct · none
--dry-run—write and print the manifest, publish nothing
--jq—run a jq expression over the envelope and print its results (implies --json)
--keep—keep the session file after publishing
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--no-shots—send the manifest only — no screenshots
--pr—the session's pull request as owner/repo#n
--project—the project for an unplanned session (default: the repo's project)
--task0the target task (default: the session's, else the checkout's vt-<id>, else Unplanned runs)
--yes—accept every proposed plan without asking
vitrinka qa usertest start

Open an exploratory testing session

FlagDefaultHelp
--app—app name stamped on the run
--device—device name stamped on the run
--force—discard an open session and start a new one
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--platform—platform stamped on the run (ios · android · web · macos)
--project—the project for an unplanned session (default: the repo's project)
--task0the feature this session tests: a qa task, a story or an epic (default: the checkout's vt-<id>)
--yes—accept every proposed plan without asking
vitrinka qa usertest status

Show the open session

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka qa usertest verdict <pass|fail|skip>

Close the open case with its verdict

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--note—what happened (a failing case's note becomes the bug draft's first line)
--yes—accept every proposed plan without asking

vitrinka review — The review brief and its rules — the rubric a review pass applies

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka review brief

Render the review brief — the rules a review pass applies, as one prompt block

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--persona—seat line appended to the brief ("a senior mobile designer reviewing onboarding")
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka review file <board> <candidates.json>

File explicitly kept, version-pinned candidates through one annotate batch

FlagDefaultHelp
--agent—author runtime (required): claude-code | codex | eve | gemini | other:<slug> | judge/<model>
--dry-run—resolve anchors and return version-pinned crop URLs without filing
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka review judge <board|set> | --run <id>

Judge captured screens and audit findings; --status reads compact results; --run has Eve judge an eve review run

Subcommands: export

FlagDefaultHelp
--batch—request provider batch processing
--calibration—audit a calibration sample of passes
--instructions—optional review focus
--journey—scope to the latest journey pass
--jq—run a jq expression over the envelope and print its results (implies --json)
--model—judge model override; default team routing
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--rules—rule IDs (comma-separated; default all enabled)
--run0have Eve judge an eve review run (vitrinka review plan <board>… --judge eve)
--section—scope to a board section
--set—scope is project/branchSlug/selector; resolve its existing board on the server
--status—read existing judgments without starting a pass
--yes—accept every proposed plan without asking
vitrinka review judge export <job>

Export version-pinned judgments as JSON; explicitly mark keep before review file

FlagDefaultHelp
--candidates—export mechanical candidates instead of model judgments
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka review lint <shots-dir>

Measure captured images and boxes.json; write candidates.json without a browser or model

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--locale—captured locale, e.g. cs-CZ
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--output—output path (default <shots-dir>/candidates.json)
--theme—captured theme: dark or light
--viewport—WxH in source-image pixels; default image dimensions
--yes—accept every proposed plan without asking

vitrinka review plan [board…]

Plan a review over boards — scope, capture gaps, duplicates, reuse — as a review run; --run reads its receipt

FlagDefaultHelp
--after0with --cards: the next page after this card id (the reply's moreCards)
--cards—with --run: list each card's receipt
--checklist—checks judged beside the project rubric (text or a digest): reuse matches only runs with the same
--full—judge everything again, reusing nothing
--jq—run a jq expression over the envelope and print its results (implies --json)
--judge—eve: Eve judges the run server-side (vitrinka review judge --run <id>)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--run0read a planned run's receipt
--scope—latest (each journey's last capture pass) or all
--section—review these sections instead of a scope (repeatable)
--sight—with --run: echo the code printed on sheet 1
--state—with --cards: only cards in this receipt state
--yes—accept every proposed plan without asking

vitrinka review rules

Read, lint and publish review rules (markdown with frontmatter)

Subcommands: get, lint, list, put

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka review rules get <id>

Print one rule as markdown (the form put takes back)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--workspace—address the workspace layer instead of a project
--yes—accept every proposed plan without asking
vitrinka review rules lint <file>...

Lint rule files with the server's own linter; --fix repairs what is mechanical

FlagDefaultHelp
--fix—rewrite each file with the mechanical repairs (BOM, entities, enum near-misses, a derived id, a default check)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka review rules list

List the resolved rules with the layer each one comes from

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--workspace—address the workspace layer instead of a project
--yes—accept every proposed plan without asking
vitrinka review rules put <file>...

Publish rule files to the project (or --workspace) layer — lints first, every put is a new version

FlagDefaultHelp
--fix—autofix each file on disk before publishing
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--workspace—address the workspace layer instead of a project
--yes—accept every proposed plan without asking

vitrinka review stats

Human verdicts per review rule and agent/model

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—filter by project; omit for the workspace
--since90dlookback days (90d) or RFC3339 timestamp
--yes—accept every proposed plan without asking
FlagDefaultHelp
--deep—with --resolve: Eve picks among an ambiguous verdict's candidates (spends AI credits)
--groups—comma-separated groups to run: tasks,annotations,pages,boards,tags,cards,sessions,shots (default: all; tasks alone with --type/--state)
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit0max hits per group (default 8, max 50; with --resolve at most 5)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—narrow to one project
--resolve—read <text> as one task reference: a verdict and at most 5 candidates
--state—canonical task state key (tasks only)
--tags—comma-separated tag slugs (boards, cards, sessions)
--type—task type key (tasks only)
--yes—accept every proposed plan without asking

vitrinka search query <sql>

Run one read-only SELECT over the workspace's agent calls ledger and board/task facts

FlagDefaultHelp
--format—table | json | csv (default: table on a TTY, json otherwise)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--param—positional value for the next ? placeholder (repeatable)
--yes—accept every proposed plan without asking

vitrinka search resolve <url>

Resolve a pasted app URL to the task, project, board or card it names — in any workspace you belong to

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka setup — First run: sign in, plugins + MCP, this repo, the index — then modules, skills, extension, uninstall

FlagDefaultHelp
--advanced—show the noise table, the directory picker and the exact manifest
--check—with --runners: report drift between the declaration and the repo, exit 1 on drift, write nothing
--experimental—also install the vitrinka-experimental plugin (flows still proving themselves; Claude Code only, opt-in)
--extension—install the journey-recorder extension without asking
--force-icon—send the repository's icon again, even over an icon a person chose for the project
--harness—project-level MCP files to render from vitrinka.config.json: a comma-separated list of claude, codex, cursor, opencode, vscode, gemini, or all (default: claude plus every harness detected on this machine or in the repo)
--jq—run a jq expression over the envelope and print its results (implies --json)
--local—project scope: no shim/completion, harness project files only, no Claude Code or Codex registry writes (both are global)
--mcp—register the MCP endpoints without asking
--modules—the modules to install as plugins, comma-separated (pm, me, qa, experimental; core is always on) — default: every module but experimental, or the choice vitrinka setup modules recorded
--no-acp—skip the ACP listener adapters (vitrinka work listen --harness …)
--no-completion—skip shell completion
--no-extension—skip the journey-recorder extension
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-mcp—skip the MCP registrations
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--operator—set the board-attribution operator persona
--project—project name (default: the project declaring this origin, else the repository name)
--runners—declare where the repo's test runners write results (vitrinka.config.json runners[]); only this step runs
--yes—accept every proposed plan without asking

vitrinka setup extension

Install, update and diagnose the recorder extension

Subcommands: setup, update

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka setup extension setup

Unpack the marketplace release and register the update host

FlagDefaultHelp
--force—re-download even when the installed version matches
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka setup extension update

Swap the folder to the newest release (the extension reloads itself)

FlagDefaultHelp
--check—report whether an update exists, install nothing
--force—reinstall even when current
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka setup modules

Modules are plugins: list, enable or disable one (core is always on)

Subcommands: disable, enable, list

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka setup modules disable <module|plugin>

Disable a module by removing the plugin that ships it (pm, me, qa, experimental)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka setup modules enable <module|plugin>

Enable a module by installing the plugin that ships it (pm, me, qa, experimental)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka setup modules list

List every module, its plugin and where it is installed

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka setup skills

The skill roster: every plugin's skills by module, and the one-skill show|hide switch

Subcommands: hide, show

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka setup skills hide <skill>

Hide an optional skill in Claude Code (skillOverrides)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--scope—settings scope: user (~/.claude) or project (./.claude)
--yes—accept every proposed plan without asking
vitrinka setup skills show <skill>

Show an optional skill in Claude Code (skillOverrides)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--scope—settings scope: user (~/.claude) or project (./.claude)
--yes—accept every proposed plan without asking

vitrinka setup uninstall

Remove everything setup put here

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--local—project scope: legacy copies under ./.claude, project-scope MCP first
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--purge—also remove ~/.config/vitrinka (token + operator)
--yes—accept every proposed plan without asking

vitrinka sprint — Outcome scopes — optional dates, concurrent starts and reviewed carry

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka sprint binding

Persist or resume the project's harness-session scope

Subcommands: get, set

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka sprint binding get <session>

Read the explicit session binding: unknown, none or sprint

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka sprint binding set <session>

Bind this session explicitly to --none or --sprint, using --version

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--none—affirmatively choose no sprint
--project—project slug (default: this checkout's)
--sprint0sprint id from this project's list
--version0current binding version; 0 only when unknown
--yes—accept every proposed plan without asking

vitrinka sprint cockpit <id>

Read one sprint's cockpit: goal, counts, obligations, gating bugs, scope change, people, activity, week

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--tz—IANA zone placing today (default: your timezone pref)
--yes—accept every proposed plan without asking

vitrinka sprint complete <id>

Preview explicit carry selection; --apply <preview.json> applies the reviewed version

FlagDefaultHelp
--apply—reviewed preview JSON file; accepts the CLI data envelope
--into0explicit destination sprint; 0 means backlog
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--request-id—stable idempotency id for applying this exact preview
--task—selected unfinished task ids; empty carries none
--yes—accept every proposed plan without asking

vitrinka sprint create <name>

Create an outcome scope with optional dates, goal and coverage

FlagDefaultHelp
--coverage—covered product:<key>, component:<key> or task:<id>; repeat for multiple
--ends—end date-time
--goal—finite outcome this sprint delivers
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--starts—start date-time
--yes—accept every proposed plan without asking

vitrinka sprint list

List a project's sprints

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka sprint members <id>

Read a bounded page of unfinished members for a carry preview

FlagDefaultHelp
--after0next cursor from the preceding page
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit50page size (1–200)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka sprint release

Exact candidates and evidence; verification and shipment remain human authority

Subcommands: evidence, get, list, prepare

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka sprint release evidence

Original evidence for an exact candidate

Subcommands: add, list

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka sprint release evidence add <candidate-id>

Record original evidence; verified:true requires a human browser session

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka sprint release evidence list <candidate-id>

Read a bounded evidence page

FlagDefaultHelp
--after0next cursor from the preceding page
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit50page size (1–200)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka sprint release get <candidate-id>

Read candidate identity and currentness

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka sprint release list <sprint-id>

Read a bounded candidate page

FlagDefaultHelp
--after0next cursor from the preceding page
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit50page size (1–200)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka sprint release prepare <sprint-id>

Prepare an exact repository/build candidate at the current scopeVersion

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka sprint resolve

Resolve feature/bug/followup routing before atomic task creation

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka sprint start <id>

Start alongside existing active sprints; absent dates remain absent

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka sprint status <id>

Read Before/Ship/After obligations and bounded blockers

FlagDefaultHelp
--after0next cursor from the preceding page
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit50page size (1–200)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--scope-version—first page's scopeVersion (required with --after)
--yes—accept every proposed plan without asking

vitrinka sprint update <id>

Patch goal, coverage or optional dates with the current version

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka tag — The tag vocabulary — the third axis beside project and subgroup

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka tag add <board> <tag>...

Attach tags to a board

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--set—replace the board's whole tag set instead of adding to it
--yes—accept every proposed plan without asking

vitrinka tag list

List the known tags and what carries them

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka tag remove <board> <tag>...

Detach tags from a board

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task — The task engine — list, read, file, update, comment, rank, search, ask, delete, start/stop a run, pickup, handback, spot

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task ask [<id>] <question>

Ask Eve one question about a task, or with --project about a whole project (AI credits)

FlagDefaultHelp
--intent—developer (default) · product · qa · reviewer · onboarding, or your own short phrase
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—ask over this project's tasks, or <workspace>/<project> (default with no <id>: this checkout's)
--scope—with <id>: self (the task alone) or tree (adds descendants; default for an epic)
--yes—accept every proposed plan without asking

vitrinka task brief <id>

Compose the epic's Plan chapter and print the feature-brief skeleton (fill it, then task upload --kind brief)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--out—Write the skeleton to this file instead of stdout (the skill fills it under the caps)
--yes—accept every proposed plan without asking

vitrinka task comment <id> <body>

Comment on a task (@mentions reach My work)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task create <title>

File a task

FlagDefaultHelp
--assignee—assignee name ("" unassigns)
--body—markdown body
--category0workspace category id (0 clears)
--dueAt—RFC 3339 due date ("" clears)
--endAt—RFC 3339 end
--estimate0estimate
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—labels, comma-separated
--link—an issue or page the task tracks (URL, github:o/r#7, jira:PROJ-1); repeatable
--milestone0milestone id (0 unassigns)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--obligation-file—Before/Ship/After obligation JSON, including explicit deferral owner and trigger
--origin—request origin: human, agent, system or unknown; independent of filer
--parent0parent task id (0 detaches)
--priority—urgent | high | medium | low ("" clears)
--project—project slug (default: this checkout's)
--scope-file—ScopeRequest JSON for feature/child/followup/bug/enhancement routing
--sprint0sprint id (0 unassigns)
--startAt—RFC 3339 start
--state—state key
--status—legacy status
--type—task | bug | story | epic | todo
--yes—accept every proposed plan without asking

vitrinka task delete <id>

Soft-delete a task (and trash its board projections)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task field

A task's custom-field values — get, set

Subcommands: get, set

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka task field get <id> [key]

Print a task's custom-field values (one key, or all)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka task field set <id> <key> <value|json>

Set one custom-field value (JSON for lists/checklists; a checklist merges by item; null deletes)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--replace—the checklist is the whole list (drops, renames, reorders)
--yes—accept every proposed plan without asking

vitrinka task final <id>

Compose (or rebuild) the epic's final artifact — the feature board and the versioned final page

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task find <ref>

Which task tracks this issue or page — an exact lookup by link (URL, github:o/r#7, jira:PROJ-1); none is an empty answer

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka task get <id>

Read one task in full, with its comments and refs (--include children for an epic's tree)

FlagDefaultHelp
--include—also read, comma-separated: children (an epic's tree, one call), links, events
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task handback [id] [-]

Hand the task back: land steps and gates on the task (a child only for real work), attach the summary, link the PR, end this session's run — and print the hand-back block

FlagDefaultHelp
--board—link a board by slug
--branch—the branch the work lives on (default: the checkout's current branch)
--build-on—where the next session should start building
--decide—a call a human owns, a "Decide: title" human gate on this task: "title::why[::who]" — add "::ask:<the sentence a person reads>" (repeat)
--done—one thing that shipped (repeat)
--gate—a human gate on this task, --step with kind human: "name[::who][::when]" — add "::ask:<the sentence a person reads>::why:<what waits on it>" (repeat)
--jq—run a jq expression over the envelope and print its results (implies --json)
--next—a child TASK — only work that needs its own session, PR or QA record: "title" or "bug:title" (repeat, rank order)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--omit—something left out, filed as a child: "title::why" (repeat)
--pr—link a pull request as owner/repo#number (repeat)
--prereq—a prerequisite before the next step can start (repeat)
--read-first—ref ids the next session must read first (repeat or comma-separated)
--session—the session whose live run this hand-back ends (default: $VITRINKA_SESSION_ID / $CLAUDE_SESSION_ID)
--status—move the task: backlog|todo|in_progress|in_review|done|cancelled
--step—a step on THIS task — a check on the work just done, a merge, a look: "name[::step|human|date|action][::who-or-YYYY-MM-DD][::when]" (repeat; "Merge PR #12::human::acme-lead::pr 12 merged")
--summary—the higher-level summary everyone reads (required unless the body comes from stdin)
--surface—a new API, component or place to build on (repeat)
--transcript—archive this session's transcript on the task after the hand-back and label it eve-distill — the hand-off to a colleague, never a default: bare --transcript finds the running Claude Code session's file, or --transcript=<path> for a file (Codex)
--worktree—the worktree path (default: the cwd when it is under .worktrees/)
--yes—accept every proposed plan without asking

vitrinka task label <id>

Add and/or remove labels on a task (labels are created on demand; eve-* names trigger Eve flows)

FlagDefaultHelp
--add—labels to add, comma-separated
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--remove—labels to remove, comma-separated
--yes—accept every proposed plan without asking

vitrinka task lineage [id] --file <event.json>

Land one memo run lineage event (locate or checkpoint) on a task — the door memo's outbox calls

FlagDefaultHelp
--file—the memo outbox request: {v, id, task, event, run, receipt?, archive?: {path, digest}}
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

Relate two tasks (blocks | relates | duplicates | custom --label)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—label for --rel custom
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--relrelatesblocks | relates | duplicates | custom
--yes—accept every proposed plan without asking

External links: the issue or page a task tracks — list, add <id> <url>, rm <id> <link-id>

Subcommands: add, rm

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

Attach an issue or page (URL, github:o/r#7, jira:PROJ-1); an issue another task tracks is refused with its owner

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--title—the item's title, shown beside the link
--yes—accept every proposed plan without asking

Detach one external link by its id (vitrinka task links <id> lists them)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task list

List a project's tasks (summary, working order; --sort priority,-due)

FlagDefaultHelp
--admission—admission states: committed, pending, declined, merged
--ask—a phrase Eve compiles into the filter ("open stories under the restart epic"), alone — no facet flag, --filter or --cursor beside it; needs an AI backend
--assignee—assignee name
--category—workspace category ids
--cursor—continue from a previous page
--filter—a raw filter document (base64url JSON) — overrides the facet flags
--group—state groups, comma-separated (backlog,unstarted,started,completed,cancelled)
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—labels, comma-separated
--limit50page size (max 200)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--order—rank | priority | due | created (legacy; --sort replaces it)
--origin—request origins (human, agent, system, unknown)
--parent—children of this task (any task spelling: 42, VIT-42, a URL); 0 = top-level tasks only
--project—project slug (default: this checkout's)
--sort—sort keys in precedence order, - for descending (priority,-due): rank, priority, due, start, created, updated, title, state, type, assignee, id, sprint, estimate
--state—state keys, comma-separated
--status—legacy status filter
--text—full-text filter: tasks carrying every word (task search ranks any of them)
--type—types, comma-separated (task,bug,story,epic,todo)
--yes—accept every proposed plan without asking

vitrinka task meeting-notes <id>

Ask Eve for a meeting task's notes, decisions and action-item drafts (--board composes the meeting board too)

FlagDefaultHelp
--board—also compose (or rebuild) the meeting board and link it to the task
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--workspace—the workspace the meeting task lives in (what diary promote answered)
--yes—accept every proposed plan without asking

vitrinka task mine

My work across projects — assigned, created, mentioned, overdue

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task organize

Review explicit category/parent edits before applying; IDs and provenance survive

Subcommands: apply, preview

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka task organize apply

Apply the reviewed preview plus an idempotency requestId

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking
vitrinka task organize preview

Preview selected edits without writing

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project slug (default: this checkout's)
--yes—accept every proposed plan without asking

vitrinka task pickup [id|url]

Print the task's pickup — what to do, where to start, what to read first, which branch exists, what not to load

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task qa-board <id>

Create or return the qa task's board (Plan section with the living journeys diagram + one section per journey)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task rank <id>

Move a task in the manual order (--before / --after neighbour ids; neither = to the end)

FlagDefaultHelp
--after0the task that should come AFTER this one
--before0the task that should come BEFORE this one
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka task resolve-qa

Resolve the qa task a publish belongs to — --task, else the branch's vt-<id> → its epic's open qa child

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--task—a qa task, or an epic/story/task that owns or sits under one (default: the checkout's vt-<id>)
--yes—accept every proposed plan without asking

Full-text search over this checkout's project's tasks (relevance-ranked; --all for every project; --within one task's tree)

FlagDefaultHelp
--all—search every project
--epic—only tasks under this task at any depth (any task spelling)
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit20hits (1..50)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--parent—only direct children of this task (any task spelling: 42, VIT-42, a URL)
--project—search this project, or <workspace>/<project> (default: this checkout's)
--state—only this state key (backlog, todo, in_progress, …)
--type—only this task type (bug, epic, story, todo, …)
--within—search this task's own tree instead — titles, bodies, comments, fields and refs (any task spelling)
--yes—accept every proposed plan without asking

vitrinka task spot <title>

File something you spotted but will not do in this change — a child of the bound task, else of the project's rolling 'Found during implementation' epic

FlagDefaultHelp
--body—what you saw · where (file, route, screen) · why it is out of scope here
--from-step—promote this step of the parent (item id or exact name) into the child; it leaves the checklist
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—an extra label by name, created on demand (repeat)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--parent0the bound task (default: the checkout's vt-<id>; none → the rolling epic)
--priority—urgent | high | medium | low — only when you know it
--production—a user could hit this on the deployed product: adds the might-affect-production label
--project—project slug (default: this checkout's)
--ref—evidence as kind:ref — board:<slug>, pr:owner/repo#n, session:<id> (repeat)
--type—bug (default) for a defect that exists today, task for a follow-up or a Decide:
--yes—accept every proposed plan without asking

vitrinka task start [id]

Bind this session to a task as a live run — the brief and the cards show who is on it (no id: the checkout's vt-<id>)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--session—session id to bind (default: $VITRINKA_SESSION_ID / $CLAUDE_SESSION_ID, else a per-process id)
--summary—what this run is about
--yes—accept every proposed plan without asking

vitrinka task stop <run>

End a live run with a summary

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--summary—what the run did
--yes—accept every proposed plan without asking

vitrinka task update <id>

Patch a task — only the flags you pass change

FlagDefaultHelp
--assignee—assignee name ("" unassigns)
--body—markdown body
--category0workspace category id (0 clears)
--dueAt—RFC 3339 due date ("" clears)
--endAt—RFC 3339 end
--estimate0estimate
--jq—run a jq expression over the envelope and print its results (implies --json)
--label—labels, comma-separated
--milestone0milestone id (0 unassigns)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--obligation-file—Before/Ship/After obligation JSON, including explicit deferral owner and trigger
--parent0parent task id (0 detaches)
--priority—urgent | high | medium | low ("" clears)
--project—move the task with its whole subtree into this project (states, labels, fields, sprint and milestone map by key; missing keys are created there) — a whole project is vitrinka project merge
--sprint0sprint id (0 unassigns)
--startAt—RFC 3339 start
--state—state key
--status—legacy status
--title—new title
--type—task | bug | story | epic | todo
--yes—accept every proposed plan without asking

vitrinka task upload <id> <files...>

Upload files onto a task as evidence (one file ref per file)

FlagDefaultHelp
--hint—One-line hint stored on the ref (what a reader gets from it; pickup prints it)
--jq—run a jq expression over the envelope and print its results (implies --json)
--kind—Ref kind for every file (an upload kind: file · brief · decision · plan · handoff · transcript · …; default file)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--version-of0Ref id whose lineage this upload continues as the next version (the brief skeleton's ref id from task brief); default: the file name is the lineage key
--yes—accept every proposed plan without asking

vitrinka work — The annotation work queue

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka work list

List open work items for this scope

FlagDefaultHelp
--all—every scope — conflict-free, takes no exclusive lease
--board—one board
--branch—narrow a project scope to one branch (default: the current branch)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—a project (default: this repository)
--yes—accept every proposed plan without asking

vitrinka work listen

Host a harness over ACP and feed it this scope's board work

FlagDefaultHelp
--all—every scope — conflict-free, takes no exclusive lease
--auto—answer allow_always to every permission request (unattended)
--board—one board
--branch—narrow a project scope to one branch (default: the current branch)
--harness—harness to host (default: the first detected harness that can be hosted over ACP)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—a project (default: this repository)
--takeover—steal an EXPIRED lease for this scope
--yes—accept every proposed plan without asking

vitrinka work watch

Monitor the queue and lease this repo+branch scope

FlagDefaultHelp
--all—every scope — conflict-free, takes no exclusive lease
--board—one board
--branch—narrow a project scope to one branch (default: the current branch)
--exec—headless resume: feed every work line to this harness's listening thread (claude, codex) with its own auto-approve policy
--harnessclaudethe harness this watch wakes, stamped on the lease: one of claude, codex, cursor, opencode, vscode, gemini
--jq—run a jq expression over the envelope and print its results (implies --json)
--keepalive0opt-in seconds between model-waking keepalive lines while a viewer is present; 0 disables
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--once—single lease-free probe; exit 3 when the queue is idle
--project—a project (default: this repository)
--quiet-grace5seconds to wait between diffs while the queue is non-empty
--takeover—steal an EXPIRED lease for this scope
--yes—accept every proposed plan without asking

vitrinka workspace — Workspace-wide settings

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka workspace category

Permanent Bugs/Features/Maintenance vocabulary

Subcommands: create, list, update

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka workspace category create

Create a permanent workspace category (admin)

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka workspace category list

Read a bounded page of workspace categories

FlagDefaultHelp
--after0next cursor from the preceding page
--jq—run a jq expression over the envelope and print its results (implies --json)
--limit50page size (1–200)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking
vitrinka workspace category update <id>

Configure or deactivate a category using its version (admin)

FlagDefaultHelp
--file—typed request JSON file (- reads stdin; CLI data envelopes accepted)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka workspace commit-prefix [bracket|bare|colon]

Show or set the workspace-wide subject prefix style ([vt-401] · vt-401 · vt-401:)

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

Top-level commands

vitrinka doctor

Check the installation and this repository; name the repair for each failure

FlagDefaultHelp
--all—also check every other project checkout registered on this machine
--fix—review and apply the repairs doctor found (ledger rows, setup migrations, the extension host)
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--yes—accept every proposed plan without asking

vitrinka status

Session dashboard: live board, open work queue, and listener lease

FlagDefaultHelp
--branch—branch (default: the current branch)
--jq—run a jq expression over the envelope and print its results (implies --json)
--live—repaint the report every few seconds on a terminal; ctrl-c exits
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--project—project name (default: this repository)
--root—capture root (default: .vitrinka/screenshots)
--yes—accept every proposed plan without asking

vitrinka update

Update the CLI and refresh every installed surface

FlagDefaultHelp
--jq—run a jq expression over the envelope and print its results (implies --json)
--no-input—never prompt; a step that needs consent exits 5 with its plan ($VITRINKA_NO_INPUT, $CI)
--no-queue—fail a write the deployment cannot receive instead of queueing it in the outbox ($VITRINKA_NO_QUEUE)
--verbose—hand the terminal to the child processes instead of task spinners
--yes—accept every proposed plan without asking

Guides

The same guides the binary prints with vitrinka help <topic>: the environment, the exit codes, the JSON envelope, non-interactive use and how an agent drives the CLI.

vitrinka help environment — Environment

Every variable the CLI reads. Flags beat variables, variables beat the stored config in ~/.config/vitrinka/config.json ($XDG_CONFIG_HOME is honoured).

Deployment and credentials

VariableMeaning
VITRINKA_URLDeployment origin, e.g. https://vitrinka.acme.internal. --base overrides it; unset means the stored default.
VITRINKA_TOKENCredential for this run. Beats the OS keyring and the plaintext file store.
VITRINKA_CA_CERTPath to a PEM bundle trusted for the deployment's TLS; HTTPS_PROXY / NO_PROXY are honoured as usual.
VITRINKA_UPLOAD_IDLEHow long an upload (board push, board upload) may move no bytes before it fails as stalled, as a duration like 3m (default 60s). A slow link that keeps moving never reaches it; uploads have no whole-request limit.
VITRINKA_NO_KEYRINGNon-empty: never touch the OS keyring; auth login stores to the file store after consent.
VITRINKA_KEYRING_CACHE_MSHow long a keyring read is cached inside one process, in milliseconds.
VITRINKA_OPERATORDisplay name stamped on board writes; overrides config operator.
VITRINKA_ORGOrganization slug for admin commands when you belong to more than one.

Behaviour switches

VariableMeaning
VITRINKA_NO_INPUT1: never prompt, same as --no-input. A step that needs consent exits 5.
CIAny value: no prompts, no update notice — the same as VITRINKA_NO_INPUT=1 plus VITRINKA_NO_UPDATE_CHECK=1.
NO_COLORAny value: plain output, no ANSI colour.
VITRINKA_DEBUGNon-empty: narrate every HTTP round trip on stderr.
VITRINKA_NO_AI1: disable vitrinka docs ask, the plain-words command finder.
VITRINKA_NO_UPDATE_CHECKNon-empty: skip the daily "a newer CLI exists" notice.
VITRINKA_RELEASE_FEEDWhere update fetches binaries; on-prem estates point it at their mirror.
VITRINKA_EXT_MARKETWhere setup extension fetches the recorder extension.
VITRINKA_RESOLVE_RENAMESNon-empty: session archives follow git renames when mapping paths.
VITRINKA_SESSION_LAUNCHERYour command that opens a fresh coding-agent session, flags allowed. It is split on whitespace only — quotes inside it are not honoured — so a launcher that needs a quoted word goes in a script, and the variable names the script. qa session launch <task url> <dir> runs it with both appended and prints its one-line receipt; a skill's fresh-session exit (the brainstorm's closing question, a hand-back whose remainder outgrew the context window) calls that verb. Unset, unrunnable or a non-zero exit fails, and the skill prints /continue <task url> instead.

Set by vitrinka for child processes

VariableMeaning
VITRINKA_RUN_ID, VITRINKA_RUN_DIR, VITRINKA_RUN_STARTED_ATExported to the test command under qa run so a runner can stamp its artifacts.
VITRINKA_SHOTSalways: qa run collects screenshots even when every case passed.
VITRINKA_SESSION_IDThe coding-agent session a task handback ends; CLAUDE_SESSION_ID and CODEX_SESSION_ID are read as fallbacks.
VITRINKA_LISTEN_HOST, VITRINKA_LISTEN_SCOPESet by work listen inside the hosted harness so the session knows it is being fed board work.
$ VITRINKA_URL=https://vitrinka.acme.internal VITRINKA_TOKEN=$TOKEN vitrinka status --json

vitrinka help exit-codes — Exit codes

The process status is part of the contract: a script or agent branches on it before reading anything else.

CodeNameMeaning
0okSuccess.
1failedThe command ran and failed; diagnostics[].code says why and fix says what to do.
2misuseUnknown command, bad flag or argument, or a removed name. Nothing ran.
3nothingNothing to report: work watch --once found no work.
4authNo usable credential for this deployment; run vitrinka auth login.
5needs_humanA step needs consent that --no-input forbade; the plan is in data, rerun with --yes.
130cancelledInterrupted (Ctrl+C or a cancelled prompt); nothing partial was applied.

With --json the same number is repeated as exit_code inside the envelope, so a caller that captured stdout but lost $? still has it.

$ vitrinka task get 99999 --json; echo "exit $?"
{"v":1,"ok":false,"verb":"task get","diagnostics":[{"code":"not_found","detail":"task 99999 is not in project web","fix":"list tasks with: vitrinka task list"}],"exit_code":1}
exit 1

vitrinka help json — JSON output

--json turns any command, including help, version and failures, into ONE envelope on stdout. Nothing else is printed there; progress and notes go to stderr.

{ "v": 1, "ok": true, "verb": "task list",
  "data": { "tasks": [ ... ], "nextCursor": "" },
  "diagnostics": [],
  "next": [ { "do": "Open one task", "cmd": "vitrinka task get 12" } ] }

{ "v": 1, "ok": false, "verb": "task get",
  "diagnostics": [ { "code": "...", "severity": "error", "detail": "...", "why": "...", "fix": "..." } ],
  "next": [ { "do": "..." } ],
  "exit_code": 3 }
  • v is the envelope version; data is the command's result and is the only part whose shape depends on the verb.
  • diagnostics[] explain a failure or a caveat: code is a closed vocabulary, detail the observed fact, why the proven cause when there is one, fix the exact command when one exists. A successful command may still carry severity: "info" rows — setup reports skipped when the index was deliberately left out — so branch on code, not on the array being empty.
  • next[] is what to do now, on success and failure: do describes it and cmd, when present, is executable as printed — no placeholders.
  • exit_code appears only on failure, so a wrapper that lost the process status still has it.

Fields

--json=field,list keeps only those keys of each data row — of a page's rows (task list), of a read's subject (task get keeps them on data.task). Unknown fields fail with exit 2, the known ones, and the same call re-run with the fields that exist — unless the command already wrote: then it succeeds with the fields that exist (all of data when none did) and an unknown_field warning, because re-running it would write twice. <verb> --help --json carries a dataShape example wherever data is not a flat list of rows.

$ vitrinka task list --json=id,title,state
{"v":1,"ok":true,"verb":"task list","data":{"tasks":[{"id":12,"title":"Checkout retries","state":"doing"}],"nextCursor":""},"diagnostics":[],"next":[]}

--jq

--jq '<expression>' runs a jq expression over the whole envelope and prints the result, one value per line; strings print raw.

$ vitrinka task list --json --jq '.data.tasks[] | select(.state=="doing") | .url'
https://vitrinka.acme.internal/w/acme/p/web/t/12

--jq never hides a failure: when the expression finds nothing in a failure envelope, the whole envelope prints instead, with the same non-zero exit. When every result is null, stderr names the real data shape, e.g. data is {nextCursor, tasks[]}: try .data.tasks[].

Streams and protocols keep their own shape: work watch, work listen, qa run (the child's stdio), auth token (the raw token) and the shell completion scripts.

vitrinka help no-input — Non-interactive use

The CLI prompts only when both stdin and stdout are a terminal. Two global flags make the behaviour explicit for scripts and agents, which may well be running on a pseudo-terminal.

FlagMeaning
--no-inputNever prompt. Also VITRINKA_NO_INPUT=1 or any CI value. A step that needs consent stops with exit 5.
--yesAccept the proposed plan wherever a prompt would have asked, on a terminal or not; it never waits for an answer.

--yes accepts what the command proposes; it never invents choices. A step with no sane default (which workspace, which project among several) still exits 5 and names the flag that answers it.

Exit 5, needs_human

The envelope carries the plan the command wanted to apply and the exact rerun that applies it.

$ vitrinka doctor --fix --json --no-input
{ "v": 1, "ok": false, "verb": "doctor", "exit_code": 5,
  "diagnostics": [ { "code": "needs_human",
                     "detail": "2 repairs in this repository need consent",
                     "fix": "review data.plan, then rerun with --yes" } ],
  "data": { "plan": [
    { "target": "vitrinka.config.json", "before": "no project", "after": "web" },
    { "target": "machine ledger", "before": "stale setup", "after": "current setup" } ] },
  "next": [ { "cmd": "vitrinka doctor --fix --yes --json" } ] }

Cancel (Ctrl+C) exits 130 and applies nothing. A skipped optional step is ok: true with a skipped diagnostic, never a failure.

vitrinka help agents — Driving the CLI as an agent

Four rules make every call mechanical: always --json, always --no-input, branch on exit_code then diagnostics[].code, and run next[].cmd verbatim when you want the follow-up.

$ vitrinka task mine --json=id,title,url --no-input

Recovery is in the envelope

  • exit_code 2 means the call itself was wrong; read diagnostics[].fix and correct the command, do not retry it.
  • 4 means sign in: vitrinka auth login needs a human once; after that the keyring or VITRINKA_TOKEN carries it.
  • 5 means consent: hand data.plan to the human and rerun the next[].cmd with --yes when they agree.
  • 1 with not_found, forbidden or conflict is a fact about the workspace, not a transient; do not loop.

Reading less

--json=fields and --jq exist so a list read costs a fraction of the tokens; ask for the keys you will use.

$ vitrinka task list --json --jq '[.data.tasks[] | {id, state}]'

Two doors, one server

The vitrinka MCP server (the deployment's /mcp door, registered by setup with OAuth) exposes the same operations as tools with JSON Schemas; the CLI is the door for shells, hooks and CI. Both validate on the server, so neither can skip a rule the other enforces. Prefer MCP inside an agent harness and the CLI inside scripts; never build URLs by hand, print the url a response returns.

On this page

Command groupsvitrinka admin — Deployment administrationvitrinka admin projectsvitrinka admin projects checkvitrinka admin smtpvitrinka admin smtp setvitrinka admin smtp statusvitrinka admin smtp testvitrinka auth — Credentials, one per deploymentvitrinka auth loginvitrinka auth logoutvitrinka auth statusvitrinka auth tokenvitrinka board — Annotation boardsvitrinka board artifactvitrinka board artifact createvitrinka board artifact initvitrinka board artifact push <file.html>vitrinka board capture <ios|android|macos|web|safari>vitrinka board cardsvitrinka board cards rm <board> <id…>vitrinka board compose <board>vitrinka board createvitrinka board diagramvitrinka board diagram import <file>vitrinka board diagram schemavitrinka board diagram schema pushvitrinka board dump <dir>vitrinka board edit [path]vitrinka board import-chat [file.ndjson]vitrinka board initvitrinka board listvitrinka board metavitrinka board openvitrinka board pullvitrinka board pushvitrinka board rename <project>/<branchSlug>/<selector> [new-name]vitrinka board share <board>vitrinka board upload <files...>vitrinka board view <board>vitrinka config — This machine's vitrinka settingsvitrinka config bind [workspace]vitrinka config default [workspace]vitrinka config hidpi [on|off]vitrinka config operator [name]vitrinka config prefix [path] [workspace]vitrinka config reviewer [self|codex]vitrinka config writes [confirm|auto]vitrinka docs — Look up the deploy's unified reference: element kinds, card kinds, artifact components, guidesvitrinka docs ask <request…>vitrinka fav — Your bookmark tree — star boards, cards, sessions, tasks and projectsvitrinka fav add <kind> <id|slug>vitrinka fav listvitrinka fav rm <kind> <id|slug>vitrinka intake — The intake queue — drafts proposed by sessions, annotations, reports, PRs and Evevitrinka intake accept <id>vitrinka intake decline <id>vitrinka intake listvitrinka intake merge <id>vitrinka intake propose <title>vitrinka me — Todos, agenda, diary, schedules, work time and your project briefvitrinka me agenda [today|tomorrow|<day>|week]vitrinka me agenda add <task>vitrinka me agenda done <item>vitrinka me agenda move <item>vitrinka me agenda rm <item>vitrinka me briefvitrinka me diaryvitrinka me diary promote <card>vitrinka me schedulevitrinka me schedule add <title> --in <dur> | --at <time>vitrinka me schedule end <id>vitrinka me schedule listvitrinka me schedule move <id> --in <dur> | --at <time>vitrinka me schedule ripevitrinka me schedule skip <id>vitrinka me timevitrinka me time capturevitrinka me time disablevitrinka me time enablevitrinka me time hooksvitrinka me time servicevitrinka me time service installvitrinka me time statusvitrinka me todovitrinka me todo add <title>vitrinka me todo backfillvitrinka me todo done <id>vitrinka me todo drop <id>vitrinka me todo listvitrinka me todo milestonevitrinka me todo milestone add <name>vitrinka me todo milestone listvitrinka me todo milestone reach <name|id>vitrinka me todo milestone unreach <name|id>vitrinka me todo show <id>vitrinka outbox — Writes queued while the deployment was unreachable — list, flush, retry, dropvitrinka outbox drop <id>vitrinka outbox flushvitrinka outbox listvitrinka outbox retry <id>vitrinka project — This repository's vitrinka wiringvitrinka project commitsvitrinka project copilotvitrinka project deploy-mark <env> <sha>vitrinka project fieldsvitrinka project fields add <key> <label> --kind <kind>vitrinka project fields listvitrinka project fields remove <key>vitrinka project fields update <key>vitrinka project historyvitrinka project history chapter <id>vitrinka project history chaptersvitrinka project history snapshotvitrinka project indexvitrinka project index configurevitrinka project index statusvitrinka project link [project]vitrinka project merge <from> --into <to>vitrinka project merge-plan --into <project>vitrinka project nowvitrinka project releasevitrinka project tidyvitrinka project transfer [project] --to <workspace>vitrinka project unlinkvitrinka qa — Runs, exploratory sessions, pairing and session archivesvitrinka qa pairvitrinka qa pair logs <stack>vitrinka qa pair relayvitrinka qa pair restart [stack…]vitrinka qa pair run [stack…]vitrinka qa pair statusvitrinka qa pair stop [stack…]vitrinka qa run [flags] -- <test command> [args…]vitrinka qa run publish <manifest.json>vitrinka qa sessionvitrinka qa session archive <transcript.jsonl> --task <id>vitrinka qa session continue <task-id>vitrinka qa session launch <task-url|slug> <dir>vitrinka qa usertestvitrinka qa usertest case <title>vitrinka qa usertest finishvitrinka qa usertest startvitrinka qa usertest statusvitrinka qa usertest verdict <pass|fail|skip>vitrinka review — The review brief and its rules — the rubric a review pass appliesvitrinka review briefvitrinka review file <board> <candidates.json>vitrinka review judge <board|set> | --run <id>vitrinka review judge export <job>vitrinka review lint <shots-dir>vitrinka review plan [board…]vitrinka review rulesvitrinka review rules get <id>vitrinka review rules lint <file>...vitrinka review rules listvitrinka review rules put <file>...vitrinka review statsvitrinka search — Search the workspace: tasks, pages, boards, tags, cards, sessions and shots in one call (annotations by number: №432)vitrinka search query <sql>vitrinka search resolve <url>vitrinka setup — First run: sign in, plugins + MCP, this repo, the index — then modules, skills, extension, uninstallvitrinka setup extensionvitrinka setup extension setupvitrinka setup extension updatevitrinka setup modulesvitrinka setup modules disable <module|plugin>vitrinka setup modules enable <module|plugin>vitrinka setup modules listvitrinka setup skillsvitrinka setup skills hide <skill>vitrinka setup skills show <skill>vitrinka setup uninstallvitrinka sprint — Outcome scopes — optional dates, concurrent starts and reviewed carryvitrinka sprint bindingvitrinka sprint binding get <session>vitrinka sprint binding set <session>vitrinka sprint cockpit <id>vitrinka sprint complete <id>vitrinka sprint create <name>vitrinka sprint listvitrinka sprint members <id>vitrinka sprint releasevitrinka sprint release evidencevitrinka sprint release evidence add <candidate-id>vitrinka sprint release evidence list <candidate-id>vitrinka sprint release get <candidate-id>vitrinka sprint release list <sprint-id>vitrinka sprint release prepare <sprint-id>vitrinka sprint resolvevitrinka sprint start <id>vitrinka sprint status <id>vitrinka sprint update <id>vitrinka tag — The tag vocabulary — the third axis beside project and subgroupvitrinka tag add <board> <tag>...vitrinka tag listvitrinka tag remove <board> <tag>...vitrinka task — The task engine — list, read, file, update, comment, rank, search, ask, delete, start/stop a run, pickup, handback, spotvitrinka task ask [<id>] <question>vitrinka task brief <id>vitrinka task comment <id> <body>vitrinka task create <title>vitrinka task delete <id>vitrinka task fieldvitrinka task field get <id> [key]vitrinka task field set <id> <key> <value|json>vitrinka task final <id>vitrinka task find <ref>vitrinka task get <id>vitrinka task handback [id] [-]vitrinka task label <id>vitrinka task lineage [id] --file <event.json>vitrinka task link <id> <toId>vitrinka task links <id>vitrinka task links add <id> <ref>vitrinka task links rm <id> <link-id>vitrinka task listvitrinka task meeting-notes <id>vitrinka task minevitrinka task organizevitrinka task organize applyvitrinka task organize previewvitrinka task pickup [id|url]vitrinka task qa-board <id>vitrinka task rank <id>vitrinka task resolve-qavitrinka task search <text>vitrinka task spot <title>vitrinka task start [id]vitrinka task stop <run>vitrinka task update <id>vitrinka task upload <id> <files...>vitrinka work — The annotation work queuevitrinka work listvitrinka work listenvitrinka work watchvitrinka workspace — Workspace-wide settingsvitrinka workspace categoryvitrinka workspace category createvitrinka workspace category listvitrinka workspace category update <id>vitrinka workspace commit-prefix [bracket|bare|colon]Top-level commandsvitrinka doctorvitrinka statusvitrinka updateGuidesvitrinka help environment — EnvironmentDeployment and credentialsBehaviour switchesSet by vitrinka for child processesvitrinka help exit-codes — Exit codesvitrinka help json — JSON outputFields--jqvitrinka help no-input — Non-interactive useExit 5, needs_humanvitrinka help agents — Driving the CLI as an agentRecovery is in the envelopeReading lessTwo doors, one server