Skip to content
GitHubBook a demo

Reference

CLI reference

0 CLI commands, arguments, options, aliases, and registered defaults.

Pick your task below, or search for a command name.

New to 0? Read the Quickstart first. Settings and environment variables are on Configuration.

Task Commands Guide
Scan code scan Findings
Review findings and threads findings · findings update · threads Findings, Threads
Automate sentinels · api Sentinels
Set up and extend config · config doctor · models · models connect · skills · computers Models, Extensions, Computers

0 with no arguments opens the web console. Everything else is one of ten commands.

Command What it does Subcommands
0 scan Scan a folder or git repository for security bugs; prints the findings as a report. none
0 probe Send adversarial messages to a live model or agent endpoint and report the ones it obeys. none
0 sbom Generate an SBOM from lockfiles, and check one against known advisories. generate, check
0 findings Browse findings and change their status. --format exports, --import loads a report. list, show, update, import, fix
0 threads Start, follow and stop threads. list, show, send, start, stop
0 sentinels Create, run and change Sentinels. list, run, set
0 skills Skills and extensions: list, add. list, add
0 models Models and provider connections. list, set, connect
0 computers Remote computers that run 0. list, add (alias deploy), stop
0 config Settings, API keys, team setup and config doctor. get, set, doctor

Run commands as 0 <command>. Check your release with 0 --version and command-specific --help.

The browser app’s chat uses the same words as slash commands: /threads list, /findings list, /models default and /config get mirror 0 threads list, 0 findings list, 0 models set and 0 config get. See Slash commands.

Option tables show registration defaults. — means no default is registered: a handler may resolve configuration or require an explicit value. Inverse --no-* options show the underlying positive boolean default. See Configuration for environment and runtime resolution.

  • With no arguments, 0 opens the browser app. No account is needed. See Browser app.
  • 0 -p "<prompt>" runs one headless chat prompt. 0 -c continues the last chat and 0 --resume <id> a saved one.
  • 0 --help lists the 8 top-level commands.
  • Use explicit commands in automation. Recognizable bare targets are routed automatically; ambiguous input is refused.
  • Provider authentication, target authentication, filesystem access, and execution isolation have independent controls.
  • The operator-global SmolVM profile runs the entire CLI inside an online Kali guest, preserving original arguments and terminal streams. workbench and config remain host management commands. No Colima/Docker daemon is needed at runtime; failures never choose host execution implicitly.

These forms run the implementation commands documented in the sections below.

Change a finding’s status. --status accepted runs findings accept, suppressed runs findings suppress, open runs findings reopen and false-positive suppresses the finding and records --reason as its note.

0 findings update [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--status <status> — accepted | suppressed | open | false-positive
--note <text> — Why (optional)
--reason <text> — Why; required with false-positive
--db-path <path> — Path to SQLite database

Show or choose the default model. It takes the arguments of models default.

0 models set [options] [model]
Argument Required Description
model No
Option Registered default Description
--provider <provider> — Provider of the model

Add a provider connection (0 models connect <provider>), or --list, --test and --remove one. These run models connections add|list|test|remove.

0 models connect [options] [provider]
Argument Required Description
provider No
Option Registered default Description
--key-env <VAR> — Add: read the API key from this environment variable
--stdin — Add: read the API key from stdin
--list — List connections (the default with no provider)
--test — Test a connection
--remove — Remove a connection (with —yes)

Check this machine and the engine. config doctor upgrade, config doctor workbench and config doctor checks reach the subcommands of doctor; --fix repairs the local database.

0 config doctor [options] [checks...]
Argument Required Description
checks No
Option Registered default Description
--fix — Repair the local database
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Scan a folder or git repository for security bugs and print the findings as a report.

0 scan [options] <target>

--diff <ref> reviews a change instead of the whole folder: only the files that differ from the ref (committed or not) and the code they connect to, for example 0 scan . --diff origin/main --format sarif -o scan.sarif in a pull request job. The folder must be a git work tree. An empty diff starts no thread and writes an empty report.

With FoxGuard installed (it ships next to 0; ZERO_FOXGUARD_PATH points elsewhere), the scan first runs it on the folder, which takes seconds and costs nothing, and gives its hits to the thread as leads: the thread checks each one against the code, records only the real ones and says which it rejected. A pattern scanner flags some safe code and cannot see logic bugs such as a missing ownership check, so the thread still reviews the entry points itself. --prepass off skips it. --scanner adds or replaces scanners (foxguard, semgrep, opengrep; repeat the flag for several); a scanner that is not installed is skipped. A Semgrep rule pack such as p/default is downloaded when it runs.

A scan is a thread that follows the scan skill, so it appears in 0 threads and in the web app. The findings are stored under the thread’s id and exported from there, so 0 findings export --scan <thread id> gives the same report later. target is a folder or a git URL. It uses the console that is running, or the engine named by --engine-url or --computer; with none running it starts a headless console for the scan and stops it afterwards. Exit codes: 0 done, 1 a finding at or above --fail-on or the scan failed, 2 usage error, 3 stopped at the budget or the time limit (the report is partial).

Argument Required Description
target Yes
Option Registered default Description
--budget <usd> 5 Stop when the estimated spend reaches this many USD; partial findings are kept
--format <format> md Report format: json, md, sarif, html, pdf
-o, --output <file> — Write the report to a file instead of stdout
--fail-on <severity> — Exit 1 when a finding is at or above this severity (critical, high, medium, low, info)
--passes <n> 1 Scan this many times and merge the findings (a scan misses some issues that another run finds); the budget is split between them, up to 5
--diff <ref> — Review only the files that differ from this git ref (for example origin/main), and what they connect to; an empty diff scans nothing
--prepass <mode> auto auto runs the pattern scanners first when they are installed and gives their hits to the scan as leads; off skips them
--scanner <id> — Pattern scanner for the pre-pass (foxguard, semgrep, opengrep); repeat to use several (default: foxguard)
--skill <id> scan Skill that holds the scan method
--model <model> — Model for the scan thread (default: gpt-6-luna)
--timeout <seconds> 3600 Maximum seconds to wait for the scan
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to

Open the local browser workspace for threads and findings.

0 web [options]
Option Registered default Description
--db-path <path> — Path to SQLite database
--port <port> 48123 Port to bind; 0 chooses a free loopback port
--host <host> 127.0.0.1 Loopback host to bind (127.0.0.0/8 or ::1)
--asset-dir <path> — Path to the built web app
--dev-url <url> — Loopback Vite server for authenticated frontend hot reload
--team-config <path> — Enable workspace accounts, roles, and shared conversation controls
--engine-token-env <name> — Environment variable holding the engine bearer credential (32–4096 characters)
--engine-workspace <path> — Engine-owned authorized workspace for persistent workflow calls
--engine-allow-apply — Admit explicitly approved patch application in persistent workflow calls
--engine-time-cap <ms> — Server workflow deadline ceiling (default 600000 ms)
--engine-cost-cap <usd> — Server workflow estimated cost ceiling (default $5)
--server-mode — Serve the console to a network behind a TLS proxy: requires sign-in, an allowed-host list and a single node (off by default)
--allowed-host <host...> — Server mode: accepted Host header names (default: only the bind host); also ZERO_ALLOWED_HOSTS
--trusted-proxy <cidr...> — Server mode: proxy addresses or CIDRs whose X-Forwarded-* headers are trusted; also ZERO_TRUSTED_PROXY
--public-url <url> — Server mode: the public https URL of this console (sign-in cookies, single sign-on); also ZERO_PUBLIC_URL
--access-token-env <name> — Server mode: environment variable holding the access token (32+ characters); default ZERO_ACCESS_TOKEN, else one is generated
--shutdown-timeout <seconds> — Server mode: seconds to finish in-flight requests on SIGTERM (default 20)
--ready-json — Emit the bound console URL as machine-readable JSON
--no-open — Do not auto-open a browser
--headless — Serve the API only: no browser, and no web app files needed (use with 0 threads)
--engines-config <path> — Trusted engine connection registry JSON (default ~/.0/engines.json)

Call an admitted HTTP API on a running engine without sending a model prompt.

0 api [options] [path]

Select either --engine <id> from an operator-managed registry, or both --engine-url <url> and --engine-token-env <name> for direct attachment. The optional path defaults to /api/backend/handshake; it must be an admitted /api/ route. The client checks the selected engine’s identity and advertised capabilities before dispatch. Missing credentials, unsupported routes, redirects, and capability mismatches fail without falling back to local execution.

The default method is GET. Use an explicit write method and --data for a mutation; JSON input can be inline or @file, with regular files and serialized bodies limited to 1 MB. GET and HEAD reject request bodies. Pass the name of an environment variable for the bearer credential, never the credential as an argument. Existing server authentication and approval checks still apply.

Responses are JSON envelopes with ok, HTTP status, and data; text exports appear as strings. Errors produce a nonzero exit and a JSON diagnostic on stderr. Successful HTTP submission does not mean queued work has finished: retain the returned resource ID, inspect its status, and cancel explicitly when needed. This command is not a binary-download or event-stream client. Browser appearance and interactive OAuth consent remain browser operations.

Argument Required Description
path No Admitted /api/ route; defaults to /api/backend/handshake.
Option Registered default Description
--method <method> GET GET, POST, PATCH, PUT, DELETE or HEAD. Mutations require an explicit method and remain subject to engine authorization and approvals.
--data <json-or-@file> — JSON body, or @regular-file containing JSON (at most 1 MB)
--engine-url <url> — Attach directly to a trusted HTTP engine; requires —engine-token-env and cannot be combined with registered-engine options.
--engine-token-env <name> — Name of the environment variable holding the engine bearer credential, not the credential itself. Required with —engine-url.
--engine <id> — Select an operator-registered HTTP engine; cannot be combined with —engine-url.
--engines-config <path> — Operator engine registry JSON file

Import retained CI artifacts into a chosen local browser workspace without starting an assessment.

0 findings reports

Subcommands: import · export.

Read a JSON report and optional run.json, validate them, and retain a passive snapshot in the explicitly selected database. Stop the engine using that database before importing, then open 0 web --db-path <same-path>. The same report and metadata import only once. Imported findings remain discovered and unverified by this engine; importing does not restore execution state or authorize fixes.

0 findings reports import [options] <report>
Argument Required Description
report Yes JSON report produced by 0; importing executes no report commands
Option Registered default Description
--metadata <path> — Optional run.json invocation and revision metadata
--db-path <path> required — Destination engine database; stop its browser engine before importing

Write a share-safe copy of a JSON report. The copy is built from an allowlist: it keeps the target, summary and, for each finding, the id, title, severity, category, status, fingerprint, CVSS, confidence and source location. It drops evidence, PoC steps, agent transcripts, triage notes, suggested code and local absolute paths, and it removes credentials, query strings and fragments from URL targets. Free-text descriptions are left out unless you pass --include-description. The command only writes the copy; it sends nothing anywhere.

0 findings reports export [options] <report>
Argument Required Description
report Yes JSON report produced by 0
Option Registered default Description
--include-description — Include each finding’s free-text description (can quote code or secrets)
--output <path> — Write the share-safe report to a file instead of stdout

Check local runtime prerequisites and suggest the next command

0 doctor [options]
Option Registered default Description
--discard-reports — Delete crash reports waiting for review on this computer
--json — Print JSON

Subcommands: upgrade · workbench.

Inspect, export, and import the two-level console configuration

0 config

Subcommands: get · set · doctor · show · list · reset · export · import · audit-log · team · db · github.

Show each setting’s effective value and source: default, global, or project.

0 config show [options]
Option Registered default Description
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Same as config show. Add --json for each key’s value and source layer.

0 config list [options]
Option Registered default Description
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Print one setting’s effective value. --json adds the layer it comes from.

0 config get [options] [key]
Argument Required Description
key No
Option Registered default Description
--json — Print JSON with the source layer
--format <format> — Output: text or json Choices: text, json.

Change one setting, with the same validation as the Settings page. It writes the global layer unless --project is given; operator-global settings refuse --project. Security-sensitive settings need --yes. Exit code 2 means a bad key or value; 1 means the engine refused the change.

0 config set [options] <key> <value>
Terminal window
0 config set compactionThreshold 85%
0 config set allowModelSelfExtension on --yes
Argument Required Description
key Yes
value Yes
Option Registered default Description
--project — Write the override for this folder
--yes — Confirm a security-sensitive setting
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Reset named settings, or every engine setting when none is named, to their defaults. Safety settings never reset to a looser value; the command lists any it kept. Requires --yes.

0 config reset [options] [keys...]
Argument Required Description
keys No
Option Registered default Description
--yes — Confirm the reset
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Export effective configuration as JSON. Use --global for the global layer. Output goes to stdout unless a file is supplied.

0 config export [options] [file]
Argument Required Description
file No
Option Registered default Description
--global — Export only the global layer instead of the effective config

Merge a shared config into the global (default) or —project layer

0 config import [options] <file>
Argument Required Description
file Yes
Option Registered default Description
--project — Import into the override for this folder instead of the global config
--global — Import into the global config (default)
--yes — Accept changes to security-sensitive settings (required to flip them)

Manage model provider connections, the same actions as Settings → Connections in the browser. These commands use a running 0 web engine when there is one, and otherwise apply the change directly on this computer. Keys are never passed as an argument: use --key-env or --stdin.

0 models connections
Terminal window
export OPENAI_API_KEY_FOR_0="sk-..."
0 models connections add openai --key-env OPENAI_API_KEY_FOR_0
0 models connections list
0 models connections test openai
0 models connections remove openai --yes

Subcommands: list · add · test · remove.

List providers with their status and saved accounts. * marks the active account.

0 models connections list [options]
Option Registered default Description
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Verify and save an API key for a provider. Exit code 2 means no key source was given; 1 means the provider rejected it.

0 models connections add [options] <provider>
Argument Required Description
provider Yes
Option Registered default Description
--key-env <VAR> — Read the API key from this environment variable
--stdin — Read the API key from stdin
--account-id <id> — Name this saved account
--base-url <url> — Custom API endpoint
--model <model> — Deployment model, where required
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Check that a connected provider answers and lists models.

0 models connections test [options] <provider>
Argument Required Description
provider Yes
Option Registered default Description
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Remove a provider’s saved credentials, or one saved account with --account. Requires --yes. A key supplied by an environment variable cannot be removed here.

0 models connections remove [options] <provider>
Argument Required Description
provider Yes
Option Registered default Description
--account <id> — Remove only this saved account
--yes — Confirm the removal
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

List the models your connected providers offer and choose the default, as on the Models page.

0 models
Terminal window
0 models list --provider openai
0 models default --provider openai gpt-5.4-mini
0 models recommended

Subcommands: list · set · connect · default · recommended · connections · usage.

List models offered by connected providers, with price and context size.

0 models list [options]
Option Registered default Description
--provider <id> — Only this provider
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Show the default model, or set it. Setting requires --provider, and the provider must be connected.

0 models default [options] [model]
Argument Required Description
model No
Option Registered default Description
--provider <id> — Provider that serves the model
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Show the recommended model for each role, chosen from your connected providers.

0 models recommended [options]
Option Registered default Description
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Check or connect the GitHub account used to publish fixes, as in Settings → Git.

0 config github
Terminal window
0 config github status
0 config github connect --stdin < token.txt
0 config github repos --search api

Subcommands: status · connect · repos.

Show whether GitHub is signed in and which scopes are missing.

0 config github status [options]
Option Registered default Description
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Sign in with a personal access token read from an environment variable or stdin. The token is never printed.

0 config github connect [options]
Option Registered default Description
--key-env <VAR> — Read the token from this environment variable
--stdin — Read the token from stdin
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

List repositories the signed-in account can reach (cached for five minutes).

0 config github repos [options]
Option Registered default Description
--search <text> — Only names containing this text
--refresh — Bypass the five-minute cache
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Show spend and tokens of the open threads, by model or by thread. Open threads are only tracked by a running 0 web engine; without one the report is empty.

0 models usage [options]
Terminal window
0 models usage --by thread --json
Option Registered default Description
--by <model|thread> — Group by model (default) or list each thread
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Show the local log of privileged actions: connection and settings changes, extension installs and denied attempts. The log is append-only.

0 config audit-log [options]
Terminal window
0 config audit-log --q connection --limit 20
Option Registered default Description
--q <text> — Only events whose action, subject or actor contains this text
--limit <n> — Maximum events to show
--before <id> — Only events older than this id (pagination)
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Set up and inspect the online SmolVM security workbench on Apple Silicon macOS. The local Linux guest contains 0, the security tools and the browser; Docker is not required to run the workbench.

0 doctor workbench

Subcommands: run-agent · console-agent · setup · status · providers · configure · disable.

Internal, hidden entrypoint for the host-controlled CLI engine inside an admitted Linux SmolVM workbench. It exchanges framed controller messages over standard input/output; it is not an interactive command or a host-side launch shortcut. Normal CLI commands select this entrypoint automatically when the workbench profile is enabled. Direct invocation outside an admitted guest is refused.

0 doctor workbench run-agent

Internal, hidden entrypoint for the host-controlled chat engine inside an admitted Linux SmolVM workbench. The host owns the terminal/browser UI and forwards requests, events and approvals over the framed controller transport. Use 0 -p or 0 to start a chat; do not invoke this transport endpoint manually. Direct invocation outside an admitted guest is refused.

0 doctor workbench console-agent

Verify/provision the signed native runtime, approve a local archive by digest, and persist the operator-global SmolVM profile.

0 doctor workbench setup [options]
Option Registered default Description
--image <archive> — Local OCI/Docker archive to digest-pin and approve; never a mutable registry tag
--state <directory> — Private VM state directory (defaults to ~/.0/workbench)
--workspace <directory> — Explicit workspace mount; otherwise each invocation mounts its current directory
--provider <id> — Grant chatgpt-codex requests through the host provider broker; credentials stay on the host
--github — Unsupported: GitHub credential forwarding is refused
--no-github — Revoke the GitHub token grant
--cpus <count> — Guest virtual CPUs
--memory <MiB> — Guest RAM in MiB
--storage <GiB> — Guest private writable storage in GiB
--sandbox-image <reference=archive> — Approve an immutable image reference for brokered isolated container actions; repeat for multiple images

The supported provider grant is chatgpt-codex: model requests go through the host broker, and credentials stay on the host. GitHub credential forwarding is refused. The host HOME, SSH configuration and Docker socket are not mounted into the guest.

Read configuration, native runtime readiness, image approval, effective privacy, network mode, broker resource ceilings and retained guest admission. Does not download or launch a VM or reveal credential values.

0 doctor workbench status [options]
Option Registered default Description
--json — Print machine-readable status (no credential values)

List the exact identifiers accepted by --provider; this does not expose credentials.

0 doctor workbench providers

Replace integration grants or operator-approved sibling image references.

0 doctor workbench configure [options]
Option Registered default Description
--provider <ids> — Replace provider grants with comma-separated IDs, or none
--github — Enable the explicit GitHub credential grant
--no-github — Revoke the GitHub credential grant
--current-workspace — Mount each invocation’s current directory instead of a fixed saved workspace
--sandbox-image <reference=archive> — Add or replace an operator-approved immutable sandbox image reference; repeat for multiple images
--clear-sandbox-images — Revoke all explicit sandbox image-reference grants

Explicitly switch to host-local execution. Approved image and guest state remain.

0 doctor workbench disable

Fetch and install the latest release binary for 0 (re-runs install.sh).

0 doctor upgrade [options]
Option Registered default Description
--version <tag> — Pin a specific release tag (e.g. v0.10.0)
--install-dir <path> — Override the install directory (default: the folder of this binary, else ~/.0/bin)

Send adversarial messages to a live model or agent endpoint and report the ones it obeys

0 probe [options] <url>

Sends ten attacks to the URL you name and reports the ones whose reply shows they worked: a user message that overrides the instructions, fake system markup, instructions hidden in a document or in base64, a role-play jailbreak, reading out the system prompt, asking for credentials, asking for a command to be run, markdown that leaks data when rendered, and raw HTML in the reply. Each attack carries a unique canary, so a hit is a check on the reply (the canary came back, a credential appeared, uid= came back from a command) and not another model’s opinion. Models vary, so each probe is sent twice by default and one hit counts.

The request is an OpenAI-style chat body unless you give --body with {{prompt}} where the message goes, and the reply is found automatically in common JSON shapes or at --response-path. Put a key in a header as an environment variable (-H "Authorization: Bearer $OPENAI_API_KEY") so it is not typed on the command line. Give --secret a secret you know is in the endpoint’s prompt and a reply that contains it is reported as a definite leak. Requests are 300 ms apart and capped at 100 by default. The findings go into the usual reports (--format md|json|sarif|html|pdf) and, with --save, into 0 findings list.

On a real model behind a deliberately weak prompt, three of the ten got through; behind a hardened prompt none did. A miss means the reply did not show the attack working in those attempts; it does not prove the endpoint is safe against attacks that are not in the list.

Argument Required Description
url Yes
Option Registered default Description
-H, --header <header> — Request header, Name: value; the value may be $ENV_VAR so a key is not typed on the command line (repeatable)
--body <json> — Request body as JSON with {{prompt}} where the message goes (default: an OpenAI-style chat body)
--body-file <file> — Read the request body from a file
--model <name> — Add this model name to the default chat body
--response-path <path> — Where the reply is in a JSON response, such as choices.0.message.content (default: tried automatically)
--probes <ids> — Only these probes, comma separated (direct-override, delimiter-injection, indirect-document, encoded-instruction, persona-jailbreak, system-prompt-extraction, secret-request, tool-execution, markdown-exfiltration, raw-html-output)
--repeat <n> 2 Times each probe is sent; models vary, and a hit in any attempt counts
--delay <ms> 300 Pause between requests
--timeout <seconds> 30 Seconds to wait for each reply
--max-requests <n> 100 Send at most this many requests
--secret <text> — A secret known to be in the endpoint’s prompt; a reply that contains it is a definite leak
--format <format> md Report format: json, md, sarif, html, pdf
-o, --output <file> — Write the report to a file instead of stdout
--fail-on <severity> — Exit 1 when a finding is at or above this severity
--save — Also store the findings, so they show in 0 findings list

Generate an SBOM from lockfiles, check one against known advisories, and scan model files

0 sbom

Subcommands: generate · check · scan-models.

Write a CycloneDX 1.5 SBOM from the lockfiles in a folder (npm, pnpm, yarn, Cargo, Go, Python, Ruby, PHP, .NET, Gradle, Dart, Elixir)

0 sbom generate [options] [folder]

Reads package-lock.json, npm-shrinkwrap.json, pnpm-lock.yaml, yarn.lock, Cargo.lock, go.mod, poetry.lock, Pipfile.lock, pinned requirements.txt, Gemfile.lock, composer.lock, packages.lock.json, gradle.lockfile, pubspec.lock and mix.lock anywhere under the folder (skipping node_modules, build output and hidden folders). With the default builtin generator nothing is installed or run; lockfiles are read as text. Components are identified by package URL, sorted and de-duplicated, so the same lockfiles give the same SBOM. A component is marked excluded only when every lockfile that lists it says it is development-only.

What the builtin SBOM carries beyond name and version, and only where the lockfile states it (nothing is looked up or guessed):

  • Hashes (hashes, hex): npm integrity, pnpm resolution.integrity and yarn classic integrity (SHA-512, SHA-384, SHA-256 or SHA-1, converted from base64 only when the length matches the algorithm), Cargo checksum (SHA-256), Composer dist.shasum (SHA-1), Gemfile.lock CHECKSUMS (SHA-256, Bundler 2.5 and later). Poetry gets a hash only for a package with exactly one file, and a gem only when it has a single platform build, because a component has one hash and those have several. Yarn Berry checksum is not reported: it is a hash of Yarn’s own cache archive, not of the published package. No hash is written for Go, Pipfile, requirements.txt, NuGet, Gradle, Dart or Mix. When two lockfiles disagree on a hash, it is left out.
  • Dependency graph (top-level dependencies): from npm lockfile v2 and v3 (resolved the way Node does), pnpm snapshots (v9) or package entries (v5, v6), yarn classic and Berry, Cargo dependencies, poetry [package.dependencies], Gemfile.lock spec lines and Composer require (platform requirements such as php are skipped). Every ref is a component in the SBOM, and entries are sorted. A component whose lockfile records a graph and has no dependencies is listed with an empty dependsOn; a component from a lockfile that records no graph (Go, Pipfile, requirements.txt, NuGet, Gradle, Dart, Mix, npm lockfile v1) has no entry, which means unknown. The application itself is not given dependencies, so direct versus transitive is not recorded.
  • Licenses (licenses): npm lockfile v2 and v3 license and Composer license. A valid SPDX id is written as id, a valid SPDX expression as expression, and anything else (such as UNLICENSED, SEE LICENSE IN ... or a differently cased id) as the name exactly as stated. Other lockfiles state no license, so none is written; licenses are not fetched from registries.

The supplier of each component is not recorded. --ai also lists the AI in the folder as CycloneDX components: model files (.gguf, .safetensors, .onnx, .pt, .pth, .ckpt, .pkl and others, with pickle-based formats flagged), hub references in code (from_pretrained, pipeline(..., model=), hf_hub_download, load_dataset), hosted model ids passed to provider SDKs (with the provider), and MCP servers from .mcp.json and similar files (an unpinned launcher such as npx -y is flagged). It reads files as text and downloads nothing; a reference the patterns do not recognise is missed, so treat the list as what was seen, not a complete inventory. The output is valid CycloneDX 1.5 (checked against the official schema in the tests, with hashes, graph and licenses). The builtin generator does not read Maven pom.xml without a lockfile, CocoaPods or SwiftPM, C and C++ package managers, container images, operating-system packages or compiled binaries. A folder with no supported lockfile is an error (exit 2).

--format spdx writes SPDX 2.3 JSON instead (builtin generator only; validated against the official SPDX 2.3 JSON schema in the tests). It has one package for the application and one per library, each with its package URL as a purl external reference, its checksums, and its license when that is an SPDX id or expression (free-text license names become NOASSERTION, because SPDX would need the license text). DESCRIBES points at the application, DEPENDS_ON follows the graph above, and the application DEPENDS_ON every component that no other component depends on. The AI inventory is not written to SPDX (--ai is refused with it), because SPDX 2.3 has no type for models, datasets or MCP servers.

--generator syft, cdxgen or trivy runs that installed tool instead and writes its CycloneDX JSON unchanged, for what the builtin reader does not cover (Maven, container images, operating-system packages, binaries). It starts the tool without a shell, with the folder as an absolute path, a 10 minute timeout and a temporary working directory, and executes nothing from the scanned folder itself. If the tool is not installed, the command prints how to install it and exits 2. The invocations are syft dir:<folder> -o cyclonedx-json, cdxgen --lifecycle pre-build --no-install-deps -o <temp file> <folder> (those two flags are documented as keeping cdxgen from running the project’s package manager) and trivy fs --format cyclonedx --quiet <folder>. Run for real on this repository with syft 1.57.2, trivy 0.76.2 and a current cdxgen, all three produced a CycloneDX 1.7 document (the builtin reader writes 1.5), with different component counts because each tool also walks the other trees in the folder. Whether trivy fetches its vulnerability database on a first run, and how older cdxgen versions treat those two flags, is not verified. The tools’ own behaviour, such as network access, is theirs, and --ai and --format spdx are not available with them.

Argument Required Description
folder No Folder to read lockfiles from
Option Registered default Description
-o, --output <file> — Write the SBOM to a file instead of stdout
--name <name> — Name of the application the SBOM describes (default: the folder’s name)
--generator <tool> builtin Who writes the SBOM: builtin (reads lockfiles; default), syft, cdxgen, trivy (run the installed tool; exit 2 if it is missing)
--format <format> cyclonedx Output format: cyclonedx (1.5, default) or spdx (2.3 JSON; builtin generator only)
--ai — Also list the AI in the folder: models, datasets, hosted model ids and MCP servers, found by reading files as text

Look every component of an SBOM up in the public OSV database and list the advisories

0 sbom check [options] <file>

Lists each advisory with its aliases, severity, the versions that fix it and a one-line summary, grouped by component. The only network use is the lookup at https://api.osv.dev: package URLs go out and nothing else does. Exit 0 when there are no advisories and 1 when there are, so a scheduled job can fail or open an issue.

Argument Required Description
file Yes CycloneDX SBOM (JSON), for example from 0 sbom generate
Option Registered default Description
--format <format> text Output: text or json

Scan model files (pickle, PyTorch, joblib, numpy) for imports that can run code when loaded

0 sbom scan-models [options] <path>

Pickle-based model files (.pkl, .pickle, .joblib, .pt, .pth, .ckpt, .bin, .npy, .npz, including the data.pkl inside a PyTorch zip) run the callables they reference when they are loaded. This command reads the files as bytes, walks the pickle opcodes (protocols 0 to 5, including GLOBAL, STACK_GLOBAL, INST, OBJ, NEWOBJ and REDUCE) and sorts every imported callable into three groups: dangerous (os.system, subprocess.*, builtins.eval/exec/__import__/open, importlib.*, socket.*, shutil.*, network clients, ctypes.*, nested pickle.loads/torch.load and similar), expected (the tensor rebuild helpers, storages, collections.OrderedDict, numpy array reconstruction and the like) and unrecognised (on neither list, reported at lower severity because libraries such as scikit-learn pickle their own classes). Nothing is loaded, imported or executed, and no Python is needed. The format comes from the content, not the extension, so a pickle renamed .safetensors is still scanned. Reads are bounded: large payloads are skipped without being read, zip directories and decompressed sizes have limits (a zip bomb is reported, not inflated), archive member names are never extracted, and a truncated or malformed file is reported as an incomplete scan instead of an error.

Each file is listed with its format, a verdict (DANGEROUS, unrecognised imports, no dangerous imports found, not a pickle format, not scanned) and the offending imports. Safetensors and TFLite are reported as formats with no code execution possible; GGUF and ONNX are reported as not pickle formats. Keras .h5 and .keras files are not scanned, because they can embed Python code. “No dangerous imports found” means exactly that: the scanner can miss what it cannot parse, and it does not say a file is safe or that the weights are trustworthy. --format sarif writes one result per dangerous file, located at the file, for code scanning. Exit 1 when any file is dangerous, 2 on a usage error. 0 sbom generate --ai adds a 0:risk property to a model file in the inventory when this scan finds it dangerous.

Argument Required Description
path Yes A model file, or a folder to search for model files
Option Registered default Description
--format <format> text Output: text, json or sarif

Browse and manage persisted findings

0 findings [options]

Human triage (new, accepted, suppressed) and verification have independent states. Accepting a finding records the operator’s decision; reproduction and fix verification remain separate steps.

Subcommands: list · show · update · import · fix · burndown · evidence · report-draft · accept · suppress · reopen · export · keys · upload · issues · reports. Subcommands: list · show · update · import · fix · evidence · report-draft · accept · suppress · reopen · export · keys · upload · reports. Subcommands: list · show · update · import · fix · burndown · accept · suppress · reopen · export · keys · upload · reports.

Option Registered default Description
--db-path <path> — Path to SQLite database
--scan <scanId> — Filter by scan ID
--severity <severity> — Filter by severity: critical, high, medium, low, info
--category <category> — Filter by attack category
--status <status> — Filter by status: discovered, verified, confirmed, scored, reported, fixed, false-positive
--triage <triage> — Filter by triage: new, accepted, suppressed
--limit <n> 50 Max findings/groups to show
--all false Show raw finding rows instead of grouped fingerprints

List findings from the database

0 findings list [options]
Option Registered default Description
--all — Show raw finding rows instead of grouped fingerprints
--db-path <path> — Path to SQLite database
--scan <scanId> — Filter by scan ID
--severity <severity> — Filter by severity: critical, high, medium, low, info
--category <category> — Filter by attack category
--status <status> — Filter by status: discovered, verified, confirmed, scored, reported, fixed, false-positive
--triage <triage> — Filter by triage: new, accepted, suppressed
--limit <n> — Max findings/groups to show

Show detailed information about a finding

0 findings show [options] <id>
Argument Required Description
id Yes Finding ID (full or prefix)
Option Registered default Description
--db-path <path> — Path to SQLite database
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Mark a finding family as accepted

0 findings accept [options] <id>
Argument Required Description
id Yes Finding ID (full or prefix)
Option Registered default Description
--db-path <path> — Path to SQLite database
--note <text> — Optional triage note

Suppress a finding family across duplicate occurrences

0 findings suppress [options] <id>
Argument Required Description
id Yes Finding ID (full or prefix)
Option Registered default Description
--db-path <path> — Path to SQLite database
--note <text> — Suppression reason

Reset a finding family back to new

0 findings reopen [options] <id>
Argument Required Description
id Yes Finding ID (full or prefix)
Option Registered default Description
--db-path <path> — Path to SQLite database
--note <text> — Optional triage note

Import findings from another scanner’s SARIF 2.1.0 file (use - for stdin). Nothing in the file is executed.

0 findings import [options] <file>

Each result becomes a finding that keeps the scanner’s name, rule, severity, CWE and file and line. The scan it creates is marked as imported and unverified, and importing the same file again changes nothing. Absolute paths become repo-relative under --root; paths outside it are dropped. Stop a running console on the same database first.

Argument Required Description
file Yes SARIF file, or - to read standard input
Option Registered default Description
--tool <name> — Label for the scanner, overriding the name in the file
--root <dir> — Folder that was scanned; absolute paths under it become repo-relative (default: the current directory)
--db-path <path> — Destination database; stop its running console before importing

Fix one finding in an isolated git work tree and open a pull request for review

0 findings fix [options] <finding>

A thread follows the fix-finding skill in a separate work tree of the repository, so your checkout is never touched. It makes the smallest change it can; then the command runs each --test check, commits on a branch named 0/fix-<id> and opens a pull request, as a draft when a check fails. Running it again for the same finding updates the same pull request. Nothing is pushed to the base branch and nothing is merged: a person reviews and merges. Use --test for the project’s tests and, to re-run the scanner that raised the finding, its own command (for example foxguard .). It edits files on this machine, so it needs the local console and does not accept --computer or --engine-url.

Argument Required Description
finding Yes
Option Registered default Description
--repo <dir> — Git repository the finding is in (default: the current directory)
--base <branch> — Branch to start from and open the pull request against (default: the remote’s default branch)
--test <command> — Check to run after the change; repeat for several. A failing check makes the pull request a draft
--no-pr — Commit on the fix branch but do not push or open a pull request
--budget <usd> 3 Stop when the estimated spend reaches this many USD
--model <model> — Model for the fix thread (default: gpt-6-luna)
--timeout <seconds> 1800 Maximum seconds to wait for the fix
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to

Write a draft early warning, notification or final report about one finding (Markdown; nothing is sent)

0 findings report-draft [options] <finding>

For a manufacturer that has to tell the authorities about an actively exploited vulnerability (Article 14 of Regulation (EU) 2024/2847, the Cyber Resilience Act; confirm the current requirements and deadlines yourself). The text is built without a model. Each field is copied from the finding record (title, severity, category, location, status, triage state, when the record was created, and the attacker-impact sentence when someone assessed it), copied from a fact you pass with a flag or in a --facts JSON file, or left as [to be completed by the manufacturer: ...]. Nothing says the vulnerability is exploited, that users are affected or that a fix exists unless you supplied it. --evidence-file lists a file’s name, size and SHA-256 and never copies its content. The draft says plainly that a person must review it and submit it through the authority’s own channel; 0 submits nothing. --stage all writes the three stages one after another. The finding can be a full id, an id prefix or fp: plus a fingerprint prefix from 0 findings list.

Argument Required Description
finding Yes
Option Registered default Description
--stage <stage> required — early-warning, notification, final or all
--product <name> — Product name
--manufacturer <name> — Legal name of the manufacturer
--contact <text> — Who submits the report and how to reach them
--affected-versions <text> — Affected product versions
--exploited-since <when> — When exploitation is known to have started
--exploitation-evidence <text> — How you know it is being exploited
--malicious-actor <text> — Suspected malicious act or actor, if known
--member-states <text> — Member States where the product is available
--mitigation <text> — Mitigation taken or recommended
--user-measures <text> — What users can do now
--corrective-measure <text> — The fix or update available to users
--corrective-measure-date <when> — When the corrective measure became available
--evidence-file <file> — Name and SHA-256 of a supporting file (its content is never copied); repeat for several
--facts <file> — JSON file with the same facts (camelCase keys, for example affectedVersions); flags win
-o, --output <file> — Write to a file instead of stdout
--db-path <path> — Path to SQLite database

Write one folder of findings, SARIF, SBOM and fix branches, with a README that says what it does and does not show

0 findings evidence [options] <folder>

Writes README.md, manifest.json (version, date, commit, models, SHA-256 of each file), findings.json and findings.md (severity, status, triage state and note, timestamps, location), findings.sarif, sbom.cdx.json (from the lockfiles in --repo), fixes.md (fix branches that exist in --repo) and, with --check-advisories, advisories.json from the public OSV database. That lookup is the only network use, and only with that flag. Evidence and proof-of-concept bodies are left out unless you pass --include-evidence, and then the folder can hold working exploit details. The command writes only those file names inside the folder, refuses a folder that holds other files, a symbolic link, or a folder inside the repository, and removes a file of its own from an earlier run that it did not write this time. The README makes no claim of compliance. It is evidence for your own records, not a conformity assessment.

Argument Required Description
folder Yes
Option Registered default Description
--repo <folder> — Repository the findings are about: adds the SBOM, the commit and the fix branches
--check-advisories — Look the SBOM components up in the public OSV database (the only network use)
--include-evidence — Also write evidence and proof-of-concept bodies (can contain working exploit details)
--scan <id> — Only the findings of this scan
--name <name> — Name of the application the SBOM describes (default: the repository folder’s name)
--db-path <path> — Path to SQLite database
--json — Print the result as JSON
--format <format> — Output: text or json Choices: text, json.

Work through open findings in batches: one fix branch and pull request each, then a report

0 findings burndown [options]

Selects open findings (not fixed, false positive, accepted or suppressed; one per fingerprint, worst severity first) and runs each through the same flow as findings fix: its own git work tree, a branch named 0/fix-<id>, your --test checks, and one pull request, a draft when a check fails. Nothing is pushed to the base branch and nothing is merged. Filter with --severity, --category, --tool (or --source), --scan and --fingerprint, and size a batch with --limit.

--concurrency (1 to 4) runs fixes side by side, each in its own work tree. --budget is the total for the run and --per-fix caps one fix; the cap shrinks to what is left of the total, and no fix starts once it is spent. The run stops when --max-consecutive-failures fixes fail in a row, or when the share of failures goes above --max-failure-rate after --min-attempts fixes. A fix fails when the thread changes nothing, errors, or a check fails.

The outcome per finding is kept in ~/.0/burndown.json, so running the same command again skips findings that already have a pull request (or, with --no-pr, a committed branch) and continues with the rest; --retry works on them again. The report lists proposed, committed, pull requests opened or updated with their links, checks passing, drafts because a check failed, skipped findings with the reason, cost and time; --format json prints it as JSON. Each run also adds a row of metrics (findings attempted, fixes proposed, check result, cost, duration) that --history lists. --dry-run shows the plan and changes nothing. It edits files on this machine, so it needs the local console and does not accept --computer or --engine-url.

Exit codes: 0 every attempted fix is verified (or there was nothing to do), 1 a fix failed or the run stopped on failures, 2 usage error, 3 the total budget ran out.

Option Registered default Description
--severity <levels> — Only these severities (critical, high, medium, low, info; comma-separated)
--category <category> — Only this category
--tool <name> — Only findings reported by this tool
--source <name> — Alias of —tool
--scan <id> — Only findings of this scan (id prefix)
--fingerprint <prefix> — Only findings whose fingerprint or id starts with this
--limit <n> — Attempt at most this many findings in this run; the next run continues with the rest
--repo <dir> — Git repository the findings are in (default: the current directory)
--base <branch> — Branch to start from and open pull requests against (default: the remote’s default branch)
--test <command> — Check to run after each change; repeat for several. A failing check makes the pull request a draft
--no-pr — Commit on the fix branches but do not push or open pull requests
--concurrency <n> 1 Fixes at the same time, each in its own work tree (1 to 4)
--budget <usd> 10 Total spend for this run in USD; no new fix starts once it is used
--per-fix <usd> 3 Spend cap for one fix, in USD
--max-consecutive-failures <n> 3 Stop after this many failed fixes in a row
--max-failure-rate <fraction> 0.5 Stop when the share of failed fixes is above this (after —min-attempts)
--min-attempts <n> 4 Fixes to attempt before the failure share can stop the run
--model <model> — Model for the fix threads (default: gpt-6-luna)
--timeout <seconds> 1800 Maximum seconds to wait for one fix
--retry — Work again on findings that already have a fix branch or pull request
--dry-run — List what would be attempted and skipped; change nothing
--history — List the metrics row of each earlier run and exit
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to

Upload a SARIF file to GitHub code scanning, so findings show in the Security tab and on pull requests

0 findings upload [options] <file>

Put the scan in a pull request check: 0 scan . --diff origin/main --format sarif -o scan.sarif, then 0 findings upload scan.sarif. The repository, commit and ref come from the clone (GITHUB_SHA and GITHUB_REF in Actions). The file is compressed, uploaded with gh, and checked until GitHub has processed it; a refused file is reported with GitHub’s reason. GitHub matches alerts by fingerprint, so an upload for a later commit updates them. gh needs permission to write security events (security-events: write in Actions).

Argument Required Description
file Yes SARIF 2.1.0 file, for example from 0 scan --format sarif -o scan.sarif
Option Registered default Description
--repo <owner/name> — Repository (default: the current clone’s)
--commit <sha> — Commit the results are for (default: HEAD, or GITHUB_SHA in Actions)
--ref <ref> — refs/heads/<branch> or refs/pull/<n>/merge (default: the current branch, or GITHUB_REF in Actions)
--tool <name> — Name the tool shown in GitHub
--no-wait — Return when GitHub has accepted the upload instead of waiting for it to be processed
--format <format> text Output: text or json

Mirror findings into GitHub Issues, one issue per finding, kept in sync without duplicates

0 findings issues [options]
Terminal window
0 findings issues --repo acme/app --dry-run
0 findings issues --repo acme/app --min-severity high --max 10

Run --dry-run first: it prints what would be created, updated, closed or reopened and changes nothing. Each finding family gets one issue, found again on later runs through a hidden <!-- 0-finding:<key> --> marker in its body (the key is the finding’s fingerprint), so running it again never duplicates. Open findings at or above --min-severity (default medium) get an issue; an issue is updated when the finding’s title, severity or location changed, closed with a comment when the finding is suppressed, accepted, fixed or marked a false positive, and reopened if it comes back. It creates the security and severity:<level> labels when they are missing; if it cannot, it warns and carries on without them. It only manages issues that carry the security label (applying that label needs triage rights), so removing it from an issue detaches that issue and a new one is created for the finding. --max (default 25) caps the changes in one run and --delay (default 1000 ms) spaces them out for GitHub’s rate limits; run again to continue. The issue text holds only the title, severity, category, location (path:line), the attacker-impact sentence, the status and a hint for finding the details locally. Evidence, requests, responses and proof-of-concept bodies are never copied, because they can quote code or secrets. Report text is neutralised: no @mentions, no #123 references, no HTML or links. gh needs permission to write issues (issues: write in Actions). The repository is taken from the clone when --repo is not given.

Option Registered default Description
--repo <owner/name> — Repository (default: the current clone’s)
--min-severity <severity> medium Open issues only for findings at or above this: critical, high, medium, low or info
--max <n> 25 Most issues to create, update, close or reopen in one run
--delay <ms> 1000 Wait this long between changes to respect rate limits
--dry-run — Print what would change and change nothing
--db-path <path> — Path to SQLite database (default: the shared database and every scan’s)
--format <format> text Output: text or json

Export selected findings, or a whole scan, as json, md, sarif, html or pdf. Reads the local database; no engine needs to run. IDs accept a unique prefix. For a share-safe copy of a JSON report use 0 findings reports export.

0 findings export [options] [ids...]
Terminal window
0 findings export 3f2a 91bc --format sarif -o findings.sarif
0 findings export --scan 20260101-abc --format pdf -o report.pdf
Argument Required Description
ids No
Option Registered default Description
--scan <id> — Export every finding of this scan instead of selected IDs
--format <format> json json, md, sarif, html or pdf
-o, --output <file> — Write to a file instead of stdout
--severity <severity> — With no IDs: only this severity
--category <category> — With no IDs: only this category
--status <status> — With no IDs: only this status
--triage <triage> — With no IDs: only this triage state
--db-path <path> — Path to SQLite database
--json — Print the result of writing a file as JSON

Manage read-only API access keys for the findings API. The secret is printed once at creation and never stored in plaintext. Team workspaces manage keys in the browser.

0 findings keys
Terminal window
0 findings keys create ci-reader --expires-in 30

Subcommands: list · create · revoke.

List keys with their expiry and status. Secrets are never shown.

0 findings keys list [options]
Terminal window
0 findings keys list --json
Option Registered default Description
--db-path <path> — Path to SQLite database
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Create a read-only key. Default expiry is 90 days.

0 findings keys create [options] <name>
Terminal window
0 findings keys create ci-reader --expires-in 30
Argument Required Description
name Yes
Option Registered default Description
--expires-in <days> — Days until the key expires (default 90)
--db-path <path> — Path to SQLite database
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Revoke a key. Requires --yes.

0 findings keys revoke [options] <id>
Terminal window
0 findings keys revoke 643b88a4-2fae-409b-b4d9-bea00fc75812 --yes
Argument Required Description
id Yes
Option Registered default Description
--yes — Confirm the revocation
--db-path <path> — Path to SQLite database
--json — Print JSON
--format <format> — Output: text or json Choices: text, json.

Manage the local findings database.

0 config db

Subcommands: repair · reset.

Back up a malformed local SQLite database and recreate a clean one

0 config db repair [options]
Option Registered default Description
--db-path <path> — Path to SQLite database

Delete the local SQLite database and optionally reseed the verification workbench

0 config db reset [options]
Option Registered default Description
--db-path <path> — Path to SQLite database
--seed <preset> verification Seed preset to load after reset

Reset also removes <db>-journal and the <db>.lock directory left by the SQLite WASM engine. It refuses, and deletes nothing, when the database path is a directory (check ZERO_DB_PATH and --db-path), when the process recorded in <db>.lock/pid is still alive, or when the lock has no owner information and was modified in the last 5 minutes. Symlinks are removed as links and never followed; recursive deletion applies only to the .lock path. The browser’s reset-database route shares this behavior and can return an error for a held lock.

Add and manage remote computers. A computer is a remote 0 engine that runs threads and automations on its host; select it in the browser’s computer menu to work there. worker still works as an older name.

0 computers

Subcommands: list · add · stop · repair · remove · hosts.

List the registered remote computers with their host and whether 0 deployed them (managed computers can be reconnected and stopped from here).

0 computers list [options]
Terminal window
0 computers list --json
Option Registered default Description
--json — Print JSON
--engines-config <path> — Engine registry path
--format <format> — Output: text or json Choices: text, json.

Also available as computers add. Deploy the built CLI engine onto a running Linux Lima instance or an SSH host and register its connection locally. Run pnpm build in a source checkout first. Use --ssh for an SSH host alias or user@host; otherwise the command uses the zero-worker Lima instance. SSH deployment uses noninteractive key authentication.

0 computers add [options]

Use --target-git with an https:// URL to clone your repository into the remote workspace. Forwarding OPENAI_API_KEY is explicit through --forward-provider-key; use it only for a host you own. Deployment installs runtime dependencies and starts the engine on the remote machine. Inspect the returned backend ID and connection details, then select that computer in the browser before starting remote work.

Option Registered default Description
--ssh <user@host> — SSH target host (BatchMode; key auth from ssh config/agent)
--lima <name> zero-worker Lima instance name
--target-git <url> — HTTPS URL of a Git repository the remote server clones into the engine folder instead of the bundled demo target
--ssh-config <path> — OpenSSH config file for the SSH target (e.g. a Lima instance’s ssh.config)
--engine-port <port> — Engine port on the remote server (default: stable port derived from host)
--trust-new-host false Trust and remember the computer’s SSH host key if it is not known yet
--forward-provider-key false Forward this computer’s OPENAI_API_KEY to the remote engine (user-owned hosts only)
--engines-config <path> — Engine registry path

Aliases: deploy.

Also available as computers reconnect.

Reconnect a previously deployed worker using its saved deployment metadata and credentials. The command starts the retained managed engine if needed and recreates its owned SSH tunnel. It preserves remote files and refuses to replace an unrelated process or an occupied engine port. If the deployment files are missing, deploy the worker again.

0 computers repair <id>

The result is JSON with the backend ID, reconnection status, and whether the engine was started.

Argument Required Description
id Yes

Aliases: reconnect.

Stop a worker engine that Zero deployed and disconnect its owned local tunnel. The command verifies the saved deployment metadata, remote working directory, PID and process command before sending a termination signal. It retains the remote workspace and the saved backend registration so the worker can be redeployed later.

0 computers stop <id>
Argument Required Description
id Yes

Remove a remote computer from this machine: closes the tunnel and forgets its saved connection. Files on the remote computer stay in place.

0 computers remove [options] <id>

Run 0 computers list to see the IDs.

Argument Required Description
id Yes
Option Registered default Description
--engines-config <path> — Engine registry path

List SSH host aliases discovered from ~/.ssh/config, with their resolved host and user when present. This lists configuration entries rather than checking connectivity or whether each host supports a Linux engine.

0 computers hosts

Browse, add, create, edit, import, export and link skills

0 skills

Every command works with the app running or on its own, and takes --json. Adding from GitHub or the catalog shows a review first and needs --yes.

Terminal window
0 skills list
0 skills catalog --search handoff
0 skills add mattpocock~skills~handoff --yes

Subcommands: list · add · show · new · edit · copy · delete · import · export · link · unlink · catalog · extensions · remove.

List installed skills and linked folders

0 skills list [options]
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Show a skill’s SKILL.md and files

0 skills show [options] <id-or-name>
Argument Required Description
id-or-name Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Create a skill from a SKILL.md file

0 skills new [options] <file>
Argument Required Description
file Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Replace a skill’s SKILL.md with the contents of —file

0 skills edit [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--file <path> required — SKILL.md with the new content
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Save a workspace copy of a skill under a new name

0 skills copy [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--name <name> required — Name for the copy (lowercase letters, digits, hyphens)
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Delete a skill from the workspace library

0 skills delete [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--yes — Confirm the deletion
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Import a skill bundle (.skill.json) or a folder with SKILL.md

0 skills import [options] <bundle>
Argument Required Description
bundle Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Export a skill as a bundle

0 skills export [options] <id>
Argument Required Description
id Yes
Option Registered default Description
-o, --output <file> — Write the bundle to a file instead of stdout
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Link a folder of skills; they stay where they are

0 skills link [options] <folder>
Argument Required Description
folder Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Unlink a folder by its link id (see 0 skills list --json)

0 skills unlink [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Browse the skills catalog

0 skills catalog [options]
Option Registered default Description
--search <text> — Filter by name, publisher or summary
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Add a skill from the catalog or GitHub (owner/repo[/path]); shows a review first

0 skills add [options] <source>
Argument Required Description
source Yes
Option Registered default Description
--preview — Only show the review
--yes — Install the reviewed commit
--enable — Extensions: also enable it
--project <dir> — Extensions: with —enable, enable for this folder only
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Installed extensions: list, info, enable, disable, update, remove (install with 0 skills add)

0 skills extensions

Subcommands: add · mcp · list · info · enable · disable · remove · update · import.

Install an extension: <url|owner/repo|folder>@; same as 0 skills add

0 skills extensions add [options] <source>
Argument Required Description
source Yes
Option Registered default Description
--preview — Only show the install prompt
--yes — Install the exact revision shown
--enable — Also enable it
--project <dir> — With —enable: enable for this folder only
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Add one MCP server as a local extension

0 skills extensions mcp [options] <name> [command...]
Argument Required Description
name Yes
command No
Option Registered default Description
--url <https-url> — A remote server instead of a command
--preview — Only show the install prompt
--yes — Install the exact revision shown
--enable — Also enable it
--project <dir> — With —enable, enable for this folder only
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

List installed extensions and built-ins

0 skills extensions list [options]
Option Registered default Description
--project <dir> — Show enablement for this project
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Show the install prompt for an installed extension

0 skills extensions info [options] <name>
Argument Required Description
name Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Enable globally, or for one project with —project

0 skills extensions enable [options] <name>
Argument Required Description
name Yes
Option Registered default Description
--project <dir> — Enable for this folder only
--yes — Approve an unapproved revision (for example an imported one)
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Disable globally, or for one project with —project

0 skills extensions disable [options] <name>
Argument Required Description
name Yes
Option Registered default Description
--project <dir> — Disable for this folder only
--yes — Confirm disabling a built-in
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Remove an installed extension and its stored revisions

0 skills extensions remove [options] <name>
Argument Required Description
name Yes
Option Registered default Description
--yes — Confirm the removal
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Show the diff and install prompt for a newer revision; —yes —to approves it

0 skills extensions update [options] <name>
Argument Required Description
name Yes
Option Registered default Description
--to <sha> — Full commit SHA to update to (default: the remote HEAD)
--yes — Approve the revision given by —to
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Import earlier plugins, MCP servers and skills (runs once automatically); shows what could not be migrated

0 skills extensions import [options]
Option Registered default Description
--force — Run the importer again
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Remove a skill that was added from GitHub or the catalog

0 skills remove [options] <name>
Argument Required Description
name Yes
Option Registered default Description
--yes — Confirm the removal
--json — Print machine-readable JSON
--db-path <path> — Use this engine database instead of the default
--format <format> — Output: text or json Choices: text, json.

Saved automations.

0 automation

Subcommands: list · show · create · edit · duplicate · versions · rollback · delete.

List saved automations and templates.

0 automation list [options]
Option Registered default Description
--templates — List only templates
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> json Output format: json or text

Inspect one saved automation or select a template with --template.

0 automation show [options] [id]
Argument Required Description
id No
Option Registered default Description
--template <id> — Show a template definition
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> json Output format: json or text

Create an automation from a template or a JSON definition.

0 automation create [options]
Option Registered default Description
--template <id> — Start from a template (see 0 sentinels list --automation --templates)
--file <path> — Definition JSON object
--name <name> — Name for the new automation
--target <target> — Target the automation runs against
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)

Replace an automation’s definition from a JSON file.

0 automation edit [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--file <path> required — Definition JSON object
--revision <n> — Reviewed revision to edit (default: the current one)
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)

Save a copy of an automation.

0 automation duplicate [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--name <name> — Name for the copy
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)

List saved revisions of an automation.

0 automation versions [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)

Restore an earlier revision as a new revision.

0 automation rollback [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--revision <n> required — Revision to restore (see 0 sentinels set --automation versions)
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)

Delete a saved automation and its schedules.

0 automation delete [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--revision <n> — Reviewed revision to delete (default: the current one)
--yes — Confirm deletion
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)

Inspect and control the same live sessions used by the browser. Attach with —engine or —engine-url/—engine-token-env, or use the discovered local engine. Session operations preserve current engine admission grants.

0 threads
Terminal window
0 threads list --engine production

Subcommands: list · show · send · start · stop · create · continue · cancel · force-stop · events · resume · decide · retry · set · rename · clear · close · archive · delete · export.

List live sessions, or retained snapshots with —saved. Listing does not resume work.

0 threads list [options]
Terminal window
0 threads list --saved --engine production
Option Registered default Description
--saved — List retained thread snapshots
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Read an existing live session without recreating it or restoring approvals.

0 threads show [options] <id>
Terminal window
0 threads show SESSION_ID --engine production
Argument Required Description
id Yes
Option Registered default Description
--wait — Wait for the answer; stdout is the reply only (thread id and usage go to stderr)
--timeout <seconds> 600 Maximum seconds to wait with —wait
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Create a session within the engine’s authorized workspace and model configuration. —config reads a bounded JSON object; it cannot expand engine grants.

0 threads create [options]
Terminal window
0 threads create --config session.json --engine production
Option Registered default Description
--config <path> — Thread configuration JSON object
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> json Output format: json or text
--json —

Send text to a live engine session. The engine runs the turn using its configured provider and tools.

0 threads send [options] <id> <text>
Terminal window
0 threads send SESSION_ID "Review the current findings" --engine production
Argument Required Description
id Yes
text Yes
Option Registered default Description
--wait — Wait for the answer; stdout is the reply only (thread id and usage go to stderr)
--timeout <seconds> 600 Maximum seconds to wait with —wait
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Continue the selected live session with optional text. This preserves the existing engine context.

0 threads continue [options] <id> [text]
Terminal window
0 threads continue SESSION_ID --engine production
Argument Required Description
id Yes
text No
Option Registered default Description
--wait — Wait for the answer; stdout is the reply only (thread id and usage go to stderr)
--timeout <seconds> 600 Maximum seconds to wait with —wait
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Explicitly cancel the session’s active work. Transport disconnect alone does not request cancellation from an attached engine.

0 threads cancel [options] <id>
Terminal window
0 threads cancel SESSION_ID --engine production
Argument Required Description
id Yes
Option Registered default Description
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Read engine session events after an optional nonnegative cursor. Cursors belong to that engine and session.

0 threads events [options] <id>
Terminal window
0 threads events SESSION_ID --after 0 --engine production
Argument Required Description
id Yes
Option Registered default Description
--after <cursor> — Nonnegative engine event cursor
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> json Output format: json or text
--json —

Explicitly stop a qualified session’s owned execution process and registered resources. Use the exact live ID from 0 threads list; this command never restores a saved chat or substitutes a replacement session. The owning engine checks authorization and supervisor availability. Unsupported execution returns an error, and unconfirmed teardown remains quarantined. No automatic escalation or replay occurs.

0 threads force-stop [options] <id>
Terminal window
0 threads force-stop LIVE_SESSION_ID --engine production
0 threads force-stop LIVE_SESSION_ID --engine-url http://127.0.0.1:48123 --engine-token-env ZERO_ENGINE_TOKEN

Force stop is available for qualified Bun sessions on macOS/Linux; completed external effects are not undone. Inspect 0 threads show after an error before taking another action.

Argument Required Description
id Yes
Option Registered default Description
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Restore a retained snapshot as a new session under current engine grants. Stored transcripts do not restore approval or filesystem grants.

0 threads resume [options] <saved-id>
Terminal window
0 threads resume SAVED_ID --engine production
Argument Required Description
saved-id Yes
Option Registered default Description
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> text Output format: json or text
--json —

Respond to an existing session decision using a JSON response file. The engine checks the decision belongs to that live session.

0 threads decide [options] <id> <decision-id>
Terminal window
0 threads decide SESSION_ID DECISION_ID --response response.json --engine production
Argument Required Description
id Yes
decision-id Yes
Option Registered default Description
--response <path> required — Decision response JSON object
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--engine <id> — Use a registered remote engine; targets and inputs are interpreted there
--engines-config <path> — Operator engine connection registry JSON file
--db-path <path> — Control database of the local engine
--format <format> json Output format: json or text
--json —

Create a thread, send the first prompt and print its ID. With --wait, block until the turn ends and print the reply.

0 threads start [options] <prompt>
Terminal window
0 threads start "Triage the open findings" --model gpt-5 --effort high --mode recon --wait
Argument Required Description
prompt Yes
Option Registered default Description
--model <model> — Model for this thread
--effort <level> — Reasoning effort: minimal, low, medium, high, xhigh
--approvals <ask|auto> — Moved to the global setting
--folder <path> — Folder the thread works in
--skill <id> — Built-in skill to follow; if it declares a check, the harness runs it and the thread cannot claim Verified without it
--title <title> — Thread title
--wait — Wait for the answer; stdout is the reply only (thread id and usage go to stderr)
--cost-ceiling <usd> — Stop the thread when its estimated spend reaches this many USD
--timeout <seconds> 600 Maximum seconds to wait with —wait
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Cancel a thread’s active work. --force force stops owned execution that did not drain.

0 threads stop [options] <id>
Terminal window
0 threads stop 3f2a --force
Argument Required Description
id Yes
Option Registered default Description
--force — Force stop owned execution that did not drain
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Re-run the last turn of a thread.

0 threads retry [options] <id>
Terminal window
0 threads retry 3f2a
Argument Required Description
id Yes
Option Registered default Description
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Change a thread’s model, reasoning effort, mode or folder. A computer is chosen when the thread starts.

0 threads set [options] <id>
Terminal window
0 threads set 3f2a --mode copilot --folder ~/code/app
Argument Required Description
id Yes
Option Registered default Description
--model <model> — Model
--effort <level> — Reasoning effort: minimal, low, medium, high, xhigh
--approvals <ask|auto> — Moved to the global setting
--folder <path> — Folder the thread works in
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Rename a thread, or generate a new title from its conversation.

0 threads rename [options] <id> [title]
Terminal window
0 threads rename 3f2a --regenerate
Argument Required Description
id Yes
title No
Option Registered default Description
--regenerate — Generate a new title from the conversation
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Erase a thread’s conversation but keep the thread. Requires --yes.

0 threads clear [options] <id>
Terminal window
0 threads clear 3f2a --yes
Argument Required Description
id Yes
Option Registered default Description
--yes — Confirm the destructive action
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Stop and close a live thread. Its saved copy stays.

0 threads close [options] <id>
Terminal window
0 threads close 3f2a
Argument Required Description
id Yes
Option Registered default Description
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Archive a thread, or a retained snapshot with --saved.

0 threads archive [options] <id>
Terminal window
0 threads archive 3f2a
Argument Required Description
id Yes
Option Registered default Description
--saved — The ID is a retained snapshot, not a live thread
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Permanently delete a thread or, with --saved, a retained snapshot. Requires --yes.

0 threads delete [options] <id>
Terminal window
0 threads delete 3f2a --yes
Argument Required Description
id Yes
Option Registered default Description
--saved — The ID is a retained snapshot, not a live thread
--yes — Confirm the destructive action
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON
--format <format> — Output: text or json Choices: text, json.

Export a thread transcript as JSON or Markdown.

0 threads export [options] <id>
Terminal window
0 threads export 3f2a --format md -o transcript.md
Argument Required Description
id Yes
Option Registered default Description
--saved — The ID is a retained snapshot, not a live thread
--format <format> json json or md
-o, --output <file> — Write to a file instead of stdout
--engine-url <url> — Attach directly to a running trusted engine
--engine-token-env <name> — Environment variable holding the attached engine token
--computer <id> — Use a registered remote computer
--engine <id> —
--computers-config <path> — Operator computer connection registry JSON file
--engines-config <path> —
--db-path <path> — Control database of the local engine to attach to
--json — Print the engine response as JSON

Create, inspect and control Sentinels.

0 sentinels

Subcommands: list · run · set · sync · export · show · presets · create · pause · resume · acknowledge · archive · delete · activations · files · triggers · webhook.

Make Sentinels match the YAML files in a folder. Shows what would change; —apply writes it.

0 sentinels sync [options] <folder>

Each *.yaml file is one Sentinel: name, mission, instructions, skills, model, folder, and automations with their triggers (see Sentinels as files). Without --apply nothing is written. A new Sentinel is created paused and a new trigger disabled, a changed model or skill list sends an active Sentinel back to review, and a Sentinel that is not in the folder is left alone. Stop a running console on the same database first.

Argument Required Description
folder Yes Folder of Sentinel definitions (*.yaml), for example .0/sentinels
Option Registered default Description
--apply — Write the changes (without it, only the plan is shown)
--check — Exit 1 when the database differs from the files
--commit <sha> — Commit the files came from; recorded on each Sentinel
--enable — Enable the triggers this sync creates (only for a change that was already reviewed)
--db-path <path> — Database to change; stop its running console first
--format <format> text Output: text or json

Write a Sentinel as a YAML definition file, so a team can start from what it already has

0 sentinels export [options] <id>

Prints the definition, or writes <name>.yaml into --out. Syncing the exported file back changes nothing.

Argument Required Description
id Yes Sentinel ID (full or prefix) or exact name
Option Registered default Description
--out <folder> — Write <name>.yaml into this folder instead of standard output
--db-path <path> — Database to read; stop its running console first

List Sentinels.

0 sentinels list [options]
Option Registered default Description
--status <status> — Only active, paused, archived
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Show a Sentinel (full or prefix ID).

0 sentinels show [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

List Sentinel presets.

0 sentinels presets [options]
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Create a Sentinel from a preset or a JSON definition.

0 sentinels create [options]
Option Registered default Description
--preset <id> — Start from a preset (see 0 sentinels list --presets)
--name <name> — Name
--file <path> — Sentinel JSON object (overrides preset fields)
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Change a Sentinel’s settings.

0 sentinels set [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--name <name> — Name
--purpose <text> — One-line purpose
--mission <text> —
--file <path> — Patch JSON object
--version <n> — Reviewed version (default: the current one)
--state <state> — active, paused, acknowledged, archived or deleted
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Pause a Sentinel.

0 sentinels pause [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Resume a paused Sentinel.

0 sentinels resume [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--acknowledge — Also acknowledge review of changed model or tools
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Mark changed model or tools as reviewed.

0 sentinels acknowledge [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Archive a Sentinel; its history stays.

0 sentinels archive [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Delete a Sentinel; its automations are detached, not deleted.

0 sentinels delete [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--yes — Confirm deletion
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Run a Sentinel now; starts a thread (needs a running engine).

0 sentinels run [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--task <text> — Task for this run
--yes — Confirm that this run is authorized
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

List a Sentinel’s recent runs.

0 sentinels activations [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--limit <n> 50 Maximum rows (1-200)
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Read and edit a Sentinel’s instructions and notes files.

0 sentinels files

Subcommands: list · get · put · rm.

List files.

0 sentinels files list [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Print a file’s content.

0 sentinels files get [options] <id> <path>
Argument Required Description
id Yes
path Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Create or replace a file from —file or —content.

0 sentinels files put [options] <id> <path>
Argument Required Description
id Yes
path Yes
Option Registered default Description
--file <path> — Read content from a local text file
--content <text> — Inline content
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Delete a file.

0 sentinels files rm [options] <id> <path>
Argument Required Description
id Yes
path Yes
Option Registered default Description
--yes — Confirm deletion
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Control what starts a Sentinel’s automations.

0 sentinels triggers

Subcommands: list · add · enable · disable · check · rm.

List triggers.

0 sentinels triggers list [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Add a trigger for an automation the Sentinel owns; disabled unless —enable —yes.

0 sentinels triggers add [options] <id>
Argument Required Description
id Yes
Option Registered default Description
--automation <id> — What the trigger starts (default: the only one this Sentinel owns)
--kind <kind> — schedule | manual | github-pr
--file <path> — Trigger JSON object with schedule or github settings
--enable — Enable immediately
--yes — Confirm that an enabled trigger was reviewed
--frequency <frequency> — schedule: minutes, hourly, daily, weekdays, weekly, cron
--every <minutes> — schedule, minutes: interval (5 or more)
--at <HH:MM> — schedule, daily, weekdays, weekly: local time
--weekday <day> — schedule, weekly: sun, mon, … or 0-6
--cron <expression> — schedule, cron: five fields
--timezone <zone> — schedule: IANA timezone (default UTC)
--repo <owner/name> — github-pr: repository to watch
--base-branch <branch> — github-pr: only pull requests into this branch
--comment — github-pr: comment on each pull request with one short summary, edited in place on later pushes (default: off)
--include-forks — github-pr: also review pull requests from forks, marked untrusted (default: skipped)
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Enable a trigger after reviewing it.

0 sentinels triggers enable [options] <id> <trigger-id>
Argument Required Description
id Yes
trigger-id Yes
Option Registered default Description
--yes — Confirm that this trigger was reviewed
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Pause a trigger.

0 sentinels triggers disable [options] <id> <trigger-id>
Argument Required Description
id Yes
trigger-id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Poll a pull request trigger now instead of waiting for its next poll.

0 sentinels triggers check [options] <id> <trigger-id>
Argument Required Description
id Yes
trigger-id Yes
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Delete a trigger.

0 sentinels triggers rm [options] <id> <trigger-id>
Argument Required Description
id Yes
trigger-id Yes
Option Registered default Description
--yes — Confirm deletion
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

GitHub webhook for pull request Sentinels (server mode). Hidden: most installs poll. See Sentinels.

0 sentinels webhook

Subcommands: status · secret.

Show whether the webhook is set up and the last deliveries.

0 sentinels webhook status [options]
Option Registered default Description
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.

Manage the webhook secret.

0 sentinels webhook secret

Subcommands: rotate.

Create the secret, or replace it; the old one keeps working for 5 minutes. Printed once.

0 sentinels webhook secret rotate [options]
Option Registered default Description
--yes — Confirm; update the secret on GitHub afterwards
--json — Print machine-readable JSON
--db-path <path> — Control database (default: the user database)
--format <format> — Output: text or json Choices: text, json.
0 config team

Provision opt-in accounts for a customer-controlled team engine. Account-free local use remains the default. Creating a config does not activate it on a running host. See Team workspaces for roles and deployment boundaries.

Subcommands: init · add-user · list.

Create a private configuration with the first owner account. The password is read from protected terminal input or stdin; it is stored as a salted password hash. No email invitation is sent. Then start 0 web --team-config <path>.

0 config team init [options]
Option Registered default Description
--config <path> required — Configuration file to create
--name <name> required — Workspace name
--owner <id> required — Owner account ID
--display-name <name> required — Owner display name

Add an explicit account to a private configuration. Assign owner, editor or viewer; viewer access does not grant agent control. Restart the team engine to load configuration changes. Password input is not a command-line argument.

0 config team add-user [options]
Option Registered default Description
--config <path> required — Team configuration
--user <id> required — Account ID
--display-name <name> required — Display name
--role <role> required — owner, editor or viewer

List configured account IDs, display names and roles without password hashes. The configuration must remain a private regular file.

0 config team list [options]
Option Registered default Description
--config <path> required — Team configuration