# Archis — command reference Generated from `chi 0.52.0`. This is the same text `chi help ` prints, organised for reading. The narrative documentation lives at . Archis indexes a repository locally and serves compact semantic context to coding agents over MCP. Indexing, retrieval and the dashboard never leave the machine. ## Global options Accepted by every command. - `--json` — Machine-readable output - `--db ` — Knowledge graph to read. Defaults to this repository's `.chi`, found by walking up the way git finds `.git` - `--sessions ` — Session memory to read. Same default as `--db` - `--repo ` — Repository to act on. Defaults to the current one - `--tokenizer ` — Tokenizer to count with (default: `o200k`; one of: `o200k`, `cl100k`) - `--color ` — When to colour the output: `auto` (a terminal, and `NO_COLOR` unset), `always`, or `never` (default: `auto`; one of: `auto`, `always`, `never`) ## Setup and maintenance Getting Archis onto a machine, in front of an agent, and back off again. ### `chi init` Set Archis up here: index the repository and connect your coding agents. Safe to run again — it asks only what is still open, which makes it also the way to connect an agent you installed after Archis. `--machine` does the machine-wide half alone; `--list` says where every step stands and asks nothing. ``` chi init [OPTIONS] ``` **Options** - `--all` — Revisit every step, including the ones already answered - `--list` — Print the steps and where each one stands. Asks nothing - `--yes` — Take every default without waiting for a terminal. For provisioning; the steps that edit tracked files or send anything off the machine default to no and stay no - `--check` — Run the closing checks only — no index, no questions — and exit non-zero when anything needs attention. For CI and hooks - `--profile ` — Answer by profile instead of opening the menu. `basic` takes every default, `full` says yes to everything except usage statistics, `custom` shows the pending steps as a checklist (one of: `basic`, `full`, `custom`) - `--machine` — Only the questions that apply to this machine rather than to this repository — the ones `chi auth login` asks at the end - `-v, --verbose` — Every check and every briefing in full, rather than only what changed and what needs attention - `-q, --quiet` — Print nothing but what changed and what is wrong. For scripts ### `chi status` *Alias: `overview`* Whether Archis is ready here, and what it knows about this repository. The one question somebody has after `chi init`: files and symbols in the graph, when it was last indexed, how many files have drifted since, and which of this repository's languages Archis actually understands. Reads everything and changes nothing. Distinct from its two neighbours on purpose. `chi doctor` is about the *installation* — whether Archis is wired to your agents and what is broken. `chi dashboard` is the history and the UI. This is about the index. ``` chi status [OPTIONS] ``` **Options** - `--languages` — The language capability matrix in full, rather than the summary line - `--lang ` — One language in detail instead of the whole registry - `--coverage` — The per-layer semantic coverage score rather than the capability matrix ### `chi config` Every file Archis has touched on this machine and in this repository, and the command that undoes each one. One row per file: the path, which coding agent it serves, what Archis put there — a hook entry, a briefing block, a skill, an MCP server entry, or one of Archis's own files — whether it is current, from an older release or absent, and how to take it back out. A registration a vendor's own command performed is listed at the file the vendor documents, marked as the vendor's: Archis never opens that file. Reads only, spawns nothing and needs no licence. Bare, it covers the machine and the repository you are in; `--machine` and `--local` pick one half, `--all-repos` walks every repository Archis has indexed here, `--agent` narrows to one coding agent, and `--catalog` describes what `chi agents on` would touch for each agent on any machine, without looking at this one. `--json` returns the same document as data. ``` chi config [OPTIONS] ``` **Options** - `--machine` — Only the machine: the agents' user-level files and Archis's state directory - `--local` — Only this repository. (`--repo `, the global option, is a path and says which one.) - `--all-repos` — Every repository in Archis's registry, one section each - `--agent ` — One coding agent, by id or alias (see `chi agents`) - `--catalog` — What Archis would touch for each agent, on any machine, with nothing read from this one. The source of the documentation's agent pages - `--absent` — Also list the places Archis could write but has not ### `chi agents` Connect Archis to the coding agents on this machine. One command for what used to be four. Bare, it reports every agent: whether its CLI is here, whether Archis's tools are registered with it, whether the hooks are installed, and whether it has been briefed. `chi agents on` arranges all of that; the flags narrow it when you want one piece. ``` chi agents [OPTIONS] [COMMAND] ``` #### `chi agents on` Connect: register Archis's tools, install the hooks, write the briefing ``` chi agents on [OPTIONS] [AGENT] ``` **Arguments** - `[AGENT]` — Agent id (see `chi agents`). Omit to do every agent installed here **Options** - `--mcp` — Only register the MCP server - `--hooks` — Only install the hooks - `--brief` — Only write the briefing - `--project` — Write into this repository rather than your home directory. Those files are usually committed, so it is never the default - `--surface ` — Limit MCP registration to one surface of the agent (`cli`, `ide`, `desktop`, `agents-window`, …). Omit to register every surface present on this machine - `--name ` — Name the harness will show the model (default: `chi`) - `--server-db ` — Knowledge-graph path to bake into the registration. Omit it — the default — and the server finds the repository's `.chi` directory by itself, the way git finds `.git`, so one registration follows the agent from repository to repository. - `--server-sessions ` — Session-memory path to bake in. Same default as `--server-db`, and its id is spelled out for the same reason - `--command ` — Path to the `chi-mcp` binary (default: `chi-mcp`) - `--absolute` — Register absolute paths, so the harness works from any directory - `--base-dir ` — Bind the registration to one repository, for a surface that cannot say which repository a turn is for. - `--workspace-root ` — Authorize a directory whose repositories this agent may ask Archis for, choosing one per call. Repeatable. #### `chi agents off` Disconnect, leaving every file otherwise as it was ``` chi agents off [OPTIONS] [AGENT] ``` **Arguments** - `[AGENT]` — Agent id. Omit to disconnect every one **Options** - `--mcp` — Only remove the MCP registration - `--hooks` — Only remove the hooks - `--brief` — Only remove the briefing - `--project` — Act on this repository's files rather than the ones in your home directory - `--name ` — Registered server name to remove (default: `chi`) #### `chi agents check` Verify a connection end to end: handshake, tool listing, one live call ``` chi agents check [OPTIONS] [AGENT] ``` **Arguments** - `[AGENT]` — Agent id. Omit to check every one that is connected **Options** - `--driver` — Also send probe turns through the agent's CLI as a model. Costs a few hundred tokens against your own account - `--live` — Also run every hook Archis has installed and check that it answers. Costs nothing and touches nothing: the hooks are asked to reply, not to do their work - `--model ` — Model or reasoning effort for `--driver` - `--surface ` — Check one surface of the agent (`cli`, `ide`, `desktop`, `agents-window`, …) instead of every surface present here. Each surface is measured against its own registration - `--name ` — Name the harness will show the model (default: `chi`) - `--server-db ` — Knowledge-graph path to bake into the registration. Omit it — the default — and the server finds the repository's `.chi` directory by itself, the way git finds `.git`, so one registration follows the agent from repository to repository. - `--server-sessions ` — Session-memory path to bake in. Same default as `--server-db`, and its id is spelled out for the same reason - `--command ` — Path to the `chi-mcp` binary (default: `chi-mcp`) - `--absolute` — Register absolute paths, so the harness works from any directory - `--base-dir ` — Bind the registration to one repository, for a surface that cannot say which repository a turn is for. - `--workspace-root ` — Authorize a directory whose repositories this agent may ask Archis for, choosing one per call. Repeatable. #### `chi agents advice` Whether Archis speaks up before an agent reaches for its own file tools. `on` names the cheaper Archis call before a `Read`, `Grep` or `Glob` and never denies anything. `strict` escalates: once a session has been advised and kept going anyway, the call is refused with the Archis call in the reason. Off everywhere by default. Bare prints where it stands. ``` chi agents advice [OPTIONS] [ACTION] ``` **Arguments** - `[ACTION]` — `on`, `off`, `strict`, or `status` to print where it stands. Omitted is `status` (default: `status`; one of: `on`, `off`, `strict`, `status`) **Options** - `--project` — Install into this repository rather than your home directory #### `chi agents auto` Whether agents you install later are connected by themselves. On by default: an agent that appears on this machine gets Archis's tools, the briefing and the skill the next time `chi` runs, and you are told once. `chi agents off ` keeps one agent out for good. Bare prints where it stands. ``` chi agents auto [OPTIONS] [ACTION] ``` **Arguments** - `[ACTION]` — `on` or `off`. Omit to print where it stands (one of: `on`, `off`) #### `chi agents connect` Connect the agents that appeared since Archis last looked. What the tail of every command does by itself; here for scripts, and for the MCP server ``` chi agents connect [OPTIONS] ``` **Options** - `--quiet` — Connect, but leave the notices for the next channel to deliver ### `chi skill` The on-disk method Archis installs into the harness, and keeps current. The MCP handshake carries the short version of Archis's method and pays for it on every turn; a skill is read only when a question matches its description, so it can carry the whole thing for nothing on the turns it is not needed. Archis owns the file: every release rewrites it, so a customer never runs a method that describes tools they no longer have. ``` chi skill [OPTIONS] ``` #### `chi skill install` Write Archis's skill where the harness will read it ``` chi skill install [OPTIONS] ``` **Options** - `--global` — Install for every repository on this machine (`~/.claude/skills`) instead of just this one - `--force` — Replace a file Archis did not write. #### `chi skill uninstall` Remove it again ``` chi skill uninstall [OPTIONS] ``` **Options** - `--global` — Remove the copy that serves every repository on this machine instead of this repository's #### `chi skill status` Where it is installed, and whether it matches this binary. The `--json` this used to declare for itself is gone: `chi --json skill status` and `chi skill status --json` named the same thing and only one of them worked, which is worse than either (#789). The global flag now answers both spellings. ``` chi skill status [OPTIONS] ``` #### `chi skill refresh` Rewrite every installed copy that this release has moved past. Creates nothing and touches nothing Archis did not write, which is what makes it safe to run unprompted — the session hook does, and so does the tail of a self-update, through the newly installed binary. ``` chi skill refresh [OPTIONS] ``` **Options** - `--quiet` — Say nothing. For the callers that run inside somebody else's output #### `chi skill show` Print exactly what would be written, without writing it ``` chi skill show [OPTIONS] ``` ### `chi policy` The read policy: paths never served to an agent and secrets redacted, from the workspace, the registry and the repository's .chipolicy.json. `chi policy` shows what is in force here and where each rule comes from; `chi policy audit` reads the local log of every refusal and redaction, which never leaves this machine; `chi policy harness` writes the deny rules into the agent's own settings, so its Read tool honours them too. ``` chi policy [OPTIONS] [COMMAND] ``` #### `chi policy show` The policy in force for this repository, layer by layer, and where each layer comes from (the default) ``` chi policy show [OPTIONS] ``` #### `chi policy audit` The local audit: every path the policy refused and every secret it redacted, oldest first. Kept on this machine; never sent anywhere ``` chi policy audit [OPTIONS] ``` **Options** - `--days ` — Only records from the last N days - `--limit ` — At most this many records, the most recent (default: `50`) #### `chi policy harness` Write the policy's deny rules where the coding agent's own file tools honour them: `Read(...)` entries (and `Edit`/`Write` of the policy file itself) in the repository's committed `.claude/settings.json`, the workspace's rules in the uncommitted `.claude/settings.local.json`, and `.cursorignore` where Cursor is in use. Only reading is denied this way: the agent's shell, Grep and Glob are not covered ``` chi policy harness [OPTIONS] ``` **Options** - `--cursor` — Write `.cursorignore` even if this repository shows no sign of Cursor ### `chi doctor` Check this installation and say what is wrong with it. Changes nothing. Safe to run when confused, which is the only time anybody runs it. ``` chi doctor [OPTIONS] [COMMAND] ``` **Options** - `--copy` — Also put the report on the clipboard, to paste into an issue or a ticket. #### `chi doctor agents` Whether Archis is actually in front of a model, agent by agent. The full version of the summary `chi doctor` prints: it asks each installed agent about its own configuration, which is a subprocess apiece and takes a few seconds. ``` chi doctor agents [OPTIONS] ``` **Options** - `--copy` — Also put the report on the clipboard, to paste into an issue or a ticket. #### `chi doctor crypto` Everything about index encryption, in one place ``` chi doctor crypto [OPTIONS] ``` **Options** - `--passphrase` — Prompt for the passphrase, for a device key or an index behind one - `--copy` — Also put the report on the clipboard, to paste into an issue or a ticket. #### `chi doctor versions` Every version stamp in this build ``` chi doctor versions [OPTIONS] ``` **Options** - `--copy` — Also put the report on the clipboard, to paste into an issue or a ticket. ### `chi update` Update Archis itself to the newest release. Verifies the download before it becomes the binary you run, replaces it atomically, and puts the old one back if the new one cannot even print its own version. Credentials, consent and local graphs are untouched. ``` chi update [OPTIONS] ``` **Options** - `--check` — Report what is available and install nothing - `--channel ` — Release channel for this run only, without changing the machine's channel. Switching for good is `chi channel ` - `--auto []` — Turn automatic updates on or off. Bare `--auto` reports the setting. ### `chi channel` The release channel this machine follows: stable, or beta to try pre-releases early. Alone, it lists the channels and names the one you are on. With a channel it switches, and from then on `chi update`, the daily notice and automatic updates all follow it — same account, same licence, only the binary offered changes. Beta always offers the newest of beta *and* stable, so nothing ever downgrades: switching back to stable simply waits for the next stable release to pass what is installed. ``` chi channel [OPTIONS] [CHANNEL] ``` **Arguments** - `[CHANNEL]` — The channel to switch to: `stable` or `beta`. Alone, reports ### `chi eject` Take Archis back out: the index, the settings, and every block Archis wrote. The inverse of `chi init`. Removes only what is attributably Archis's, prints the full plan first, and asks before acting. ``` chi eject [OPTIONS] ``` **Options** - `--yes` — Remove without asking. Required when there is no terminal to ask at - `--dry-run` — Print what would be removed and stop - `--keep-sessions` — Keep the session store — this repository's working history, the one thing `chi index` cannot rebuild - `--all` — Every repository Archis has indexed on this machine, not just this one. Combine with --machine to leave nothing behind - `--machine` — Also remove the machine-wide half: hooks, briefing, skill, permission entry, and every MCP registration. On its own it touches no repository ### `chi uninstall` Take Archis off this machine entirely: every repository, the machine setup, the credentials, the installer's PATH line and the binaries. The whole opt-out in one command, in the only order that works — `chi` is what knows where Archis put anything, so it removes all of it before deleting itself. `chi eject` is the same thing bounded to one repository; this is for finishing with the product. Every step says what it did per path, and names the command that completes anything it could not. ``` chi uninstall [OPTIONS] ``` **Options** - `--yes` — Remove without asking. Required when there is no terminal to ask at - `--dry-run` — Print what would happen and change nothing - `--keep-sessions` — Keep each repository's session store — its working history, and the one thing `chi index` cannot rebuild - `--keep-repos` — Leave repositories alone: machine setup, credentials and binaries only - `--purge` — Also delete the state directory — credentials, index keys, telemetry spool, registry — and this machine's device identity in the keychain - `--keep-backups` — Keep the `*.chi-backup` copies Archis made before editing a file ## The index Building and refreshing the graph Archis answers from, and the keys that seal it. ### `chi index` Build or refresh this repository's knowledge graph. Works out for itself what is needed: an empty graph is indexed whole, an existing one has only its changed files recompiled and its deleted ones forgotten. Name a file to refresh just that file. `--full` rebuilds from scratch. Optional either way: the graph refreshes itself when a model asks it something. Running this is the explicit path. ``` chi index [OPTIONS] [PATH] ``` **Arguments** - `[PATH]` — What to index. A directory is a tree, a file is that file alone. Defaults to this repository (default: `.`) **Options** - `--full` — Rebuild from scratch instead of updating what changed. What `--json` and `--timings` have always reported on - `--no-prune` — Index everything: dependencies, build output, hidden directories, and whatever `.chignore` says to skip. An order of magnitude more work, so it is asked for rather than assumed. Implies `--full`, because a wider scope is not a difference against a narrower one - `--detect` — Report the languages found and how well each is supported. Writes no graph unless `--opaque` is given too - `--encrypt` — Seal this repository's index at rest, converting it if it is not sealed already. Ordinarily decided for you — an index is sealed whenever this machine has a key — so this is for a repository indexed before, or one that opted out. Converting rebuilds the index and sets the plaintext store aside rather than overwriting it - `--no-encrypt` — Index in the clear, for a corpus meant to be inspectable with ordinary tools. Decides only for an index that does not exist yet: forgetting a flag can never downgrade a sealed one **Advanced options** - `--opaque` — With `--detect`, also record the files no adapter understands, so they are findable even though nothing can parse them - `--timings` — Per-stage timings, file taxonomy and the canonical graph hash. Implies `--json` ### `chi keys` Encryption keys: this machine's identity, and what can open an index. An encrypted index is sealed with a key this machine generated and never sent anywhere, itself wrapped by an epoch key your licence delivers — so an index copied off this machine is unreadable. Nothing here deletes an index. ``` chi keys [OPTIONS] [COMMAND] ``` #### `chi keys status` Show the device identity and what can open this repository's index ``` chi keys status [OPTIONS] ``` #### `chi keys enroll` Create this machine's encryption identity and register it. Run automatically by `chi auth login`. Worth running by hand to move the private key behind a passphrase, or to re-register after the OS keystore was cleared. ``` chi keys enroll [OPTIONS] ``` **Options** - `--passphrase` — Protect the private key with a passphrase instead of the OS keystore. Every command that opens an encrypted index will ask for it, and losing it means re-enrolling and re-indexing #### `chi keys devices` Every device on this account: whether it is activated, and whether it can open an encrypted index ``` chi keys devices [OPTIONS] ``` **Options** - `--revoke ` — Revoke a device so it stops receiving licence refreshes. Reversible: `--reinstate` undoes it, and so does signing in again from that machine - `--remove ` — Take a device off the list without deleting it. It stops counting against your activations, and installing Archis on that machine again brings it back as itself rather than as a second device - `--reinstate ` — Put a device you switched off back into service. Refused for one an administrator revoked — that is theirs to undo #### `chi keys rotate` Re-wrap this repository's key under the newest epoch your licence carries. Ordinarily unnecessary — every command that opens an encrypted index does this. It exists for a machine that has been offline long enough to be close to falling behind. ``` chi keys rotate [OPTIONS] ``` #### `chi keys passphrase` Add or remove a passphrase that opens this repository's index without a licence (BYOK) ``` chi keys passphrase [OPTIONS] ``` **Options** - `--remove` — Remove it, leaving the licence as the only way in #### `chi keys forget` Delete this machine's encryption identity. Every index sealed to this device stops opening until a new identity is enrolled and a fresh licence arrives. The indexes themselves are untouched and can always be rebuilt. ``` chi keys forget [OPTIONS] ``` **Options** - `--yes` — Required. This is not a command to run by accident ## Reading the graph The questions a person asks by hand — the same ones an agent asks over MCP. ### `chi context` Everything one question needs, in one answer: rank, outline, project, scan. The CLI half of `chi_context`, and here for the same reason the skill tells a model to start there: it is the whole first pass — rank, outline, project, and scan for anything the task quoted — where doing it by hand is four commands. This is also the documented fallback when the MCP server is not registered, and a fallback that cannot make the first call is not one. ``` chi context [OPTIONS] ``` **Arguments** - `` — The whole question, in prose. Every term in it seeds the ranking, and anything quoted is searched for literally **Options** - `--intent ` — What you are about to do, which decides what comes back (default: `understand`; one of: `understand`, `debug`, `edit`, `test`, `review`) - `--file ` — Narrow to these paths - `--symbol ` — Seed with these symbols, and for `--intent edit` fetch their source - `--budget ` — Ceiling for the whole package. Defaults to what the intent asks for ### `chi search` Find symbols by name or signature. A ranked lookup over names, signatures and the compact projection — the CLI half of the `search` tool. Exact name matches rank first; `--kind` and `--file` tell two same-named symbols apart. ``` chi search [OPTIONS] ``` **Arguments** - `` — What to look for: a name, or something close to one **Options** - `--limit ` — How many hits to return (default: `20`) - `--kind ` — Filter by symbol kind (function|method|class|interface|struct|…) - `--file ` — Filter by a file-path substring (disambiguates same-named symbols) ### `chi symbol` *Alias: `sym`* Everything about one symbol: what it is, its source, and what it reaches. Bare, it prints what the symbol does. The flags widen that to the other questions a person has about the same symbol — its exact text, who calls it, what it calls, how far a change to it reaches — which used to be a second command (`chi refs`) for what is one subject. `--refs` is the two directions at once, which is the question somebody actually has. `--impact` walks the graph transitively and is the expensive one, so it is asked for by name. ``` chi symbol [OPTIONS] ``` **Arguments** - `` — Symbol id, canonical name, or bare display name. `chi search` finds it **Options** - `--detail ` — How much to show: signature, behavior (the default), or source (default: `behavior`; one of: `signature`, `behavior`, `source`) - `--source` — Shorthand for `--detail source` - `--refs` — Both directions of the call graph: who calls it, and what it calls - `--calls` — Only what it calls - `--called-by` — Only who calls it - `--impact` — Blast radius: the transitive callers - `--depth ` — How far `--impact` follows the graph (default: `3`) ### `chi specs` The repository's specifications, as the graph sees them. Spec-driven tools (Spec Kit, Kiro, OpenSpec, plain ADRs) write their claims into the files: front-matter metadata, task→requirement references, links between documents. The indexer turns those into symbols and edges; this command inventories them (`list`) and verifies them against the graph (`check`) — a stale `spec_hash`, an edge whose target is gone, a spec the index has not seen. ``` chi specs [OPTIONS] ``` #### `chi specs list` The files under this repository's spec roots, with what each declares ``` chi specs list [OPTIONS] ``` #### `chi specs check` Verify the declarations: a `spec_hash` that no longer matches the body, an edge whose target the graph does not know, a spec the index has not seen. Exits non-zero when anything needs attention ``` chi specs check [OPTIONS] ``` ### `chi compile` Compile one file and print its compact projection ``` chi compile [OPTIONS] ``` **Arguments** - `` — The file to compile. One file — `chi measure` is what walks a directory **Advanced options** - `--ir` — Also print the canonical IR as JSON ### `chi measure` Measure the token reduction over a file or a directory ``` chi measure [OPTIONS] [PATH] ``` **Arguments** - `[PATH]` — What to measure. Defaults to this repository (default: `.`) ## Sessions and the agent loop Working memory across turns, the built-in loop, and the local dashboard. ### `chi session` Session memory: create, show, rehydrate, report, cost ``` chi session [OPTIONS] ``` #### `chi session create` Create a new session and print its id ``` chi session create [OPTIONS] ``` **Options** - `--model ` — The model this session runs against, recorded with it - `--repo-version ` — The repository revision the session starts from, recorded with it #### `chi session show` Show a session's full memory ``` chi session show [OPTIONS] ``` **Arguments** - `` — The session to read — the id `chi session create` printed #### `chi session rehydrate` Build the rehydration package for a session ``` chi session rehydrate [OPTIONS] ``` **Arguments** - `` — The session to rehydrate #### `chi session report` Context accounting: tokens exposed per level, tool and turn, escalation rates and the reasons exact source was served ``` chi session report [OPTIONS] ``` **Arguments** - `` — The session to account for #### `chi session cost` What a session cost: the provider's bill, when Archis drove the session and saw it, beside Archis's own accounting of what it served and what that stood in for ``` chi session cost [OPTIONS] ``` **Arguments** - `` — The session to price **Options** - `--forwarded` — The other half of the invoice: the forwarded-token ceiling split by directory — what the session keeps re-sending, rather than what the provider charged for it - `--min-share ` — With `--forwarded`: hide subtrees below this share of the total (default: `0.01`) - `--limit ` — With `--forwarded`: hard ceiling on rendered rows (default: `40`) ### `chi run` *Alias: `agent`* Run Archis's own agent loop over a task. CAVS drives a live model over Archis's tools until it finishes or hits the step limit. ``` chi run [OPTIONS] ``` **Arguments** - `` — The task for the agent to solve **Options** - `--agent ` — Which agent CLI drives the loop (see `chi agents`) (default: `claude`) - `--model ` — Model name, or reasoning effort for agents that read the knob that way. Defaults to the agent's own default - `--steps ` — Stop after this many turns (default: `12`) - `--budget ` — Context budget in tokens; the loop elides old tool results and only stops if the prompt still cannot fit - `--plan` — Plan mode: serve compact context only, never exact source - `--source-budget ` — Token ceiling on exact source for the whole session; once spent, further source reads are refused in favour of compact ones - `--write` — Let the agent apply patches (writes files) - `--exec` — Let the agent run tests, builds and lints - `--repair` — Bug-fix mode: the loop cannot finish without applying a patch **Advanced options** - `--transcript` — Print the full turn-by-turn transcript - `--no-compress` — Send tool output to the model uncompressed (the control arm) ### `chi dashboard` Open the local dashboard: repositories, activity, history, integrations. Loopback only (127.0.0.1) and strictly read-only. Nothing leaves the machine, and history is redacted before display. ``` chi dashboard [OPTIONS] [COMMAND] ``` **Options** - `--tui` — Stay in the terminal instead of opening a browser - `--plain` — Print the numbers as text and exit. No UI of either kind - `--port ` — Port for the web dashboard. 0 picks a random free port (default: `0`) - `--no-browser` — Print the URL without opening a browser #### `chi dashboard clean` Delete local history: this repository's sessions, dead registry entries, or both. A project whose directory merely moved is kept — you still have it. Only entries whose directory, graph and session store are all gone are dropped. Session history is the one thing nothing can rebuild, so it goes only when asked for by name. ``` chi dashboard clean [OPTIONS] ``` **Options** - `--history` — Delete ALL session history for this repository's store - `--projects` — Drop registry entries with nothing left behind them - `--yes` — Skip the confirmation prompt ## Pilot evidence Rework, reverts and review minutes for agent pull requests, computed on your machine from your own history. ### `chi pilot` The evidence a pilot reports: rework, reverts and review minutes for agent pull requests, with and without Archis. Computed on this machine from the repository's Git history and its pull request metadata. Nothing is sent to Archis. ``` chi pilot [OPTIONS] ``` #### `chi pilot report` Rework, reverts and review minutes for agent pull requests, with and without Archis. Computed on this machine from the repository's Git history and its pull request metadata, read from a file (`--prs`) or from GitHub through your own `gh` login (`--github`). Nothing is sent to Archis. ``` chi pilot report [OPTIONS] ``` **Options** - `--github ` — Read pull requests live from GitHub (`owner/name`) through `gh` - `--prs ` — Read pull requests from a file `chi pilot fetch` wrote - `--since ` — Count pull requests ready for review on or after this time (UTC) - `--until ` — Count pull requests ready for review before this time (UTC) - `--as-of ` — The time the report is computed at, for the revert window. Defaults to now - `--revert-window-days ` — A merge reverted within this many days counts as reverted (default: `14`) - `--maturity-days ` — Rework and review times count only pull requests ready at least this many days before `--as-of`; younger ones are shown as too recent (default: `7`) - `--git-ref ` — The branch whose history is scanned for reverts. Defaults to the remote's default branch (`origin/HEAD`), else `HEAD` with a warning - `--no-git` — Do not scan Git history; read reverts from pull request descriptions only - `--agent-label