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.
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.
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.
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
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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)
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
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)
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
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
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.
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
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
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)
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
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
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)
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.
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.
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.
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)
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.
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.
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.
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.
Create a session within the engine’s authorized workspace and model configuration. —config reads a bounded JSON object; it cannot expand engine grants.
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.
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
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
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.
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>.
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.