{% 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.57.0-nightly.20261009 (2026-10-09). 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`. > > 79 top-level commands, 158 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 79 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 Run `car code` in a repository to open a conversation. Ask questions or describe a change, then use `/build` to draft an editable task and review its checks. `/help` shows controls, `/sessions` opens coding session history (`d` returns to the conversation), and `/quit` exits. Running tasks survive closing the terminal. Resume a saved discussion with `car code --resume ` from the same repository; the exit summary prints its id. An explicit task or execution flags such as `--engine` select the single-task flow. Delivered revisions remain available as the base for follow-up conversation tasks. - [`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). Apply reviewed results to your checkout, preserving HEAD and the staged index, or explicitly request `--delivery branch` to publish a result branch. - [`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 evaluate-contract`](#car-evaluate-contract) | Evaluate a pinned outcome contract without a model, coding loop, or delivery | | [`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 coder`](#car-coder) | Manage operator-controlled repository trust for CarCoder | | [`car coder-overlays`](#car-coder-overlays) | Show the approved harness overlays — system-prompt and tool-description text applied through `evolution.run` — that every native coder session starts with, or clear them. Nothing removes an applied overlay on its own; `--clear` is how one is taken out of force. Reads the local coder state directory; no daemon needed | | [`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). Runtime reads process env first, then `$CAR_HOME/env`, then keychain | | [`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 concierge`](#car-concierge) | Your local models' concierge: what each model is doing, what it would change and what it did on its own. Without a subcommand, prints the facts (no model involved) | | [`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 and Windows; Linux needs its own leak-path audit first | | [`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) | Open a coding conversation in your repository. Ask questions, plan a change, or describe work to implement; review the checks and edits, then keep iterating in the same conversation | | [`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 lattice`](#car-lattice) | The CAR Lattice: agents, coding sessions, and people on this daemon that find each other by capability. Register yourself as a human node, see what is being asked of you, and answer it. Uses the local host credential, so it acts as this machine's operator | | [`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 mp`](#car-mp) | Multiplayer development: a work item moves Build → Improve → Polish through different developers before it merges, each stage a coder session on its owner's machine with the engine they choose. Needs a running daemon and a shared git remote | | [`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 evaluate-contract ```text Evaluate a pinned outcome contract without a model, coding loop, or delivery Usage: car evaluate-contract [OPTIONS] --repo --contract-file --expected-commit --expected-contract-sha256 --evidence-dir --max-check-timeout-secs Options: --repo Clean repository whose checks run. Ignored and untracked inputs are refused --contract-file Operator-supplied OutcomeContract JSON (raw bytes are pinned) --expected-commit Exact full Git commit object ID, not a movable ref --expected-contract-sha256 SHA-256 of the exact contract-file bytes --evidence-dir New directory outside the repository; must not already exist --max-check-timeout-secs Positive wall-clock ceiling for each check --container-runtime Trusted absolute OCI runtime executable. Requires an exact cached image --container-image Exact cached Linux image ID (sha256:...), selected by the verifier host -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 Set an explicit operator iteration cap. The default is unbounded; 0 is unbounded. A capped run ends `budget_exhausted`, naming usage and cap --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 Set an explicit operator session wall-clock cap. The default is unbounded; 0 is unbounded. A capped run ends `budget_exhausted`, naming elapsed time and cap --max-check-timeout-secs Set an explicit operator cap for one contract check. The default is unbounded. A check that reaches the cap is killed and judged red; the model's own `shell` tool keeps its separate ceiling regardless --silence-window-secs Stop the run when nothing makes progress for this many seconds (default 900; 0 disables). This is the only time-based stop: a check that prints nothing for this long is killed and judged red, and a session silent this long ends `failed` with `failure_kind: "stalled"`, naming what it was waiting on --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) rescore Re-score one delivered attempt without starting a coding session ledger Inspect or validate the append-only replay-attempt ledger distill Contrast CAR's trajectories with the reference arm's (Codex / Claude Code) over a finished A/B report, and name candidate behaviors CAR is missing — each with its invariant and the cheapest CAR mechanism to try. Reads the arm journals the report points at; no inference, no network judge-replay Ask a generative model and Jev (TypeSafe's System One model, through Parslee) the same code-review judgment over test-labeled diffs, offline. Build candidates first with bench/coder-ab/judge-replay/build_candidates.py; score the output with analyze.py beside it. See docs/proposals/system-one-decisions.md judge-select Show a generative model and Jev (through Parslee) a set of candidate diffs for one task and ask which to merge, offline. Build sets with bench/coder-ab/judge-replay/build_sets.py; score with analyze_sets.py. See docs/proposals/system-one-decisions.md, Experiment 2 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 unbounded shipping default (`0`), so the A/B measures the coder users actually get. A positive value is an explicit experiment cap; a run whose losses all end at `iteration N/N` is measuring that cap, not the harness. The external arm is not capped by this — it gets its CLI's own configuration (the coder passes no turn cap) [default: 0] --out-dir Directory for the timestamped JSON report [default: bench/results/coder-ab] --timeout-secs Optional per-task wall bound (seconds) for the NATIVE arm; when it fires the attempt is a scored timeout loss and the daemon session is cancelled with the reason `harness wall bound s reached`. Unset by default: the coder's own silence watchdog and no-progress stop end a stuck session, and a fixed wall only measures the wall --external-timeout-secs Optional per-task wall bound (seconds) for the EXTERNAL arm (Codex/Claude Code). Unset by default, like `--timeout-secs`: a timeout is a scored loss, so any wall turns a slow reference into a CAR win (Claude Code on claude-sonnet-5 needed 338s for a flask task it then passed, and a former 300s default scored it as a loss) --allow-external-web Let the external arm keep its CLI's own web access. Off by default: the external arm runs with `car code --isolate-external-network` (no web search or fetch, browser, app connectors or MCP servers; shell without network), because on a corpus mined from a project's history a reference that can reach the web can read the upstream fix --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 --external-clone Declare an external clone a corpus row may point into, as key=path (repeatable). Layered over the corpus's `external-clones.toml`; a row names a clone only by its key in `provenance.external_clone`, never by path, and a clone that holds the bench tree is refused --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] --fix-ref Name the CarCoder fix made since this corpus's previous attempt. Cite the ledger entry it answers in that PR's body --recurrence-of Record that this run answers an earlier attempt of the same task -h, --help Print help ``` #### car coder-ab rescore ```text Re-score one delivered attempt without starting a coding session Usage: car coder-ab rescore [OPTIONS] --attempt --corpus Options: --attempt Existing `/artifacts//` directory --corpus Corpus manifest containing the task named by the source ledger row --ledger Owning ledger. Omit to discover it from the attempt artifact layout -h, --help Print help ``` #### car coder-ab ledger ```text Inspect or validate the append-only replay-attempt ledger Usage: car coder-ab ledger Commands: render Render the append-only replay ledger as Markdown. Writes beside the ledger unless --stdout is supplied check Check that every evidence path named by the ledger still exists help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car coder-ab distill ```text Contrast CAR's trajectories with the reference arm's (Codex / Claude Code) over a finished A/B report, and name candidate behaviors CAR is missing — each with its invariant and the cheapest CAR mechanism to try. Reads the arm journals the report points at; no inference, no network Usage: car coder-ab distill [OPTIONS] --report Options: --report A report written by `car coder-ab run` (bench/results/coder-ab/…json) --min-cells Cells a behavior must separate the arms in before it is a candidate [default: 2] --out-dir Where to write `.distill.{md,json}` (default: beside the report) -h, --help Print help ``` #### car coder-ab judge-replay ```text Ask a generative model and Jev (TypeSafe's System One model, through Parslee) the same code-review judgment over test-labeled diffs, offline. Build candidates first with bench/coder-ab/judge-replay/build_candidates.py; score the output with analyze.py beside it. See docs/proposals/system-one-decisions.md Usage: car coder-ab judge-replay [OPTIONS] --candidates --out --llm-model Options: --candidates Candidates JSONL written by build_candidates.py --out Results JSONL; appended to, and a rerun resumes where it stopped --experiment Experiments to run: 1a (capability probe), 1b (heal-review question) [default: 1a 1b] --llm-model Generative judge; repeat for several. The heal panel has no default --jev-model Jev model; pinned so a result can be reproduced [default: jev-1.13.0] --requests-per-minute Jev request pace. Parslee allows 60/minute per org, shared with everything else the org runs [default: 40] --limit Only the first N candidates (a diagnostic slice) --perturb Also ask each question under context that should not change the answer, plus an identical repeat that measures each judge's own noise --shard Run one slice of the candidates, as `index/count` (e.g. `0/4`); give each shard its own --out and a share of --requests-per-minute --seen Earlier results file whose answers count as done; repeatable -h, --help Print help ``` #### car coder-ab judge-select ```text Show a generative model and Jev (through Parslee) a set of candidate diffs for one task and ask which to merge, offline. Build sets with bench/coder-ab/judge-replay/build_sets.py; score with analyze_sets.py. See docs/proposals/system-one-decisions.md, Experiment 2 Usage: car coder-ab judge-select [OPTIONS] --sets --out --llm-model Options: --sets Sets JSONL written by build_sets.py --out Results JSONL; appended to, and a rerun resumes where it stopped --llm-model Generative judge; repeat for several --jev-model Jev model; pinned so a result can be reproduced [default: jev-1.13.0] --requests-per-minute Jev request pace; Parslee allows 60/minute per org [default: 40] --limit Only the first N sets (a diagnostic slice) -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 coder ```text Manage operator-controlled repository trust for CarCoder Usage: car coder Commands: trust Manage repositories allowed to use the macOS login keychain help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car coder trust ```text Manage repositories allowed to use the macOS login keychain Usage: car coder trust Commands: add Add one trusted repository, replay root, replay-only GitHub owner, or replay-only repository remove Remove one trust entry of any kind list List every trust entry and the file that owns them check Show the live-session trust decision for one repository path help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` ### car coder-overlays ```text Show the approved harness overlays — system-prompt and tool-description text applied through `evolution.run` — that every native coder session starts with, or clear them. Nothing removes an applied overlay on its own; `--clear` is how one is taken out of force. Reads the local coder state directory; no daemon needed Usage: car coder-overlays [OPTIONS] Options: --clear Remove every stored overlay; the next coder session starts without -h, --help Print help ``` ### 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). Runtime reads process env first, then `$CAR_HOME/env`, then keychain 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 concierge ```text Your local models' concierge: what each model is doing, what it would change and what it did on its own. Without a subcommand, prints the facts (no model involved) Usage: car concierge [COMMAND] Commands: ask Ask about your local models; answered from the facts, by a model maintain Run one maintenance pass now (retire, upgrade, clean up) under your update policy rollback Put a lane's default model back to what it was before the concierge's last change (e.g. an automatic upgrade) help Print this message or the help of the given subcommand(s) Options: -h, --help Print help ``` #### car concierge ask ```text Ask about your local models; answered from the facts, by a model Usage: car concierge ask Arguments: The question, e.g. "which models can I delete?" Options: -h, --help Print help ``` #### car concierge maintain ```text Run one maintenance pass now (retire, upgrade, clean up) under your update policy Usage: car concierge maintain [OPTIONS] Options: --dry-run Decide and report, change nothing --json Output as JSON -h, --help Print help ``` #### car concierge rollback ```text Put a lane's default model back to what it was before the concierge's last change (e.g. an automatic upgrade) Usage: car concierge rollback Arguments: The lane: assistant, coding, search, vision, transcription, summarize Options: -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 update-policy Show the update policy, or set it: `auto` keeps local models current and tidy on its own, `notify` only suggests, `off` does nothing. Setting it makes it your explicit choice portfolio Assess every installed local model: protected, idle, superseded, never runs here, … with the evidence, and what retiring each would free. Reads only; asks the running daemon 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 fit CAR's memory-fit verdict for catalog rows on stated Apple Silicon machines, under both the `everyday` and `local_focused` policies — the same rule `models.list_unified` reports, without a machine of each size. Reads a row or an array of rows (as `car models add --dry-run --json` prints) from FILE, or stdin. Prints JSON. The verdict is the recommendation estimate `models.list_unified` shows, which sizes the KV cache from the parameter count; load-time admission uses an installed checkpoint's own KV geometry and the machine's live state, so it can differ 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 classify-bench Compare CAR's `classify` capability against Jev (TypeSafe's System One model, through Parslee) on a human-labeled dataset, offline. Build rows with bench/classify/build_clinc.py; score with bench/classify/analyze.py. See docs/proposals/system-one-decisions.md, Experiment 3 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 update-policy ```text Show the update policy, or set it: `auto` keeps local models current and tidy on its own, `notify` only suggests, `off` does nothing. Setting it makes it your explicit choice Usage: car models update-policy [POLICY] Arguments: [POLICY] [possible values: auto, notify, off] Options: -h, --help Print help ``` #### car models portfolio ```text Assess every installed local model: protected, idle, superseded, never runs here, … with the evidence, and what retiring each would free. Reads only; asks the running daemon Usage: car models portfolio [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 --json With --dry-run, print the derived schema as JSON — the exact row CAR would register, for a catalog candidate file --pull Download the weights now instead of on first use -h, --help Print help (see a summary with '-h') ``` #### car models fit ```text CAR's memory-fit verdict for catalog rows on stated Apple Silicon machines, under both the `everyday` and `local_focused` policies — the same rule `models.list_unified` reports, without a machine of each size. Reads a row or an array of rows (as `car models add --dry-run --json` prints) from FILE, or stdin. Prints JSON. The verdict is the recommendation estimate `models.list_unified` shows, which sizes the KV cache from the parameter count; load-time admission uses an installed checkpoint's own KV geometry and the machine's live state, so it can differ Usage: car models fit [OPTIONS] [FILE] Arguments: [FILE] Catalog row JSON file; stdin when omitted Options: --ram-gb Unified-memory sizes to judge, in GB [default: 16,24,32,36,48,64,96,128,192,256,512] -h, --help Print help ``` #### 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 classify-bench ```text Compare CAR's `classify` capability against Jev (TypeSafe's System One model, through Parslee) on a human-labeled dataset, offline. Build rows with bench/classify/build_clinc.py; score with bench/classify/analyze.py. See docs/proposals/system-one-decisions.md, Experiment 3 Usage: car models classify-bench [OPTIONS] --data --labels --out --model Options: --data Rows JSONL ({id, text, label}) --labels JSON array of labels offered for every row --out Results JSONL; appended to, and a rerun resumes where it stopped --model CAR `classify` arm by model id, or `default` to let CAR choose; repeatable --jev-model Jev model; pinned so a result can be reproduced [default: jev-1.13.0] --requests-per-minute Jev request pace; Parslee allows 60/minute per org [default: 40] --limit Only the first N rows (a diagnostic slice) -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