{% raw %} # CAR CLI reference > **Generated file — do not hand-edit below the task map.** Produced by > `scripts/gen-cli-docs.sh` from `car --help` / `car help ` on car > 0.54.0 (2026-09-15). Every subcommand the installed binary reports is > below; a new subcommand cannot ship without appearing here the next time > this script runs. To regenerate: `bash scripts/gen-cli-docs.sh`. > > 73 top-level commands, 117 nested subcommands > (one level deep) — counted from the live binary at generation time, not > typed by hand. ## Finding your way around `car` is one binary with 73 subcommands spanning several different jobs: running the built-in agent, coding, local model management, OS integrations, and installing other people's agents on your machine. This map groups the commands people actually reach for; the full alphabetical reference with every flag follows below. ### Run an agent - [`car do`](#car-do) — the general-purpose CAR Assistant. No goal opens an interactive REPL; with a goal it runs once and prints the result. Ships wired with files, a real shell, web access, and durable memory; runs sandbox-first (a hardened Docker container) unless you pass `--local`. - [`car board`](#car-board) — fullscreen supervision board for coder sessions: attach to a run's history, confirm its outcome contract, answer its questions, approve its diff. - [`car agent`](#car-agent) — build and run in-daemon agents from plain-language descriptions; nothing extra to install. - [`car build`](#car-build) — build a runnable workflow from a natural-language goal. - [`car run-task`](#car-run-task) — headless entry point for external eval harnesses: run a goal autonomously against stdio MCP tool servers, emitting a JSONL transcript. ### Code - [`car code`](#car-code) — built-in coding agent: state an intent, confirm the verifiable outcome contract, and CAR delivers it in an isolated git worktree (natively or via an installed frontier CLI). Results land on a `car/coder/` branch after your approval; your checkout is never touched. - [`car code-task`](#car-code-task) — run a coder session headlessly and in this process, driving to a green outcome contract and delivering a PR. - [`car coder-ab`](#car-coder-ab) — A/B-test CAR's coder against an external agent (Codex / Claude Code) over a corpus, and grow that corpus from git history. ### Models and media - [`car setup`](#car-setup) — detect hardware, recommend, and install the right model for this machine. Interactive walkthrough with no flags. - [`car models`](#car-models) — manage local inference models: list, pull, remove, benchmark, route, and more (see the subcommand table below). - [`car infer`](#car-infer) — run text generation with a local model. - [`car image`](#car-image) / [`car video`](#car-video) — generate an image or video with a local MLX model. - [`car speech`](#car-speech) — manage the CAR speech runtime, health checks, and smoke tests. - [`car embed`](#car-embed) — generate embeddings for text. - [`car reason`](#car-reason) — reason about code: diagnose, suggest fixes, explain. ### Memory and skills - [`car skills`](#car-skills) — manage learned skills (SkillRL-inspired). - [`car dream`](#car-dream) — run memory consolidation ("dream") — prune, GC, embed, evolve. - [`car eval`](#car-eval) — evaluate agent improvement from stored trajectories. ### Auth and accounts - [`car auth`](#car-auth) — Parslee account authentication for CAR cloud-backed features (`login`, `status`, `logout`, `orgs`, `switch-org`, `accounts`, `switch-account`). - [`car parslee`](#car-parslee) — Parslee platform capabilities for the signed-in account (requires `car auth login`). - [`car keys`](#car-keys) — store cloud-provider API keys in the OS keychain, so a native-app user never sets an environment variable. - [`car secrets`](#car-secrets) — OS-native secret store (Keychain / Credential Manager / Secret Service); aliased `secret`. - [`car keychain`](#car-keychain) — OS keychain integration. - [`car identity`](#car-identity) — show or change the name your assistant answers to, in conversation, in the host apps, and as its voice wake word. ### Install and supervise contributed agents - [`car install`](#car-install) — install a contributed agent, from a local directory or a registry reference. - [`car ls`](#car-ls) — list every installed contributed agent (long alias `agents`). - [`car inspect`](#car-inspect) — inspect a single installed agent: on-disk manifest plus the supervisor's current status. - [`car start`](#car-start) / [`car stop`](#car-stop) / [`car restart`](#car-restart) — control a supervised, installed agent. - [`car tail-log`](#car-tail-log) — tail an installed agent's captured stdout/stderr (long alias `logs`). - [`car uninstall`](#car-uninstall) — uninstall a contributed agent (idempotent). - [`car registry`](#car-registry) — registry tooling: `digest` a manifest, `validate` a registry directory, or print the canonical `schema`. - [`car publish`](#car-publish) — publish a contributed agent to the registry (signs, stages, opens a PR). ### OS integrations `car` reaches into the OS for accounts, calendar, contacts, mail, messages, notes, reminders, photos, bookmarks, files, wearable health data, and browser bookmarks, plus the permission preflight that gates them and voiceprint enrollment. Most of these are cross-platform (TCC on macOS, WAM/Credential Manager on Windows, GOA/xdg-desktop-portal on Linux, per the command's own `--help`); `car notes`, `car reminders`, and `car photos` are macOS-only — each says so in its own description below: [`car accounts`](#car-accounts), [`car cal`](#car-cal), [`car contacts`](#car-contacts), [`car mail`](#car-mail), [`car messages`](#car-messages), [`car notes`](#car-notes), [`car reminders`](#car-reminders), [`car photos`](#car-photos), [`car bookmarks`](#car-bookmarks), [`car files`](#car-files), [`car health`](#car-health), [`car permissions`](#car-permissions), [`car voice`](#car-voice). ### Diagnose an install - [`car doctor`](#car-doctor) — diagnose (and optionally repair) a CAR install: corrupt model weights, unparseable `~/.car` state files, version skew, leftover files from a previous install. Runs against the local filesystem only — no daemon required. - [`car update`](#car-update) — update the locally-installed `car` CLI and its sibling `car-server` daemon to the latest release (or a pinned version), in place, reconciling drift between update channels. - [`car purge`](#car-purge) — remove this install's own state under `~/.car` and reap OS-level schedules CAR installed, for a clean slate before reinstalling. - [`car onboard`](#car-onboard) — onboarding readiness: what's set up and what's still pending (headless equivalent of the CarHost setup wizard). - [`car approvals`](#car-approvals) — the default posture for what agents may do without asking (CLI counterpart to CarHost's Approvals settings). - [`car info`](#car-info) — show runtime info. ### Runtime internals Lower-level commands mostly useful when embedding CAR or debugging the runtime itself: [`car daemon`](#car-daemon) (start the daemon server), [`car verify`](#car-verify) / [`car simulate`](#car-simulate) / [`car optimize`](#car-optimize) (static proposal verification — see [SPEC.md](./SPEC.md)), [`car replay`](#car-replay) (replay an event journal and show reconstructed state), [`car policy-check-hook`](#car-policy-check-hook) (evaluate a host's proposed tool call against `.car/policies/` for that host's hook decision envelope), [`car ui`](#car-ui) (open the browser dashboard served by the daemon), [`car project`](#car-project) (manage CAR-managed, git-backed workspaces), [`car init`](#car-init) (initialize a `.car/` project directory), [`car browse`](#car-browse) (browser automation through the runtime), [`car schedule`](#car-schedule) (schedule commands on a cadence via launchd / cron / schtasks). --- ## All commands | Command | Description | |---|---| | [`car info`](#car-info) | Show runtime and live machine state | | [`car capabilities`](#car-capabilities) | Print the deterministic CAR capability manifest | | [`car ui`](#car-ui) | Open the browser dashboard served by the daemon | | [`car verify`](#car-verify) | Statically verify a proposal | | [`car simulate`](#car-simulate) | Simulate a proposal's state effects without executing | | [`car optimize`](#car-optimize) | Optimize a proposal (remove phantom dependencies) | | [`car replay`](#car-replay) | Replay an event journal and show reconstructed state | | [`car run-cancel`](#car-run-cancel) | Cancel one active CAR run and print its deterministic durable receipt | | [`car run-task`](#car-run-task) | Run a goal autonomously against stdio MCP tool servers, emitting a JSONL transcript. Headless entry point for external eval harnesses | | [`car tools`](#car-tools) | Invoke CAR's built-in runtime tools directly, in-process and without a daemon | | [`car code-task`](#car-code-task) | Run a coder session headlessly and IN THIS PROCESS: derive or accept an outcome contract, work in a git worktree until the runtime's own re-run of that contract is green, then deliver the result as a pull request | | [`car coder-ab`](#car-coder-ab) | A/B-test CAR's coder against an external agent (Codex / Claude Code) over a corpus, and grow that corpus from git history — the productionized dogfooding loop (docs/proposals/coder-ab-dogfood.md) | | [`car keys`](#car-keys) | Store cloud-provider API keys in the OS keychain, so a native-app user never sets an environment variable (docs/proposals/native-secrets-no-env.md). The key is read env-first, keychain-fallback by the runtime | | [`car heal`](#car-heal) | Inspect and operate the daemon's self-healing REPAIR loop: it reads a configured issue tracker, runs a coder session, gates the result on a multi-model panel, and opens a pull request. It never merges | | [`car selfheal`](#car-selfheal) | Inspect and operate the daemon's deterministic self-healing detector | | [`car daemon`](#car-daemon) | Start the daemon server (delegates to car-server binary) | | [`car models`](#car-models) | Manage local inference models | | [`car setup`](#car-setup) | Set up the right model for this machine — detect hardware, recommend, and install. Run with no flags for an interactive walkthrough | | [`car speech`](#car-speech) | Manage CAR speech runtime, health checks, and smoke tests | | [`car infer`](#car-infer) | Run text generation with a local model | | [`car image`](#car-image) | Generate an image with a local MLX model | | [`car video`](#car-video) | Generate a video with a local MLX model | | [`car embed`](#car-embed) | Generate embeddings for text | | [`car skills`](#car-skills) | Manage learned skills (SkillRL-inspired) | | [`car reason`](#car-reason) | Reason about code: diagnose, suggest fixes, explain | | [`car eval`](#car-eval) | Evaluate agent improvement from stored trajectories | | [`car identity`](#car-identity) | Show or change the name your assistant answers to — in conversation, in the host apps, and as its voice wake word | | [`car init`](#car-init) | Initialize a .car/ project directory for team-shared configuration | | [`car doctor`](#car-doctor) | Diagnose (and optionally repair) a CAR install: corrupt model weights, unparseable `~/.car` state files, version skew, and leftover files from a previous install. Runs entirely against the local filesystem — no daemon required, so it works even when `car-server` won't start | | [`car feedback`](#car-feedback) | Report a problem to Parslee. Captures a redacted diagnostic bundle (your description, the `car doctor` report, bounded log tails, and a version stamp) into the local outbox at `~/.car/feedback-outbox` — nothing is uploaded by this command; queued reports send when CAR can reach Parslee. Works with the daemon down, like `car doctor`. macOS-only in this release | | [`car update`](#car-update) | Update the locally-installed `car` CLI and its sibling `car-server` daemon to the latest release (or `--version `), in place — regardless of how they were installed. Reconciles the drift that otherwise builds up when one channel updates and another doesn't (e.g. CarHost.app auto-updates its bundled daemon via Sparkle but leaves the `/usr/local/bin/car` CLI behind). The npm/PyPI `car-runtime` client packages are separate — this command never touches them; `car doctor` reports which of your agents have drifted, and prints the exact command per environment. Both remedies pin: `npm install car-runtime@` (`npm update` CANNOT cross a 0.x minor — npm reads `^0.41.0` as `>=0.41.0 <0.42.0`, so it is a no-op) and `/bin/python -m pip install -U car-runtime==` (a bare `-U` can be silently defeated by the consumer's own pin, and the wrong interpreter installs into an environment that does not hold the stale wheel) | | [`car purge`](#car-purge) | Remove this CAR install's own state under `~/.car` (config, logs, managed models, binaries) and reap any OS-level schedules CAR installed — for a clean slate before a reinstall. On macOS this also clears CarHost.app's user-level state and resets its privacy (TCC) permissions, so a reinstall really does re-run permission onboarding. NEVER touches the shared HuggingFace model cache (other tools use it); managed models are symlinks into it, so only the links are removed, not the multi-GB blobs. (To uninstall a single contributed agent instead, use `car uninstall `.) | | [`car code`](#car-code) | Built-in coding agent: state an intent, confirm the verifiable outcome contract, and CAR delivers it in an isolated git worktree — natively or via an installed frontier CLI. Results land on a `car/coder/` branch after your approval; your checkout is never touched | | [`car board`](#car-board) | Fullscreen supervision board for coder sessions — one screen for every run on this host, whoever started it (`car code`, CarHost, milo, another board). Attach to a run's full history, confirm its outcome contract, answer its questions, approve its diff, or scope work in a repo-grounded discussion first. Closing the board never stops a run | | [`car do`](#car-do) | CAR Assistant: a general-purpose agent that works out of the box | | [`car policy-check-hook`](#car-policy-check-hook) | Evaluate a host's proposed tool call against `.car/policies/` and answer on stdout with that host's hook decision envelope | | [`car project`](#car-project) | Manage CAR-managed projects (a named, git-backed workspace CAR creates for you — no repo to pick) | | [`car parslee`](#car-parslee) | Parslee platform capabilities for the signed-in account (requires `car auth login`) | | [`car agent`](#car-agent) | Build and run in-daemon agents from plain-language descriptions. An agent runs inside CAR — nothing to install | | [`car build`](#car-build) | Build a runnable workflow from a natural-language goal | | [`car dream`](#car-dream) | Run memory consolidation ("dream") — prune, GC, embed, evolve | | [`car browse`](#car-browse) | Browser automation — drive Chromium through the CAR runtime | | [`car secrets`](#car-secrets) | OS-native secret store — Keychain / Credential Manager / Secret Service. Aliased as `secret` (singular) for backward compatibility | | [`car auth`](#car-auth) | Parslee account authentication for CAR cloud-backed features | | [`car permissions`](#car-permissions) | OS permission preflight — TCC / Windows Privacy / xdg-desktop-portal | | [`car voice`](#car-voice) | Voiceprint enrollment — teach CAR your voice so it knows who's speaking (the owner drives commands; other voices are context). Proxies the daemon's `voice.*` surface | | [`car onboard`](#car-onboard) | Onboarding readiness — what's set up and what's still pending (the headless equivalent of the CarHost setup wizard) | | [`car approvals`](#car-approvals) | Agent approval policy — the default posture for what agents may do without asking. Proxies the daemon's `agent_permissions.*` surface (the CLI counterpart to the CarHost "Approvals" settings / onboarding step) | | [`car accounts`](#car-accounts) | OS-native account discovery — Internet Accounts / WAM / GOA | | [`car cal`](#car-cal) | OS-native Calendar integration | | [`car contacts`](#car-contacts) | OS-native Contacts integration | | [`car mail`](#car-mail) | OS-native Mail integration | | [`car messages`](#car-messages) | OS-native Messages integration | | [`car notes`](#car-notes) | macOS Notes integration | | [`car reminders`](#car-reminders) | macOS Reminders integration | | [`car photos`](#car-photos) | macOS Photos integration | | [`car bookmarks`](#car-bookmarks) | Browser bookmark integration | | [`car files`](#car-files) | Account-backed file locations | | [`car keychain`](#car-keychain) | OS keychain integration | | [`car health`](#car-health) | Wearable / activity data (HealthKit + Fitbit/Garmin/Oura/etc.) | | [`car install`](#car-install) | Install a contributed agent — from a local directory OR a registry reference (Parslee-ai/car#182 phases 4 + 5) | | [`car ls`](#car-ls) | List every installed contributed agent (Parslee-ai/car#182 phase 4). Calls the daemon's `agents.list` and renders the result. Long alias: `agents` | | [`car inspect`](#car-inspect) | Inspect a single installed agent (Parslee-ai/car#182 phase 4). Shows the on-disk manifest plus the supervisor's current status. Resolves unqualified names to the highest installed semver per the contributed-agents proposal | | [`car start`](#car-start) | Start an installed contributed agent | | [`car stop`](#car-stop) | Stop an installed contributed agent | | [`car restart`](#car-restart) | Restart an installed contributed agent | | [`car tail-log`](#car-tail-log) | Tail the most recent stdout/stderr lines captured from a supervised agent (Parslee-ai/car#231 §5.2). Calls the daemon's `agents.tail_log`. Closes the DX gap where the daemon captured logs to `~/.car/logs/` (`%USERPROFILE%\.car\logs\` on Windows) but offered no CLI surface to read them. Long alias: `logs` | | [`car uninstall`](#car-uninstall) | Uninstall a contributed agent (Parslee-ai/car#182 phase 4). Stops the running child if any, removes the manifest from `~/.car/agents//`, and reaps the legacy `agents.json` entry. Idempotent | | [`car schedule`](#car-schedule) | Schedule commands to run on a cadence (launchd / cron / schtasks) | | [`car registry`](#car-registry) | Registry tooling for the contributed-agents registry (Parslee-ai/car#182 phase 5): `digest` a manifest, or `validate` a registry directory (the CI gate run by Parslee-ai/car-agent-registry) | | [`car fleet`](#car-fleet) | What every CAR instance you can reach can do — agents, capabilities and models across the fleet — and whether this machine takes coding subtasks farmed out by peers (`car fleet enroll`). Needs a running daemon | | [`car publish`](#car-publish) | Publish a contributed agent to the registry (Parslee-ai/car#182 phase 5). Reads a local agent's `manifest.toml`, signs it for `--audience public` (ed25519 key at `$CAR_PUBLISH_KEY_PATH`), stages it at the versioned `agents////` path, updates `index.json` + the README catalog, re-runs the EXACT `car registry validate` CI gate locally, and opens a PR against the registry repo. Aborts (no PR) on a missing signing key or a validation failure | | [`car help`](#car-help) | Print this message or the help of the given subcommand(s) | --- ## Command reference Full `--help` output for every command, generated directly from the binary. ### car info ```text Show runtime and live machine state Usage: car info [OPTIONS] Options: --json Emit machine-readable JSON -h, --help Print help ``` ### car capabilities ```text Print the deterministic CAR capability manifest Usage: car capabilities [OPTIONS] Options: --json Emit machine-readable JSON --md Emit generated Markdown (the default) --role Print exactly the daemon method names assigned to this caller role [possible values: agent, owner, operator, host] -h, --help Print help ``` ### car ui ```text Open the browser dashboard served by the daemon Usage: car ui [OPTIONS] Options: -p, --port Daemon WS port; the dashboard is served on this + 1 [default: 9100] -h, --help Print help ``` ### car verify ```text Statically verify a proposal Usage: car verify [OPTIONS] Arguments: Path to proposal JSON file Options: --state Path to initial state JSON file --tools Comma-separated tool names -h, --help Print help ``` ### car simulate ```text Simulate a proposal's state effects without executing Usage: car simulate [OPTIONS] Arguments: Path to proposal JSON file Options: --state Path to initial state JSON file -h, --help Print help ``` ### car optimize ```text Optimize a proposal (remove phantom dependencies) Usage: car optimize Arguments: Path to proposal JSON file Options: -h, --help Print help ``` ### car replay ```text Replay an event journal and show reconstructed state Usage: car replay Arguments: Path to JSONL journal file Options: -h, --help Print help ``` ### car run-cancel ```text Cancel one active CAR run and print its deterministic durable receipt Usage: car run-cancel [OPTIONS] --run-id --idempotency-key --reason Options: --run-id --idempotency-key --reason --url [default: ws://127.0.0.1:9100/] --json -h, --help Print help ``` ### car run-task ```text Run a goal autonomously against stdio MCP tool servers, emitting a JSONL transcript. Headless entry point for external eval harnesses Usage: car run-task [OPTIONS] --goal-file --mcp-config --transcript --model Options: --goal-file File whose contents are the task instruction --mcp-config JSON file listing the stdio MCP servers to expose as tools --transcript Where to write the JSONL transcript --eventlog Where to write the engine event journal (optional) --max-turns Hard cap on agent loop turns [default: 100] --model Inference model id (resolved by CAR's registry/router) --resume Resume from a checkpoint next to the transcript if one exists (survives a crash / SIGKILL / VM-host restart mid-run) --gui-subagent Route GUI (mcp_cua_*) tools through a delegate_gui sub-agent instead of exposing them to the main model (also via CAR_RUNTASK_GUI_SUBAGENT=1) -h, --help Print help ``` ### car tools ```text Invoke CAR's built-in runtime tools directly, in-process and without a daemon Usage: car tools Commands: call Invoke one CAR built-in tool in this process; no daemon is contacted help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car tools call ```text Invoke one CAR built-in tool in this process; no daemon is contacted Usage: car tools call [OPTIONS] Arguments: Built-in tool name (for example: calculate, read_file, or grep_files) Options: --params-file Read the tool's JSON parameter object from this file --params Supply the tool's JSON parameter object inline -h, --help Print help ``` ### car code-task ```text Run a coder session headlessly and IN THIS PROCESS: derive or accept an outcome contract, work in a git worktree until the runtime's own re-run of that contract is green, then deliver the result as a pull request. No daemon is contacted and none needs to be running — this drives `car_server_core::coder` as a library. `car code` is the interactive twin, and it does go through the daemon. Usage: car code-task [OPTIONS] --repo Options: --repo Repository to work in (must be a git repo) --intent-file File whose contents are the intent. Exactly one of --intent-file/--intent --intent Inline intent. Exactly one of --intent-file/--intent --contract-file JSON `OutcomeContract`. When present, contract derivation does not run --target-branch Stable delivery branch. Required for `--deliver pr` --pr-base PR base branch. Defaults to the repo's default branch --body-prefix Trusted caller-supplied text placed at the start of the pull-request body --draft Open the pull request as a draft --deliver pr | branch | none. Defaults to `pr` when --target-branch is given, else `branch` Possible values: - pr: Push the delivery branch and reconcile exactly one pull request for it - branch: Create a local `car/coder/` branch in the repo and stop there - none: Verify only. Nothing leaves the worktree --model Pin the inference model for this session --max-iterations Override the coder config's iteration ceiling (default 8) --browser Expose the assistant's browser tools for this run. Off by default; calls remain policy-gated and appear in the JSONL event stream --max-session-wall-secs Override the coder config's session wall clock (default 3600). 0 = unlimited --max-check-timeout-secs Ceiling for ONE contract check's command (default 600). Raise it for a verification gate that legitimately runs longer than ten minutes; the model's own `shell` tool keeps the 600s ceiling regardless --workspace-dir Explicit workspace location. Reused when it is already a valid worktree --keep-workspace Keep the workspace on any non-zero exit (and on a green `--deliver none` run, where the worktree is the only copy), for the next round to reuse --transcript Also mirror the JSONL event stream to this file --json Emit the JSONL event stream on stdout, one compact object per line -h, --help Print help (see a summary with '-h') ``` ### car coder-ab ```text A/B-test CAR's coder against an external agent (Codex / Claude Code) over a corpus, and grow that corpus from git history — the productionized dogfooding loop (docs/proposals/coder-ab-dogfood.md) Usage: car coder-ab Commands: run Run the paired A/B over a corpus manifest, verify each arm against the task's own contract, and write a JSON report. Exits non-zero when CAR is significantly *behind* the external arm (McNemar), so it doubles as a CI regression gate. Needs a running daemon (`car code` routes to it) extract Grow the corpus from a git repo's history: for each recent commit that fixes code AND touches a test, materialize the pre-fix (failing) state as a task (parent's source + the commit's test), keep only tasks whose test actually fails at that state, and append them to a corpus. Best-effort candidate generation for human review help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car coder-ab run ```text Run the paired A/B over a corpus manifest, verify each arm against the task's own contract, and write a JSON report. Exits non-zero when CAR is significantly *behind* the external arm (McNemar), so it doubles as a CI regression gate. Needs a running daemon (`car code` routes to it) Usage: car coder-ab run [OPTIONS] --corpus Options: --corpus Corpus manifest (JSONL of tasks; see bench/coder-ab/README.md) --external External comparison engine (codex | claude-code | gemini). Omit to run native-only --model Pin CAR's arm to a backbone, as a CAR model id (e.g. parslee/reasoning). Backbone choice is ~3x the harness spread, so an unpinned run measures the model, not the runtime. NOT forwarded to an external arm — a CAR id means nothing to another CLI; use --external-model for that arm --external-model Pin the external arm's backbone, in THAT CLI's own id namespace (e.g. gpt-5.5 for `codex -m`). Omit and the CLI uses its own configured default — the report then says UNPINNED, since the backbone is unverified. For a fair same-backbone A/B pass both flags naming the same model (--model parslee/reasoning --external-model gpt-5.5); to measure the cross-tier diagonal name different tiers (--model openai/gpt-5.4 --external-model gpt-5.5). Differing pins are reported as DIFFERENT PINS and are NOT a harness delta --iters Native arm's repair-iteration cap per task. Defaults to the coder's OWN shipping default, so the A/B measures the coder users actually get — it used to hardcode 4, i.e. half of it. Raise it when the cap binds: a weaker backbone needs more rounds, and a run whose losses all end at `iteration N/N` is measuring this number, not the harness (at gpt-5.4, 4 → 45% and 20 → 75%, every loss cap-bound at both). The external arm is not capped by this — it gets its CLI's own turn budget (`max_turns: 50` per invocation), so setting this low is a silent handicap [default: 8] --out-dir Directory for the timestamped JSON report [default: bench/results/coder-ab] --timeout-secs Per-task wall bound (seconds) for the NATIVE arm before it's infra. The native reasoning loop can legitimately take many minutes [default: 900] --external-timeout-secs Per-task wall bound (seconds) for the EXTERNAL arm (Codex/Claude Code). An external CLI finishes fast or is stuck, so keep this well below `--timeout-secs` — a stuck external run otherwise burns the native budget and drags the whole suite [default: 300] --limit Run at most this many not-yet-scored tasks, then stop (the rest resume on the next run). Omit to run all remaining. `--limit 1` runs one task so you can inspect it and fix what it surfaces before continuing --fresh Ignore any existing checkpoint for this corpus and re-score from scratch --report-issues File each durable-fix proposal that clears the reporting bar as an issue on --report-repo, skipping signatures already open there. Off by default: a measurement run must not open issues on a shared tracker as a side effect --report-repo Where --report-issues files. The releases repo by default, not the source repo — filing a defect report needs no source checkout [default: Parslee-ai/car-releases] -h, --help Print help ``` #### car coder-ab extract ```text Grow the corpus from a git repo's history: for each recent commit that fixes code AND touches a test, materialize the pre-fix (failing) state as a task (parent's source + the commit's test), keep only tasks whose test actually fails at that state, and append them to a corpus. Best-effort candidate generation for human review Usage: car coder-ab extract [OPTIONS] --out Options: --repo Repo to mine (default: current dir) [default: .] --out Corpus directory to write (`manifest.jsonl` + `tasks//`) --test-cmd Command that verifies a task (the contract check), run in each task dir. `pytest -q` rather than `python3 -m pytest -q`: `python3` does not exist on a standard Windows python.org install, and `python` is often absent on macOS/Linux — pytest's console script is the portable spelling [default: "pytest -q"] --path Only mine commits touching paths under this prefix --max Limit to this many recent commits scanned [default: 50] --max-files Skip a commit whose changed-file count exceeds this (keep tasks small) [default: 6] --full-tree Materialize the FULL pre-fix source tree into each task (not just the changed files), so a package-structured repo's sibling imports resolve and the test fails on the real bug — not a `ModuleNotFoundError`. Recommended for any repo whose modules import each other --subject-filter Keep only commits whose subject contains this substring (e.g. `fix(`). On a Rust repo this is close to required: a `feat` commit's test imports a symbol the commit itself adds, so it cannot compile at the pre-fix parent. Such tasks are rejected anyway, but only after a full tree materialize + build, which costs 30-200s each. -h, --help Print help (see a summary with '-h') ``` ### car keys ```text Store cloud-provider API keys in the OS keychain, so a native-app user never sets an environment variable (docs/proposals/native-secrets-no-env.md). The key is read env-first, keychain-fallback by the runtime Usage: car keys Commands: set Store a provider key in the keychain. `` is a provider (openai/anthropic/gemini/elevenlabs/github/aws) or a raw env-var name. Omit `` to read it from stdin (keeps it out of shell history) list Show which provider keys are configured (keychain or env); values hidden remove Remove a stored provider key from the keychain help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car keys set ```text Store a provider key in the keychain. `` is a provider (openai/anthropic/gemini/elevenlabs/github/aws) or a raw env-var name. Omit `` to read it from stdin (keeps it out of shell history) Usage: car keys set [VALUE] Arguments: [VALUE] Options: -h, --help Print help ``` #### car keys list ```text Show which provider keys are configured (keychain or env); values hidden Usage: car keys list Options: -h, --help Print help ``` #### car keys remove ```text Remove a stored provider key from the keychain Usage: car keys remove Arguments: Options: -h, --help Print help ``` ### car heal ```text Inspect and operate the daemon's self-healing REPAIR loop: it reads a configured issue tracker, runs a coder session, gates the result on a multi-model panel, and opens a pull request. It never merges. Configured in `/heal.toml`; off by default, and an issue must carry an explicit opt-in label. See `car selfheal` for the separate watch-only detector, which never writes. Usage: car heal Commands: status Show whether the loop is enabled — and if not, why — plus its targets, review panel, and engine run Run one sweep now instead of waiting for the cadence help Print this message or the help of the given subcommand(s) Options: -h, --help Print help (see a summary with '-h') ``` #### car heal status ```text Show whether the loop is enabled — and if not, why — plus its targets, review panel, and engine Usage: car heal status Options: -h, --help Print help ``` #### car heal run ```text Run one sweep now instead of waiting for the cadence. At most one item per configured target. This can run a real coder session and open a real pull request. It never merges. Usage: car heal run Options: -h, --help Print help (see a summary with '-h') ``` ### car selfheal ```text Inspect and operate the daemon's deterministic self-healing detector Usage: car selfheal Commands: status Show cadence, active counts, and the route resolved by the last tick list List active detections, optionally filtered by kind, severity, or time show Print the trusted local issue document for one detection dismiss Dismiss one active detection by dedup key fix Start one bounded coder round for an eligible recurring-tool key run Run one deterministic detection tick and its auto-fix cadence hook now help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car selfheal status ```text Show cadence, active counts, and the route resolved by the last tick Usage: car selfheal status Options: -h, --help Print help ``` #### car selfheal list ```text List active detections, optionally filtered by kind, severity, or time Usage: car selfheal list [OPTIONS] Options: --kind Detection kind (metrics_alert, agent_gave_up, agent_log_error, agent_silently_idle, recurring_tool_failure, capability_miss) --severity Severity (warning or critical) --since Only detections observed at or after this RFC3339 timestamp -h, --help Print help ``` #### car selfheal show ```text Print the trusted local issue document for one detection Usage: car selfheal show Arguments: Detection SHA-256 dedup key Options: -h, --help Print help ``` #### car selfheal dismiss ```text Dismiss one active detection by dedup key Usage: car selfheal dismiss Arguments: Detection SHA-256 dedup key Options: -h, --help Print help ``` #### car selfheal fix ```text Start one bounded coder round for an eligible recurring-tool key Usage: car selfheal fix Arguments: Detection SHA-256 dedup key Options: -h, --help Print help ``` #### car selfheal run ```text Run one deterministic detection tick and its auto-fix cadence hook now Usage: car selfheal run Options: -h, --help Print help ``` ### car daemon ```text Start the daemon server (delegates to car-server binary) Usage: car daemon [OPTIONS] Options: -p, --port Port to listen on [default: 9100] -h, --help Print help ``` ### car models ```text Manage local inference models Usage: car models Commands: list List available models and download status discover Discover models exposed by a running vLLM-MLX server pull Download a model resource-policy Inspect or update the local-model RAM policy preflight Evaluate one local model without downloading or loading it adopt Adopt an already-usable local artifact into CAR ownership recommend Recommend the best model for this machine and what you want to do remove Remove a downloaded model upgrades Show installed models that have curated newer replacements upgrade Upgrade installed models to curated newer replacements when CAR can do so serve Start an external MLX runtime for a cataloged local-server model add Add any HuggingFace model by repo id, deriving its schema automatically register Register a custom model from a JSON schema file unregister Unregister a model by ID stats Show performance stats for models based on observed outcomes benchmark Benchmark curated models and write benchmark priors for cold-start routing doctor Report configured defaults, provider health, and modality coverage smoke Run representative live model checks across text, code, tool, vision, and speech route Route a prompt and show which model would be selected (dry run) help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car models list ```text List available models and download status Usage: car models list [OPTIONS] Options: -c, --capability Filter by capability (generate, embed, code, reasoning, etc.) --provider Filter by provider (e.g., openai, qwen, google, vllm-mlx) --local-only Only show local models --all Show every row, including models that do not fit this machine and deprecated ones (hidden by default), with a FIT column explaining why -h, --help Print help ``` #### car models discover ```text Discover models exposed by a running vLLM-MLX server Usage: car models discover [OPTIONS] Options: --json Output as JSON -h, --help Print help ``` #### car models pull ```text Download a model Usage: car models pull Arguments: Model name (e.g., Qwen3-0.6B, Qwen3-1.7B) Options: -h, --help Print help ``` #### car models resource-policy ```text Inspect or update the local-model RAM policy Usage: car models resource-policy Commands: get Show the saved policy and its evaluated machine budget set Persist a policy. Custom values are exact MB in 512 MB increments help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car models preflight ```text Evaluate one local model without downloading or loading it Usage: car models preflight [OPTIONS] Arguments: Options: --context-tokens [default: 0] -h, --help Print help ``` #### car models adopt ```text Adopt an already-usable local artifact into CAR ownership Usage: car models adopt Arguments: Options: -h, --help Print help ``` #### car models recommend ```text Recommend the best model for this machine and what you want to do Usage: car models recommend [OPTIONS] Options: --for What you'll use it for: assistant, coding, search, vision, transcription, summarize [default: assistant] --tier Speed/quality: fastest, balanced, most-capable [default: balanced] --cloud-ok Allow cloud models to compete (default: on-device only) -h, --help Print help ``` #### car models remove ```text Remove a downloaded model Usage: car models remove Arguments: Model name Options: -h, --help Print help ``` #### car models upgrades ```text Show installed models that have curated newer replacements Usage: car models upgrades [OPTIONS] Options: --json Output as JSON -h, --help Print help ``` #### car models upgrade ```text Upgrade installed models to curated newer replacements when CAR can do so Usage: car models upgrade [OPTIONS] Options: --apply Actually perform supported downloads/removals. Without this, print a plan --remove-old Remove the older local model after a replacement is available --json Output as JSON -h, --help Print help ``` #### car models serve ```text Start an external MLX runtime for a cataloged local-server model Usage: car models serve [OPTIONS] Arguments: Model id, short alias, or Hugging Face repo to serve Options: --port Port for the OpenAI-compatible local server [default: 8000] --dry-run Print the command without starting the server --json Output as JSON -h, --help Print help ``` #### car models add ```text Add any HuggingFace model by repo id, deriving its schema automatically Reads the repo's `config.json` and picks the right backend for you: architectures with an in-process Rust MLX backend register as native, everything else routes to the supervised vLLM-MLX runtime. This is the path that does NOT require a CAR release to adopt a new model. Usage: car models add [OPTIONS] Arguments: HuggingFace repo id, e.g. `mlx-community/Qwen3.8-27B-4bit` Options: --dry-run Show the derived schema without registering it --pull Download the weights now instead of on first use -h, --help Print help (see a summary with '-h') ``` #### car models register ```text Register a custom model from a JSON schema file Usage: car models register Arguments: Path to model schema JSON file Options: -h, --help Print help ``` #### car models unregister ```text Unregister a model by ID Usage: car models unregister Arguments: Model ID (e.g., "anthropic/claude-sonnet-4-6:latest") Options: -h, --help Print help ``` #### car models stats ```text Show performance stats for models based on observed outcomes Usage: car models stats [ID] Arguments: [ID] Model ID (omit for all models) Options: -h, --help Print help ``` #### car models benchmark ```text Benchmark curated models and write benchmark priors for cold-start routing Usage: car models benchmark [OPTIONS] Options: --json Output as JSON --models Optional comma-separated model names to benchmark --cases Optional comma-separated benchmark case ids --judge-model Optional judge model override -h, --help Print help ``` #### car models doctor ```text Report configured defaults, provider health, and modality coverage Usage: car models doctor [OPTIONS] Options: --json Output as JSON --mlx Only report MLX runtime/tooling diagnostics -h, --help Print help ``` #### car models smoke ```text Run representative live model checks across text, code, tool, vision, and speech Usage: car models smoke [OPTIONS] Options: --json Output as JSON --dry-run Only validate routing/orchestration without making live model calls -h, --help Print help ``` #### car models route ```text Route a prompt and show which model would be selected (dry run) Usage: car models route Arguments: Prompt to route Options: -h, --help Print help ``` ### car setup ```text Set up the right model for this machine — detect hardware, recommend, and install. Run with no flags for an interactive walkthrough Usage: car setup [OPTIONS] Options: --use-case What you'll mainly do: assistant, coding, search, vision, transcription, summarize. Prompted if omitted --tier Speed/quality preference: fastest, balanced, most-capable [default: balanced] --cloud-ok Allow cloud models to compete (default: on-device only) --yes Don't prompt — accept the top recommendation. For scripts/CI -h, --help Print help ``` ### car speech ```text Manage CAR speech runtime, health checks, and smoke tests Usage: car speech Commands: install Install the managed speech runtime and curated local speech models doctor Report managed speech runtime, local model cache, and remote-provider health smoke Run end-to-end speech smoke tests through CAR help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car speech install ```text Install the managed speech runtime and curated local speech models Usage: car speech install [OPTIONS] Options: --json Output as JSON -h, --help Print help ``` #### car speech doctor ```text Report managed speech runtime, local model cache, and remote-provider health Usage: car speech doctor [OPTIONS] Options: --json Output as JSON -h, --help Print help ``` #### car speech smoke ```text Run end-to-end speech smoke tests through CAR Usage: car speech smoke [OPTIONS] Options: --local-only Only run the local speech path --remote-only Only run the remote speech path --json Output as JSON -h, --help Print help ``` ### car infer ```text Run text generation with a local model Usage: car infer [OPTIONS] Arguments: Prompt text Options: -m, --model Model name (default: Qwen3-1.7B) --image Local image path to include for vision-language inference. May be repeated --workload Workload class for routing: interactive, batch, or background [default: interactive] --max-tokens Max tokens to generate [default: 512] --temperature Temperature (0.0 = greedy) [default: 0.7] --thinking Qwen3 thinking mode: `off` injects `/no_think` and prefills a closed `` block (direct answer, no reasoning); `on` injects `/think` (force reasoning); `auto` trusts the model's trained default. CLI defaults to `off` because Qwen3's trained default is reasoning-on, which chews through small `--max-tokens` budgets inside an unclosed `` block and makes the post-strip text empty (issue #168). Set `auto` or `on` for tasks that actually want reasoning, and pair with a larger `--max-tokens` so the model can both think and answer [default: off] -h, --help Print help ``` ### car image ```text Generate an image with a local MLX model Usage: car image [OPTIONS] Arguments: Prompt text Options: -m, --model Model name -o, --output Output path --width Image width --height Image height --steps Sampling steps --guidance CFG / guidance scale --seed Random seed -h, --help Print help ``` ### car video ```text Generate a video with a local MLX model Usage: car video [OPTIONS] Arguments: Prompt text Options: -m, --model Model name -o, --output Output path --width Video width --height Video height --frames Number of frames --steps Sampling steps --guidance CFG / guidance scale --fps Frames per second --seed Random seed --image Reference image for image-to-video (first frame anchor) --audio-video Enable joint audio+video synthesis (text-to-(video+audio)) --audio