Skip to content

Command-line reference

This page lists every command the vect binary registers, with its arguments, flags, environment variables, output, and exit codes. It is a lookup page: for how the pieces fit together, see How runs work, Storage, and Stacks. The normative text is the API and CLI spec (the API-CLI-* requirements).

The examples come from docs/site/examples/reference/cli/tour/ in the vect repository: one terraform executor that creates a random_pet and a sensitive random_password. Run IDs, digests, and timestamps in the output will differ from yours.

Run the commands from that folder, with its server.vect as the server configuration. The commands that plan and apply need a Temporal dev server on the localhost:7233 the file names:

export VECT_CONFIG=server.vect

Common options and environment

Commands at a glance

CommandWhat it doesNeeds a server
vect validateCheck a configurationno
vect graphPrint the evaluation orderno
vect inspectPrint evaluated executor inputs as HCLonly with --observe
vect bundleBuild and upload a bundleyes
vect affectedReport what a bundle would affectyes
vect planPlan a runyes
vect applyApply a run or a plan fileyes
vect destroyTear down a workspace or targetsyes
vect approveApprove awaiting requests, or attest a plan fileyes
vect rejectReject awaiting requestsyes
vect runsList runs, or show oneyes
vect logsPrint or tail a run’s logsyes
vect outputPrint root outputsyes
vect inventoryShow Inventory records and pointersyes
vect inventory resolveClear an uncertain nodeyes
vect gcCollect unreachable stored entriesyes
vect serveServe the APIis the server
vect workerRun a Temporal workeris a worker
vect versionPrint the versionno

“Needs a server” means the command calls the API. Without --api-url it starts the same server in-process, built from --config (or the defaults), and stops it when the command ends. That is how a single vect apply works with no vect serve running. The in-process server still needs the Temporal endpoint named by the workspace in the server configuration.

Global flags

Every command accepts -h/--help and --chdir <dir> (or --chdir=<dir>). Running vect with no command prints the command list to standard error and exits 2.

--chdir <dir> makes vect behave as if it were started in <dir>, without changing the directory of your shell. The root stack and the search for a .vectroot file start there, and every relative path resolves from <dir>, not from where you ran the command: --facts, --out, a plan-file argument, --project-root, --global-file, --token-file, --config, the [dir] argument of validate, graph, inspect, and bundle, the path variables in Environment variables such as VECT_CONFIG, and the relative paths in the server configuration, such as server.data_dir. A <dir> that does not exist or is not a directory exits 2. It is spelled only --chdir: a one-dash -chdir is rejected, and no environment variable sets it.

This lets a CI job that runs at the project root pick one of several root stacks that share a .vectroot. This example validates two root stacks from the project root:

vect validate --chdir ws/a
vect validate --chdir ws/b
Success!
  (root)  0 blocks
Success!
  (root)  0 blocks

To plan one of them, name the server configuration relative to the same directory:

vect plan --chdir ws/a --config ../../server.vect

Server flags

Every command that calls the API accepts these. validate, graph, and inspect accept them too, but use them only to read a workspace’s known stack pins (with --workspace) or, for inspect, to --observe.

FlagEnvironmentDefaultMeaning
--api-url <url>VECT_API_URLnone (in-process server)API server to call. A malformed URL exits 2.
--token-file <path>VECT_TOKEN_FILEAWS_WEB_IDENTITY_TOKEN_FILE when --api-url is setFile holding the bearer token. An unreadable file exits 1.
--config <path>VECT_CONFIGbuilt-in defaultsServer configuration file. An invalid file prints every diagnostic and exits 1.

vect serve and vect worker take only --config, and require it.

Precedence is the same everywhere: a flag, then its environment variable, then the default. A flag given as an empty string still counts as given.

Workspace selection

Commands that act on a workspace (plan, apply, destroy, approve, reject, runs, logs, output, inventory, gc, worker, affected) choose it in this order:

  1. --workspace <name>
  2. VECT_WORKSPACE
  3. default_workspace in the server configuration

With none of the three, they print a “needs a workspace” error naming these three and exit 2. When no server configuration was loaded, the error adds that default_workspace is not set and points at --config and VECT_CONFIG. The server configuration is read only from --config or VECT_CONFIG, so a server.vect in the current directory is not picked up on its own.

The offline commands (validate, graph, inspect) read no server configuration, so default_workspace does not apply to them. There --workspace or VECT_WORKSPACE binds vect.workspace and lets the command read known pins of composed stacks; without either, composed stacks stay opaque.

Project root

validate, graph, inspect, bundle, plan, and apply take --project-root <dir> (VECT_PROJECT_ROOT): the directory that holds every stack the root stack uses. Without it the project root is the nearest parent directory (of the root stack) that contains a .vectroot file, else the root stack itself. A root stack outside the project root exits 2. See Stacks.

Fact files and globals

FlagCommandsMeaning
--facts <file>validate, graph, inspect, bundle, plan, apply, affectedInject values from a fact file. Repeatable; later files win. Read through the caller’s filesystem.
--global <name>=<expr>validate, inspect, bundleSupply a declared global’s whole value. Repeatable. <expr> may use literals, constructors, and operators only. A malformed argument, an undeclared name, or a repeated name exits 2.
--global-file <path>validateRead <name> = <expr> attributes from an HCL file, under the same expression rules.

Where a global is given more than once, --global overrides --global-file, which overrides fact files.

Output formats

--format text|json (default text) is accepted by plan, apply, destroy, affected, runs, output, inventory, and gc. Any other value exits 2. With json, the command writes one document to standard output whose top-level format_version names its schema version (currently 1); the JSON is a stable contract and the text is not. Progress, node events, and executor logs go to standard error, so standard output is safe to pipe.

Human-readable output redacts sensitive values; only vect output --show-sensitive can print them, and ephemeral values are never printed.

Two-dash flags

Every long flag takes two dashes, as in --target, --out, --destroy, and --chdir. A one-dash long form such as -target exits 2 and names the two-dash spelling; the only shorthand is -h for --help. (API-CLI-16.)

Exit codes

CodeMeaning
0Success.
1A runtime or configuration failure, including a plan, apply, or destroy run that did not succeed.
2A usage error: unknown command or flag, wrong arguments, a missing workspace, or an invalid flag value.

A failed API call exits 2 for the InvalidArgument code and 1 for every other code (Unauthenticated, PermissionDenied, FailedPrecondition, and so on), after printing the code and message to standard error. Errors are printed as vect: <message>.

vect validate --bogus
vect: unknown flag: --bogus

Usage:
  vect validate [dir] [flags]
…

(The usage text continues with the flag list; the exit code is 2.)

Environment variables

VariableUsed byEquivalent flag
VECT_CONFIGevery command that reads a server configuration--config
VECT_WORKSPACEevery command that selects a workspace--workspace
VECT_API_URLserver commands--api-url
VECT_TOKEN_FILEserver commands--token-file
AWS_WEB_IDENTITY_TOKEN_FILEserver commands, only when --api-url is set and no token file is namednone
VECT_PROJECT_ROOTcommands that load a configuration--project-root
VECT_COMMIT, VECT_LINEAGE, VECT_SOURCE_POSITIONbundle, and the on-demand bundle of plan and apply--commit, --lineage, --source-position (bundle only)
NO_COLOR, TERM=dumbinspect --color autoturn color off

Commands

vect validate

Checks the configuration in a directory: it parses, type-checks, and compiles it offline, without running executors.

vect validate [dir] [flags]
Argument or flagTypeDefaultMeaning
dirpath.The root stack’s directory.
--workspacestringVECT_WORKSPACEBinds vect.workspace; reads known stack pins.
--facts, --global, --global-fileSee Fact files and globals.
--project-rootpathsee Project root
server flagsSee Server flags.

Prints Success! and one line per stack with its block count, exits 0. Diagnostics (errors and warnings, with source snippets) go to standard error; any error exits 1. A required_version the running binary does not satisfy fails before anything else.

vect validate
Success!
  (root)  1 block

vect graph

Prints the evaluation order of the whole configuration, one node address per line. The configuration is one graph across all stack boundaries, so the lines interleave stacks. Disabled nodes are not printed. See The dependency graph.

vect graph [dir] [flags]

Flags: --workspace, --facts, --project-root, and the server flags. It takes no --global flags.

vect graph
terraform.pet
output.name
output.token

vect inspect

Prints evaluated executor inputs as HCL, one node block per node, with depends_on, input, and the other evaluated fields. By default it shows executor blocks only.

vect inspect [dir] [flags]
FlagTypeDefaultMeaning
--allboolfalseShow every node kind, not only executor blocks.
--colorauto, always, neverautoColor the HCL. auto colors only on a terminal, and not with NO_COLOR set or TERM=dumb. Another value exits 2.
--observe <address>string, repeatablenoneRead an executor instance’s deployed outputs from the workspace’s Inventory and use them as observed results. Needs a workspace and a server; an address that is not an executor instance exits 2.
--workspace, --facts, --global, --project-rootAs above.

Fact files given to inspect may also set hypothetical result blocks; other commands reject them. A fact file’s result wins over an observed one for the same address.

vect inspect
node "terraform.pet" {
  depends_on = []
  type = object({
    source = string
  })
  input = {
    source = "./roots/pet"
  }
}

vect bundle

Builds a bundle of the configuration (units, assemblies, and a manifest), uploads it through the API, and registers a publication. A bundle is independent of any workspace: --workspace is refused with exit 2. See Storage.

vect bundle [dir] [flags]
FlagTypeDefaultMeaning
--platform <os>_<arch>string, repeatablethe server’s platformsPlatform to bundle provider and engine binaries for. A value not shaped like linux_amd64 exits 2.
--commitstringVECT_COMMITCommit the bundle was built from.
--lineage<repository>@<branch>VECT_LINEAGEPublication lineage.
--source-positionuint64VECT_SOURCE_POSITIONPosition in the lineage. Needs a lineage; otherwise exit 2.
--global, --facts, --project-rootAs above.
vect bundle
source digest: sha256:ac77b0827a84a7cb6175edd0cf8064bf3a0e51cf0dbc6f5caf270619a73944e1
bundle digest: sha256:d5be5c930fadacbe1205e55d400d76635b1da26e84ad8fce84646e556e27485d
publication: pub_000001

Token and credential files

From vect 0.1.2, vect bundle never reads or packs a token file it knows of that sits inside the project root. The files it knows of are the ones named by --token-file, VECT_TOKEN_FILE, AWS_WEB_IDENTITY_TOKEN_FILE, the server configuration’s top-level client_auth token file, and each external_workspace’s client_auth token file. Vect matches by path and by file identity, so a symlink to one is caught too. A reference to such a file from your configuration, such as a file() call in a Terraform root, is an error from vect bundle. To trigger it, put token = file("${path.module}/../../ci.token") in a locals block of roots/app/main.tf, create ci.token in the project root, and run vect bundle --token-file ci.token. vect validate does not evaluate it and prints Success!:

Error: Credential file referenced

  on roots/app/main.tf line 2, in locals:
   2:   token = file("${path.module}/../../ci.token")

"ci.token" is a token file vect authenticates with; it is never bundled. Keep it outside the project
root.

Both vect bundle and vect validate also warn, without failing, about each file in the project whose name looks like a credential (.vect-token*, *.token, .env, credentials, *.pem, *.key) and that .vectignore does not exclude. To trigger it, create a ci.token file in the project and run vect validate:

Warning: Credential-looking file in the project

"ci.token" looks like a credential and will be packed into bundles. Add "/ci.token" to .vectignore,
or keep it outside the project root.

Excluded files are dropped silently. To confirm one was left out, change its contents and bundle again with --token-file set: the source digest does not change. (The last line removes the file again, so later commands do not warn about it.)

echo fake > ci.token
vect bundle --token-file ci.token
echo changed > ci.token
vect bundle --token-file ci.token
rm ci.token
source digest: sha256:ac77b0827a84a7cb6175edd0cf8064bf3a0e51cf0dbc6f5caf270619a73944e1
bundle digest: sha256:d5be5c930fadacbe1205e55d400d76635b1da26e84ad8fce84646e556e27485d
publication: pub_000002
source digest: sha256:ac77b0827a84a7cb6175edd0cf8064bf3a0e51cf0dbc6f5caf270619a73944e1
bundle digest: sha256:d5be5c930fadacbe1205e55d400d76635b1da26e84ad8fce84646e556e27485d
publication: pub_000003

The safest place for a token file is outside the project folder. See Spec: BNDL-UNIT-13.

vect affected

Reports, read-only, which workspaces and loops a published bundle would affect, and which nodes directly or potentially.

vect affected --bundle <digest> [flags]
FlagTypeDefaultMeaning
--bundlesha256:<hex>requiredThe published bundle to analyze. Missing or malformed exits 2.
--workspacestring, repeatableVECT_WORKSPACE, then default_workspaceWorkspaces to analyze.
--runner <url>stringnoneAnalyze every loop the runner at this URL hosts. Also sets --api-url.
--factsfile, repeatablenoneFact files, as for a run.
--formattext, jsontextJSON is the response message with its protobuf field names.
--spec-patch <file>stringnoneAccepted but not yet supported: exits 2 with “not yet supported”.

With neither a workspace nor --runner, it exits 2.

vect plan

Plans a run in a workspace: every node’s action and reason, with nothing changed. The configuration in the current directory is bundled on demand unless --bundle names a published one. See How runs work.

vect plan [flags]

It takes no positional arguments.

FlagTypeDefaultMeaning
--workspacestringsee Workspace selectionWorkspace to run in.
--out <path>pathnoneWrite a plan file here when the plan succeeds (mode 0600).
--bundle <digest>sha256:<hex>noneRun this published bundle instead of the checkout. Malformed exits 2.
--publication <id>stringnonePublication of the bundle. Needs --bundle.
--target <address>string, repeatablenone (full run)Limit the run to a stack, an executor instance, or an <instance>::<internal> address.
--upstreaminventory, includeinventoryFor a targeted run, whether out-of-scope upstream nodes are read from Inventory or run. Needs at least one --target.
--metadata <key=value>string, repeatablenoneMetadata attached to the run, its plan file, and its deployment pointer. A malformed pair exits 2.
--destroyboolfalsePlan a teardown of every committed Inventory record (or the targets), without reading local files.
--force-revisionboolfalseWith --destroy: destroy a record whose recorded revision differs from its type’s. Without --destroy, exit 2.
--allow-root-changeboolfalseAdmit a run whose root stack differs from the workspace’s current bundle’s.
--formattext, jsontext
--facts, --project-rootAs above.
server flags

Node events and executor output stream to standard error as the run proceeds. The summary goes to standard output; the command exits 1 unless the run succeeded. Ctrl-C (or SIGTERM) during an in-process run cancels the run and waits up to 30 seconds for it to end. The examples below leave out those standard-error lines.

vect plan --out tour.plan
plan of workspace "dev": succeeded (run 01a1e7da-816a-7075-94a3-3176fefae042)
  terraform.pet  run  will run
plan file sha256:9a472c000859c4e8321d4139ae2ba736f242d1b711767200c48c2006d2b2c5b8 written to tour.plan

With --format json the document has these top-level fields: format_version, run_id, workspace, kind, state, vect_version, bundle_digest, source_digest, facts_digest, plan_file, deployment_sequence, targets, upstream, message, warnings, metadata, nodes (each with address, status, action, reason, version), approvals, failed, skipped, and canceled. It holds statuses, digests, and reasons, never a value.

vect apply

Applies a run. With a plan file, it applies that file’s plan; without one, it plans and applies the checkout (or --bundle).

vect apply [plan-file] [flags]

apply accepts every flag of vect plan except --out, plus:

FlagTypeDefaultMeaning
--auto-approveboolfalseApprove every approval request that nothing else decided.
--plan-approvalsboolthe workspace’s plan_approvalsHonor approvals attested into the plan file. --plan-approvals=false ignores them.
--approval-timeoutdurationthe workspace’s approval_timeoutHow long each request waits before counting as rejected. Must be positive, else exit 2.

A plan file records its own bundle, facts, and scope, so --target and --upstream cannot be combined with one (exit 2).

At a terminal, each approval request is put to you as approve <kind> of <target>? [y/N]; a blank answer rejects. Without a terminal the outcome depends on where the run executes. A CLI-direct run (no --api-url) applies the workspace’s unattended_approvals policy, which defaults to reject: the request is rejected and the command exits 1 (for example vect destroy with no terminal fails with “approval rejected by unattended”), unless --auto-approve is given or the policy is approve. A run on a served runner (--api-url) waits for the request, and the command prints how to answer it with vect approve --run. See Approvals. The summary names each node’s outcome and, last, the deployment pointer the run appended. As for plan, the example leaves out the standard-error lines.

vect apply tour.plan
apply of workspace "dev": succeeded (run 01a1e7da-8a22-7883-9027-02bc37c64c02)
  terraform.pet  applied (run)  will run (replanned: saved_plans is replan)
deployment pointer 1 appended

vect destroy

Tears down every committed Inventory record in a workspace, or only the targets. It is vect apply --destroy with a smaller flag set, and never reads or uploads local files.

vect destroy [flags]
FlagTypeDefaultMeaning
--workspacestringsee Workspace selectionWorkspace to tear down.
--target <address>string, repeatablenoneTear down only this stack or executor instance.
--bundle, --publicationnoneBundle (and publication) to record on the run.
--metadata <key=value>string, repeatablenoneAttached to the run.
--auto-approveboolfalseApprove every destroy of this run.
--approval-timeoutdurationthe workspace’s approval_timeoutAs for apply.
--force-revisionboolfalseDestroy a record whose recorded revision differs from its type’s.
--formattext, jsontextSame document as plan and apply.
server flags

The text summary of a destroy is headed destroy of workspace "<name>": ..., and --format json and vect runs give its kind as destroy. With no terminal it is subject to the same unattended-approval rules as vect apply.

vect approve

Answers approval requests, or attests a plan file’s requests ahead of an apply.

vect approve <plan-file> | --run <run-id> [request-id...] [flags]
Argument or flagMeaning
<plan-file>Without --run, attests every approval request in the plan file. Exactly one file is required, else exit 2.
--run <run-id>Run whose awaiting requests to answer.
request-id...Requests to approve. With none, vect approve --run lists the awaiting requests and changes nothing.
--workspaceWorkspace of the run or plan file.

Output is a table of request ID, kind, target, and summary, or a count (approved 1 approval request).

Known issue: answering or listing requests of a run (--run) queries the run’s workflow, which needs a worker polling its task queue (vect serve or vect worker). Without one, and for a finished run, the command can exit 1 with internal: query run <id>: context deadline exceeded. Tracked in issue #92.

vect reject

Rejects a run’s awaiting requests, or lists them.

vect reject --run <run-id> [request-id...] [flags]

Same flags as vect approve; --run is required (exit 2 without it) and there is no plan-file form.

vect runs

Lists the workspace’s runs, newest first, or shows one run’s node statuses and reasons, approval decisions, and metadata.

vect runs [<run-id>] [flags]

Flags: --workspace, --format text|json (default text), and the server flags. The list document is {format_version, workspace, runs[]}; the single-run document is the plan/apply document plus started_at and finished_at.

vect runs
RUN                                   KIND   STATE      SCOPE  STARTED               FINISHED              METADATA
01a1e7da-8a22-7883-9027-02bc37c64c02  apply  succeeded  full   2026-11-17T04:53:41Z  2026-11-17T04:53:42Z  -
01a1e7da-816a-7075-94a3-3176fefae042  plan   succeeded  full   2026-11-17T04:53:39Z  2026-11-17T04:53:41Z  -

vect logs

Prints a run’s stored logs to standard output, one line per log line, each prefixed <node> [<phase> #<attempt>] |.

vect logs --run <run-id> [--node <address>] [--follow] [flags]
FlagTypeDefaultMeaning
--run <run-id>stringrequiredRun whose logs to print. Missing exits 2.
--node <address>stringall nodesOnly this node’s canonical address.
--followboolfalseAfter the stored lines, tail a running run until it ends.
--workspacestring
server flags

vect output

Prints the root outputs of the workspace’s latest applied deployment.

vect output [name] [flags]
FlagTypeDefaultMeaning
namestringall outputsOne output. An unknown name exits 1 and lists the names that exist.
--show-sensitiveboolfalsePrint sensitive values. Needs the workspace.read_sensitive_outputs permission; without it the values stay redacted and the command says so on standard error.
--formattext, jsontext
--workspacestring
vect output
name = "direct-foxhound"
token = redacted(string)
vect output name --format json
{
  "format_version": 1,
  "workspace": "dev",
  "outputs": {
    "name": {
      "value": "mighty-pup",
      "sensitive": false
    }
  },
  "bundle_digest": "sha256:2ebe762498775c304590e7676fb59c971567bc59c59bb66045b16c15fc1af2dc",
  "applied_at": "2026-11-15T20:12:57.99016Z"
}

vect inventory

Shows the workspace’s Inventory: with no argument, one row per record and the deployment pointers; with an executor instance address, that record’s versions.

vect inventory [address] [flags]

Flags: --workspace, --format text|json (default text), and the server flags. Each record has one status: in_flight, uncertain, recovery_required, stale, destroyed, converged, or none. No values are shown.

vect inventory
ADDRESS        VERSION  STATUS
terraform.pet  1        converged

POINTER  BUNDLE                                                                   SCOPE  APPLIED               METADATA
1        sha256:d5be5c930fadacbe1205e55d400d76635b1da26e84ad8fce84646e556e27485d  full   2026-11-17T04:53:42Z

vect inventory resolve

Clears the uncertain state of a node, attesting that its old operation has stopped, so the next run plans it again.

vect inventory resolve <address> [flags]
FlagTypeDefaultMeaning
--force-unlock <lock-id>stringnoneAlso release the node’s backend state lock with this ID, before clearing the mark.
--workspacestringWorkspace of the node.

The server flags also apply; there is no --format. Prints resolved <address> as <operator>: the next run plans it again, or <address> is not uncertain; nothing to resolve, and exits 0 for both.

--force-unlock is for a terraform node whose last attempt left its backend state lock behind and could not show that its engine stopped, for example because its worker was lost. A run forces a stale lock by itself only when the previous attempt’s recorded exit matches the lock. When it doesn’t, the node fails with state lock <id> was not forced: <reason>; if its operation has stopped, run: vect inventory resolve <address> --force-unlock <id>. That ID is the one to pass. Check that the lock is the stopped operation’s before you force it: vect takes your word for it.

With --force-unlock, vect takes the node’s lease, runs force-unlock -force <lock-id> against the node’s recorded backend, then clears the uncertain mark. It prints released state lock <lock-id> of <address> before the resolved line. It refuses, and exits 1 with the message on standard error, when:

  • the node is not uncertain (without the flag, that case is the nothing to resolve line above);
  • a run holds the node’s lease (try again once it is done);
  • there is no record for that address (not_found);
  • the node has no committed version, so no backend is recorded;
  • the engine rejects the lock ID.

Spec: FLEET-CONC-14, EXEC-IDEM-4.

vect gc

Reports unreachable entries in the workspace’s content-addressed store and value store, and the Inventory history retention would prune. By default it is a dry run.

vect gc [flags]
FlagTypeDefaultMeaning
--applyboolfalseDelete what is reported. Without it nothing is deleted.
--retire-workspace <name>stringnoneRemove this workspace’s root manifests instead of collecting. A dry run unless --apply is also given.
--abandonboolfalseWith --retire-workspace: retire it although its stores still hold entries. Without --retire-workspace, exit 2.
--workspacestringWorkspace whose stores are collected.
--formattext, jsontext
vect gc
dry run for workspace dev: nothing is deleted without --apply
retention: would delete 0 versions, 0 records, 0 deployment pointers
STORE  KIND  ID  SIZE  AGE
would delete 0 entries, 0 bytes

vect serve

Serves the API over gRPC, gRPC-Web, and Connect until interrupted. It starts a worker on each served workspace’s default task queue and a loop for each loop block in the configuration.

vect serve --config <file>

--config (or VECT_CONFIG) is required, else exit 2, and the file must contain a server block, else exit 1. The server block must also set listen; without it vect serve exits 1 with “server.listen is not set” (the example server.vect files in these docs are for CLI-direct use and omit it). A served API also needs authentication configured (a bearer-token authenticator), described in the server configuration reference. An invalid file prints its diagnostics and exits 1 before anything listens. When it is listening it prints vect: serving on <address> to standard output; SIGINT or SIGTERM stops it and exits 0.

vect worker

Runs a Temporal worker for one capability’s task queue, hosting the executor and data source activities of the nodes routed to it. It hosts no run workflow.

vect worker --capability <name> [flags]
FlagTypeDefaultMeaning
--configpathVECT_CONFIG, requiredServer configuration file.
--workspacestringVECT_WORKSPACE, then default_workspaceWorkspace whose capability queue to serve.
--capabilitystringrequiredA capability named in the workspace’s execution block.

Missing configuration, workspace, or capability, an unknown workspace, or a capability the workspace does not declare exits 2. A Temporal connection failure exits 1. It prints vect: worker for capability "<name>" polling task queue "<queue>" and runs until interrupted.

vect version

Prints the version and exits 0. It takes no flags. The version goes up by one patch release for each change that lands, so yours is probably newer than the one below.

vect version
vect 0.1.20