GeezerVison is showing chatcli.edilsonfreitas.com — Complete Command Reference - ChatCLI Quick reference for all ChatCLI commands and flags.
Internal Commands (/)
| Command | Description |
|---|
/help / /help <command> | Every command by category, with aliases, context modifiers, one-shot flags and subcommands; /help <command> (e.g. /help session) lists that command’s subcommands and options | /menu (or /) | Opens the interactive command palette — a navigable list of every command (see Command Palette) | /exit or /quit | Exit ChatCLI | /newsession | Start a new conversation session | /config, /status or /settings | Configuration panorama (accepts subsections — see below); bare opens the palette with the sections | /reload (alias /config --reload) | Reload settings from .env — covers every provider variable (keys, models, endpoint overrides, BEDROCK_PROVIDER) and the embeddings provider (CHATCLI_EMBED_*); values removed from .env are cleared without restarting | /switch | Switch LLM provider or model (with dynamic autocomplete); bare opens the providers/flags palette | /provider (or /providers) | Switch the active LLM provider by name; bare opens the palette with the active providers (same UX as /model) | /model <name> (or /models) | Shorthand for /switch --model <name>; bare opens the palette with the available models | /max-tokens <num> | Shorthand for /switch --max-tokens <num>; with no argument, shows the current value | /agent or /run | Start agent mode | /coder | Start coder mode (code engineering) | /auth | Manage OAuth credentials | /clear | Clear the conversation: the turns go to a checkpoint (/rewind restores them) while the session binding, attachments and memory stay | /redraw | Repaint the screen (prompt corrupted or visual artifacts; also /reset) | /connect | Connect to remote server (gRPC) | /disconnect | Disconnect from remote server | /context | Manage persistent contexts | /plugin | Manage plugins | /skill | Manage skills from registries | /<command> | Invoke a slash-command template from .chatcli/commands (project or ~/.chatcli/commands, with interop for 9 agent-CLI ecosystems — Claude Code, Devin, Windsurf, Cursor, opencode, Codex, Gemini, Qwen, Copilot): /review-pr 1326. /config commands lists the catalog | /session | Manage sessions (save, load, attach, detach, status, list, delete, new, fork, search) | /nextchunk | Load next file chunk | /retry | Retry last failed chunk | /retryall | Retry all failed chunks | /skipchunk | Skip a file chunk | /version | Version card: installed build, install channel, latest release and what’s new when an update exists | /update | Update ChatCLI through the same channel it was installed with (Homebrew, go install or release binary); /update check only checks. Also available outside the REPL as the chatcli update subcommand | /restart | Restart ChatCLI on the version installed now (after /update or a background auto-update), with the same arguments, resuming the conversation. Interactive terminal only | /compact | Compact conversation history (auto or guided) | /autocompact | Session auto-compaction threshold | /rewind | Rewind to a previous conversation checkpoint | /memory | View/load/edit memory (today, yesterday, week, load, longterm, list, profile, profile set <field>=<value>, remember <fact>, forget <substring>, topics, projects, stats, facts, timeline [q], compact, export, import, recall, why, links <note>, link <a> -> <b>, unlink <a> -> <b>, vault [status|sync|path]) | /graph | Renders the knowledge graph to an image (PNG, via embedded go-graphviz). /graph = full graph; /graph <subject> = a node’s local graph | /watch | K8s watcher status | /mcp | Manage MCP servers (status, tools, restart) | /hooks | List configured lifecycle hooks | /cost [reset|last|sessions|export] | Session cost summary; reset the period, view the previous/recent snapshots, export JSON | /storage [store] / /storage prune [store] [--apply] | Inventory of every local store (files, size, policy, what the rules would remove now); prune is a dry run until --apply | /worktree | Manage git worktrees (create, list, remove, status) | /channel | MCP channels inbox + trigger engine — see /channel subcommands | /websearch | Manage web search provider (status, list, provider, reset) | /policy | Session security-policy mode (status, mode auto, mode interactive) — see Session Policy Mode | /thinking | Cross-provider reasoning/thinking override (on|off|auto|low|medium|high|max|budget=N) — see #7 Reasoning Backbone | /plan | Force Plan-and-Solve / ReWOO on next /agent or /coder — see #2 Plan-and-Solve | /refine | Toggle Self-Refine for the session (on|off|once|auto) — see #5 Self-Refine | /verify | Toggle Chain-of-Verification for the session (on|off|once|auto) — see #6 CoVe | /reflect | Durable lesson queue (status, list, failed, retry, purge, drain) — see #3 Reflexion | /schedule | Schedule a durable job (cron / relative / interval / wait-until) — see Scheduler | /wait | Wait for a condition and optionally run an action — see Scheduler | /jobs | Manage scheduled jobs (list, show, tree, cancel, pause, resume, logs, history, daemon, gc) | /agents | Live agent runs as a tree (list, show <id>, cancel <id>) — see Agent Squad | /board | Squad work board (list, show, create, move, assign, note, archive) — see Agent Squad | /taskgraph | Task graph runs (status, show, list, dash, prune, cancel) — watch a DAG execution mid-run, see Task Graph | /dash | Live dashboard of the whole runtime (open, url, status, off): a real-time graph of agents, LLM, tools, skills, MCP, the seven patterns, background work and connections across every chatcli process on the machine. Works mid-run and over ACP; chatcli dash serves it from a terminal of its own. See Live Dashboard | /mail | Squad mail (list, send <agent> <text>, pending) — see Agent Squad | /parked | List agents parked via @park — prune removes terminals, gc <dur> removes old ones — see Agent Park & Resume | /resume | /resume <token> forces immediate resume of a park (idempotent against auto-resume) | /cancel-park | /cancel-park <token> aborts a park: deletes snapshot + cancels scheduler job | /park-note | /park-note <message> sends a directive to the parked agent — delivered as an instruction when it resumes | /ratelimit or /limits | Show the current provider’s rate limits, parsed from the last response’s x-ratelimit-* headers (remaining requests/tokens and reset) | /export | Export the current session’s agent trajectory as ShareGPT-format JSONL (fine-tuning / analysis) | /moa | Mixture-of-Agents: several models propose in parallel and an aggregator synthesizes; every participant gets a chat turn’s briefing + read-only tools (knowledge, CCR recall, memory) (CHATCLI_MOA_MODELS); --layers N adds cross-review rounds where each model revises after reading the others — see Mixture-of-Agents | /gateway | Run ChatCLI as a detached messaging daemon (start, status, stop): each message runs through the agent loop and progress is streamed over Telegram/Slack/Discord/WhatsApp/webhook — see Chat Gateway | /hub | Inspect and manage the shared cross-channel conversation: whoami (principal + active conversation), bind <platform> <userid> [principal], bindings [principal] — see Conversation Hub | /lsp <file> | Code diagnostics (errors/warnings) for a file via the Language Server Protocol — see LSP Diagnostics |
Interactive Command Palette
Commands that have subcommands, flags or values open a navigable palette when typed bare and confirmed with Enter — the same experience Claude Code users get. Instead of just printing a list, the palette lets you arrow through it and select.
| How to open | Result |
|---|
/ or /menu + Enter | Root palette: every command grouped by category | A bare “pickable” command (e.g. /model, /config, /provider, /switch) + Enter | Scoped palette for that command: its real subcommands/flags/values |
<TAB> always show exactly the same set, with no drift.
Palette navigation:
| Key | Action |
|---|
↑ / ↓ (or Ctrl+P / Ctrl+N) | Move the selection | | Type | Filter (fuzzy) | → / Enter | Drill into a sublevel, or select (runs the command) | Tab | Insert the selection as text | ← / Esc / Backspace | Go back one level (or cancel at the root) | Ctrl+C | Cancel |
↵): every scoped picker leads with an entry that runs the command with no arguments, preserving the behavior of commands whose bare form already did something — e.g. /config shows the overview, /switch opens the provider picker. That entry’s description summarizes what the command does, so it never looks “empty”.
The palette is themed (it follows the active theme, see /config ui theme) and runs only in the interactive REPL — headless runs (scheduler, gateway, one-shot) execute the command as typed.
External subcommand chatcli daemon
chatcli daemon {start|stop|status|ping|install} [--detach] [--socket <path>] — controls the scheduler daemon in the background. Any interactive CLI detects the daemon and becomes a thin client over the UNIX socket. See Scheduler → Daemon mode.
External subcommands chatcli mcp-server and chatcli acp
chatcli mcp-server (alias mcp-serve) — runs ChatCLI as an MCP server over stdio, with the full ChatCLI experience: chat through the complete pipeline (ask_chatcli — memory, contexts, skills, knowledge), the real agent/coder loops (agent_task, coder_task), session management (manage_session), every built-in tool, skills as prompts, local state as chatcli:// resources and conversation-hub continuity. Use LLM_PROVIDER/LLM_MODEL to pick the backend. See MCP Server (ChatCLI as a server).
chatcli acp — runs ChatCLI over the Agent Client Protocol (stdio): chat/agent/coder session modes, structured tool-call and plan updates, slash commands from the IDE prompt, native permission dialogs and session/load restore (live state or the autosave mirror, with the conversation replayed), for JetBrains IDEs, Zed and any ACP client. See ACP — ChatCLI inside your IDE.
/config security — mutable rules
/config security is now hierarchical: the bare form still shows the read-only panorama; the new subcommands mutate the PolicyManager live and persist to ~/.chatcli/coder_policy.json. Used by both interactive /coder and the scheduler preflight.
| Subcommand | Description |
|---|
/config security | Read-only dump (previous behavior) | /config security rules | List active rules grouped by action (deny, allow, ask) | /config security allow "<pattern>" [--yes] | Add ALLOW rule; prompts if the pattern is broad | /config security reseal | Rewrite every store under the state root with the current encryption key (plaintext files get sealed; retired keys are migrated). With CHATCLI_ENCRYPTION_KEY=off it writes every store back in plaintext, the way back to an older version. See Encryption at Rest | /config security reveal [<file>] [--out <path>] [--force] | Read one sealed store file in plaintext without unsealing it on disk. With no file, list the sealed files (relative to the state root; Tab completes them). --out writes an opened copy (mode 0600, outside the state root, no overwrite without --force). Interactive terminal only. See Encryption at Rest | /config security use-keychain | With CHATCLI_ENCRYPTION_KEY set, move every store to the OS keychain key, after which the variable can be removed. With the default key still in ~/.chatcli/.auth-key (the keychain held a different key), move that same key into the keychain, keeping the keychain’s previous value as auth-key.previous | /config security recovery-key [--save <file> | --restore <file>] | Show the recovery key behind the default keychain key (interactive terminal only); kept outside the machine, it opens your data anywhere as CHATCLI_ENCRYPTION_KEY. --save writes it to a passphrase-protected file; --restore opens such a file and moves your data onto this machine’s keychain key | /config security verify-audit [path] | Re-hash the tamper-evident audit trail and report the first broken line, sealed count, rotation origin and torn tail | /config security deny "<pattern>" [--yes] | Add DENY rule; prompts [y/N] | /config security forget "<pattern>" [--yes] | Remove rule; prompts [y/N] | /config security reload | Force re-read of the JSON (after external file edit) |
<toolName> <args> as the PolicyManager normalizes (@coder exec <cmd>). Deny always beats allow.
/channel — MCP channels inbox and triggers
Manages the MCP Channels inbox and the trigger engine (rules in ~/.chatcli/mcp/triggers.json). All subcommands support autocomplete (Tab after /channel ).
| Subcommand | Argument | Description |
|---|
/channel or /channel list | — | Lists up to 20 most recent ring messages with seq, timestamp, server, channel and preview. Shows total and unread counters, plus a warning when the engine is paused | /channel <name> | channel name | Filters the listing to that channel | /channel ack | — | Marks every message as read, clears the pending notify banner. Returns how many entries were cleared | /channel inject | — | Injects the last 10 messages into history as a system message (legacy behavior). Useful when you want to provide explicit context without waiting for auto-injection of the 5 most recent | /channel pause | — | Pauses the trigger engine. Messages keep entering the ring/persistence, but no Action is emitted (zero banners, confirms, autos) while paused | /channel resume | — | Reactivates the trigger engine | /channel rules | — | Lists active rules with name, mode, filters (server/channel/contentRegex) and configs (rate, dedup, tools) | /channel rules reload | — | Re-reads ~/.chatcli/mcp/triggers.json without restarting ChatCLI. On schema error, keeps the previous rules active and shows the error | /channel confirm <id> | id required | Accepts a pending confirm action (default = yes); fires the agent with the rule template inside an AUTO-AGENT envelope box | /channel confirm <id> no | id required | Refuses a pending confirm action without firing anything | /channel run <seq> | seq required | Fires the agent manually against a specific ring message (use the seq shown by /channel list) — useful for investigating a message that came in as notify |
Harness/Quality Pipeline — At a Glance
ChatCLI ships seven LLM-agent patterns that can be toggled per session via slashes:
| Pattern | Slash | Default | What it does |
|---|
| #1 ReAct | — | always on | Base loop | | #2 Plan-and-Solve | /plan | auto (complexity ≥ 6) | JSON plan + ReWOO | | #3 Reflexion | /reflect | on (on errors) | Persisted lessons | | #4 RAG + HyDE | — | off | Semantic retrieval | | #5 Self-Refine | /refine on | off | Critique + rewrite | | #6 CoVe | /verify on | off | Chain-of-Verification | | #7 Reasoning | /thinking on | auto (planner, refiner, verifier, reflexion) | Cross-provider |
/reflect — subcommands
The durable Reflexion queue exposes observability and DLQ triage operations. All have Tab autocomplete:
| Subcommand | What it does |
|---|
/reflect | Status: queue depth + DLQ size + subcommands hint | /reflect <free text> | Persist manual lesson to memory.Fact (no LLM) | /reflect list | List pending + DLQ with trigger, attempts, age, task preview | /reflect failed | DLQ only, with last error — ideal for triage | /reflect retry <job-id> | Re-queue a DLQ job (resets Attempts=0) — Tab autocompletes live IDs | /reflect purge <job-id> | Remove permanently from the DLQ — Tab autocompletes live IDs | /reflect drain | Force WAL replay (pending items from a previous session) |
Tab on /reflect retry or /reflect purge queries the live DLQ and shows IDs with task preview + last error.
/config — Panorama and Sections
/config (aliases: /status, /settings) has two modes: short panorama (no argument — default) and drill-down by section. /config <TAB> autocomplete lists the sections.
| Command | Description |
|---|
/config | Short panorama: provider, model, session (messages, tokens, cost, duration), active persona, counters (plugins, MCP servers, hooks), websearch chain, remote connection if active | /config all | Full dump — all sections in sequence | /config general | .env path, locale, logging, version check, history file | /config update | Auto-update policy (CHATCLI_AUTO_UPDATE), detected install channel, current vs. latest release | /config providers | Env vars for each provider (OpenAI, Claude, Bedrock, Copilot, Devin CLI, OpenRouter, ZAI, MiniMax, Moonshot, StackSpot, Ollama) + API key presence (no value leaked) | /config agent | Agent runtime: coder UI, workers, subagents, timeouts, tmpdir, denial caps, per-agent overrides, active persona | /config resilience | Payload caps, recovery ladder, stream timeout, global TLS trust (CA bundle, skip-verify), Bedrock proxy (CA bundle, IMDS), compaction | /config session | Current session (name, messages, cost, budget), attached contexts, memory system | /config managed | Organization-managed defaults and locked policies in effect (file path, entries, precedence) | /config retention | Lifecycle policy of every on-disk store in one view: machine sessions, transcript journals, park snapshots, cost snapshots and coder checkpoints (all on CHATCLI_SESSION_TTL, swept at boot; a checkpoint whose workspace is gone goes regardless of age), CCR archive TTL and size cap, task-graph runs, memory daily notes and fact cap, hub idle purge | /config memory | Memory injection mode, auto-recall gates, knowledge-graph settings, live graph node/edge stats, explicit link count and the vault (CHATCLI_MEMORY_VAULT, its directory, last sync) | /config selfevolve | Skill self-evolution: mode (CHATCLI_SELFEVOLVE_MODE auto/suggest/off) + observability (skills authored by the engine vs. total). See Skill Authoring | /config commands | Slash-command catalog: every loaded template with its source, names refused for shadowing built-ins, scanned directories; reload forces a re-scan. See Slash Commands | /config integrations | MCP (servers + tool count), hooks, plugins, skill registries, websearch (active chain), worktrees (if in a git repo), K8s watcher, remote connection | /config auth | OAuth status per provider (anthropic, openai-codex, github-copilot) with token expiry, keychain backend | /config security | Command policy (allow/denylist, sudo), workspace sandbox, Coder policy, TLS/proxy, redaction | /config quality | Seven-pattern pipeline: Self-Refine, CoVe, Reflexion, Plan-First, HyDE (vectors + provider + count), Reasoning backbone — see full overview | /config compression | Context Compression (CCR): mode, threshold, CCR store, savings. Mutable — off/lossless/lossy/stats | /config output | Output-token reduction: verbosity steering + effort routing. Mutable — full/concise/minimal, effort on|off | /config server | Conditional — only renders when any server-mode env is set (gRPC, JWT, rate limit, fallback chain, watcher, audit, operator) | /config hub | Conversation Hub: the effective value of each setting (with its source — setting/env/default), bindings, and session state. Mutable — see below |
The panorama shows a numeric summary (“MCP servers: 2 (6 tools)”, “Hooks: 3”, “Web search chain: duckduckgo → searxng”) and lists the available sections in the footer. Use /config <section> for full detail. /config hub — mutable settings
Unlike bare /config hub (a read-only panorama), the subcommands change hub settings at runtime — persisted in hub.db and read live by the gateway daemon (cross-process, no restart):
| Command | Effect |
|---|
/config hub set enabled <on|off> | Turn the hub on/off | /config hub set principal <name> | Set the shared conversation identity | /config hub set isolate <on|off> | Isolate each channel (multi-user bot) vs. collapse to the principal | /config hub set ttl_hours <n> | Hours before pruning an idle conversation (0 disables) | /config hub reset <key> | Drop the override; back to env var/default |
/config hub reprints immediately after each set/reset, showing the new value and its source. Mutation requires local hub mode or /connect.
/websearch — Web Search Provider
| Command | Description |
|---|
/websearch or /websearch status | Show current provider + active fallback chain | /websearch list | List known providers and which are configured | /websearch provider <searxng|duckduckgo|brave|mojeek|auto> | Set preferred provider for the session (sets CHATCLI_WEBSEARCH_PROVIDER) | /websearch reset | Remove override and return to auto mode |
duckduckgo (default, HTML scraping), searxng (self-hosted via SEARXNG_URL), brave and mojeek (independent indexes, HTML scraping). Default chain: duckduckgo → searxng → brave → mojeek. See Web Tools for details.
Provider and Model Switching (/switch)
| Command | Description |
|---|
/switch | Bare opens the palette of providers/flags; also accepts the flags below | /switch --model <name> | Switch model for the active provider | /switch --model | List all available models (dynamic from API) | /switch --max-tokens <num> | Set max tokens for responses | /switch --realm <name> | Change realm/tenant (StackSpot only) | /switch --agent-id <id> | Change agent (StackSpot only) | /provider <name> | Switch the active provider by name (case-insensitive); bare opens the palette with the active providers | /providers | Alias of /provider | /model <name> | Shorthand for /switch --model <name> (bare opens the palette with the models) | /models | Alias of /model | /max-tokens <num> | Shorthand for /switch --max-tokens <num> (no argument shows the current value) |
/switch --model (and /model) autocomplete fetches models directly from the provider’s API using the active token/key. Each suggestion shows [API] (dynamic) or [catalog] (static). /model and /max-tokens delegate to /switch, so they share exactly the same validation and behavior.
/provider is the navigable counterpart to the provider picker: type /provider and Enter to open the palette with the active providers (the current one marked), pick one and the switch is applied — the same switch logic as /switch, just by name instead of a numeric index.
Every provider switch — /switch, /provider or the palette — starts the new provider on its model variable (OPENAI_MODEL, ANTHROPIC_MODEL, BEDROCK_MODEL, …), read from the environment first and then from the persisted configuration, falling back to the provider’s built-in default. It is the same resolution startup uses; see How model selection works.
# Examples
/switch # Providers/flags palette
/switch --model gpt-4o # Switch to GPT-4o
/provider # Palette with the active providers
/provider OPENAI # Switch straight to the OPENAI provider
/model gpt-4o-mini # Same as /switch --model gpt-4o-mini
/model # Palette with the available models (source: API or catalog)
/max-tokens 4096 # Same as /switch --max-tokens 4096
/max-tokens # Show the current max-tokens limit
The /model (and its /models alias), /provider and /max-tokens shorthands appear in the command menu (<TAB> after /) and have their own autocomplete — /model <TAB> suggests the active provider’s models, /provider <TAB> lists the providers and /max-tokens <TAB> offers presets (0, 1024, 4096, 8192, 16384, 32768).
Context Commands (@)
| Command | Description |
|---|
@file <path> | Attach file content or directory structure | @file --mode <mode> | Mode: full, summary, chunked, smart | @command <cmd> | Execute command and attach output as context | @command --ai | Send output directly to AI for analysis | @command -i | Interactive mode (e.g., ssh, vim) | @git | Inject Git repository status, diff, and log | @env | Inject environment variables (sensitive ones redacted) | @history | Inject shell command history |
LLM-callable plugins (@<tool>)
Tools the agent can invoke via <tool_call> (in /agent, /coder modes). Full catalog in Plugin System and Atomic Tools.
| Plugin | Subcommands | Docs |
|---|
@coder | read, write, patch, multipatch, tree, search, exec, test, rollback, git-status, git-diff, git-log, git-changed, git-branch, outline, map, checkpoint, clean | Plugin @coder | @browser | open, show, hide, wait, snapshot, text, find, click, type, clear, press, hover, select, upload, scroll, eval, screenshot, html, pdf, resize, tabs, tab, cookies, console, network, downloads, back, forward, reload, status, close | Browser Automation | @forge | pr-list, pr-view, pr-diff, pr-checks, pr-create, pr-comment, issue-list, issue-view, issue-comment, ci-status, ci-logs, detect | Git Forge | @view | view (attach a local image to the conversation via the vision pipeline) | Image Input (Vision) | @proc | start (with pty:true), stdin, wait (pattern, timeout), status, logs (tail, grep), stop, remove, list | Agentic Plugins | @read | (flat) file, from_line, to_line, head, tail, encoding | Atomic Tools | @search | (flat) term, dir, max_results, include | Atomic Tools | @tree | (flat) dir, depth, exclude | Atomic Tools | @todo | write, add (append tasks), update (reword one), list, mark | Atomic Tools | @websearch | search | Web Tools | @webfetch | fetch | Web Tools | @scheduler | schedule, wait, query, list, cancel, pause, resume | Scheduler | @agents | list, show, cancel | Agent Squad | @board | create, list, show, move, assign, note, link, archive | Agent Squad | @mail | send, inbox, history | Agent Squad | @park | delay, until, for_url, for_cmd, list, note | Agent Park | @memory | remember, recall, list (facts with ids), forget (match + dry_run, or id), profile, timeline (dated episodes), neighbors (links →, backlinks ← and nearby notes), map (knowledge graph), link / unlink (explicit, persisted links between notes) | Bootstrap & Memory | @skill | create, update, list, show, remove, restore, stats, export, import | Skill Authoring | @commands | list, get — the model discovers and expands slash-command templates | Slash Commands | @knowledge | search (plus linked-document hints), get, toc, links (a document’s links and backlinks), list | Knowledge Base | @model | list, use, reset, status, delegate | Model Routing |
Partial list — the full catalog (32 native tools) is auto-generated: run /plugin list in ChatCLI, or ask an agent for @tools list. Curated highlights live in Agentic Plugins.
Agent Mode — Actions
| Action | Description |
|---|
[N] | Execute command number N | a | Execute all pending commands | eN | Edit command N | tN | Simulate (dry-run) command N | cN | Ask AI to continue with output from N | pcN | Add pre-execution context | acN | Add post-execution context | vN | View full output in pager | wN | Save output to temporary file | p | Toggle compact/full view | r | Redraw the screen | q | Exit agent mode |
Sessions (/session)
| Command | Description |
|---|
/session save <name> | Save the current conversation (also binds it — turns are written through from then on) | /session load <name> | Load a saved conversation (also binds it, and rotates the shared hub thread) | /session attach <name> | Bind to a named session — loads it if it exists, creates it if not; every turn syncs both ways with other surfaces (see Cross-surface continuity) | /session detach | Keep the conversation, drop the binding — turns stop writing through | /session status | Show whether (and to which session) the conversation is bound | /session list | List all sessions | /session delete <name> | Delete a session | /session new | Start a clean session (unbinds and rotates the shared hub thread, like /newsession) | /session fork <name> | Fork current session into an independent copy | /session export <md|jsonl> [path] | Export the full transcript journal as Markdown or JSON Lines | /session transcript <search|show|export|stats> | BM25 search, replay, export or stats over the transcript journal | /session search <term> | Full-text search across saved sessions, showing snippets with the term highlighted |
When connected to a remote server, sessions can be saved/loaded locally, remotely, or both.
Persistent Contexts (/context)
| Command | Description | |
|---|
/context create <name> ... | Create snapshot of files/directories (--mode knowledge indexes documentation or code/infra corpora as a knowledge base) | | /context update <name> ... | Update existing context | | /context attach <name> | Attach context to current session (--rag [K] semantic retrieval, --full/-f whole content, --chunk(s), --priority, --weight <n> corpus weight when merging knowledge hits; large contexts auto-upgrade to RAG when embeddings are on) | | /context detach <name> | Detach context | | /context list | List saved contexts | | /context show <name> | Show details and files | | /context inspect <name> | Detailed statistics | | /context delete <name> | Delete permanently | | /context merge <new> <c1> <c2> | Combine contexts | | /context refresh <name> | Re-index from the recorded source paths; only changed files are re-read and only changed passages re-embedded; unchanged corpora leave caches untouched | | /context watch <name> [off] / watch list / unwatch <name> | Filesystem watch (fsnotify) that refreshes the context automatically after edits settle (1.5 s debounce); outcome printed at the next prompt | | /context attached | Show attached contexts with token estimates and cache hints | | /context export <name> <file> | Export to JSON | | /context import <file> | Import from JSON | | /context metrics | Usage statistics | | /context status | Live inspector: what the last assembled system prompt was made of (section by section, with cached-prefix marks), the conversation history by role, token estimates from the learned chars/token ratio, projected share of the model window and where auto-compact fires | The totals now include the prefix budget (half the window, floor 24K chars): how much of it the last prompt used and which sections were folded for budget (skills → knowledge digests → attachments). |
Skills (/skill)
| Command | Description |
|---|
/skill search <query> | Search across all registries (parallel fan-out) | /skill install <name> [--from <reg>] | Install skill from a registry (specific or auto-detect) | /skill uninstall <name> | Remove installed skill (disambiguates if multiple sources) | /skill list | List installed skills with source and version | /skill info <name> [--from <reg>] | Full metadata (installs, security audits) | /skill registries | Show configured registries and status | /skill registry enable <name> | Enable a registry (immediate hot-reload) | /skill registry disable <name> | Disable a registry (immediate hot-reload) | /skill prefer [name] [source] | Set/show preferred source for conflicting skills | /skill prefer <name> --reset | Remove preference (revert to default: local wins) | /skill pin <name> | Pin a skill for the session — injected on every turn until /skill unpin | /skill unpin <name> | Remove a skill from the pinned set | /skill pinned | List skills pinned for the current session | /skill help | Help for the /skill command |
Command-Line Flags (One-Shot)
| Flag | Description |
|---|
-p, --prompt | Execute a prompt and exit | --provider <name> | Override provider (e.g., CLAUDEAI) | --model <name> | Override model | --timeout <duration> | Time limit (e.g., 10s, 1m) | --max-tokens <num> | Limit tokens in response | --agent-auto-exec | Execute first safe command in agent mode | --no-anim | Disable animations (useful in scripts) | --raw | Plain output without markdown or ANSI colors (for scripts and CI) | --realm <realm> / --agent-id <id> | StackSpot realm and agent ID overrides | -v, --version | Show the version card (same output as /version) | -h, --help | Print usage: every flag and every subcommand |
Subcommands
chatcli --help lists every subcommand, and chatcli <subcommand> --help shows one.
chatcli storage chatcli trust chatcli eval chatcli provider chatcli server chatcli healthcheck chatcli connect chatcli watch chatcli update
The /storage command without a REPL, for cron jobs and scripts. Boots no provider.| Form | Description |
|---|
chatcli storage [store] | Inventory: files, size, policy and what the rules would remove now, per store | chatcli storage prune [store] | Dry run: what the rules would remove, with the reason per item group | chatcli storage prune [store] --apply | Remove it | --json | Machine-readable inventory or outcome |
costs, checkpoints, sessions, transcripts, parked, memory-pending, attachments, taskgraph, pulse, ccr, hub; every other store (memory, vault, skills, plugins, contexts, agents, commands, reflexion, scheduler, tokenizers, mcp, cache, logs) is inventoried and never pruned. Rules: the session TTL (CHATCLI_SESSION_TTL) on last write for machine sessions, transcripts, parks, cost snapshots, pending memory, saved attachments (the private copies of images attached in the web UI) and checkpoints; checkpoints whose workspace is a temp directory or no longer exists; cost snapshots started in a burst (four or more in one minute, at most two requests each — a test suite, never a person) on prune only; task-graph runs past 30 days; live-dashboard spools (pulse) of every process that is no longer running, never one that is still recording; the CCR archive’s TTL and size cap and the hub’s idle TTL, swept when applied. Named sessions, distilled memory and user content are never touched. --apply without prune is refused. Marks a directory as trusted so its workspace files — the project .env, .chatcli/hooks.json and coder_policy.json — are loaded. Without trust, the REPL asks once per folder ([y/N], default No) and non-interactive modes never load them (a warning goes to stderr). See Non-interactive mode and the security hardening upgrade.| Form | Description |
|---|
chatcli trust [dir] | Trust dir (the current directory when omitted) | chatcli trust --list | List the directories currently trusted | chatcli trust --revoke [dir] | Revoke trust for dir (the current directory when omitted) |
Offline evaluation harness: runs a suite of cases through the real binary in throwaway sandboxes, grades them, and gates CI. Full guide: Evals.| Form | Description |
|---|
chatcli eval run [path] | Run, grade, report and gate. path is a suite file or directory, default ./evals | chatcli eval list [path] [--filter …] | The cases a run would execute | chatcli eval validate [path] | Parse and validate only. Boots no provider and spends nothing | chatcli eval compare <baseline.json> <current.json> | Compare two saved reports |
run flags: --provider/--model (candidate), --judge-provider/--judge-model, --trials, --concurrency (default 2), --filter id,tag:x, --timeout, --max-cost, --out, --markdown, --baseline, --max-regressions, --tolerance, --min-pass-rate (default 1.0), --with-memory, --keep, --json, --quiet, --bin. Exit codes: 0 ok, 1 pass rate below --min-pass-rate, 2 usage or invalid suite, 3 regression against --baseline. Provider plugins installed in ~/.chatcli/providers, without a REPL. Full guide: Provider Plugins.| Form | Description |
|---|
chatcli provider install <path|url> [--trust <fingerprint>] | Install a signed provider plugin bundle, trusting its publisher once (see Signature Verification) | chatcli provider list | Installed plugins with version, mode and login state, plus any that failed to load | chatcli provider login <name> [--input id=value]… | Log in; --input answers prompt fields so CI and servers need no person | chatcli provider logout <name> | Revoke the credential upstream (when supported) and delete it | chatcli provider test [flags] <plugin> [args…] | Run the conformance kit against a plugin binary over stdin/stdout, exactly as ChatCLI talks to it |
test flags: --input id=value (repeatable), --credential-file path (JSON credential instead of logging in), --model id, --timeout (default 30s), --json. Exit codes: 0 success, 1 failure (a check failed, a plugin failed to load, login failed), 2 usage error. Starts ChatCLI as a gRPC server for remote access (alias chatcli serve). Every flag has an environment variable that sets its default.| Flag | Env | Description | Default |
|---|
--port <int> | CHATCLI_SERVER_PORT | gRPC port | 50051 | --token <string> | CHATCLI_SERVER_TOKEN | Shared bearer token (callers get the admin role) | "" | --tls-cert <path> | CHATCLI_SERVER_TLS_CERT | TLS certificate (the server accepts TLS 1.3 only). Needs --tls-key: one without the other refuses to start instead of serving plaintext | "" | --tls-key <path> | CHATCLI_SERVER_TLS_KEY | TLS private key. Needs --tls-cert | "" | --tls-client-ca <path> | CHATCLI_SERVER_TLS_CLIENT_CA | CA bundle for client certificates; enables mTLS, every connection must then present a certificate. Requires --tls-cert and --tls-key | "" | --provider <name> | LLM_PROVIDER | Default LLM provider | First configured provider | --model <name> | — | Default model | Provider default | --metrics-port <int> | CHATCLI_METRICS_PORT | Prometheus /metrics and /healthz over plain HTTP, no authentication, on all interfaces; 0 disables it | 9090 | --shutdown-delay <dur> | CHATCLI_SERVER_SHUTDOWN_DELAY | How long the server keeps serving after SIGTERM, with health already NOT_SERVING, before it stops; lets a pod being replaced leave the Service endpoints and DNS before it refuses connections. 0 stops at once | 0 | --enable-reflection | CHATCLI_GRPC_REFLECTION=true | Registers gRPC server reflection; keep off in production | false | --fallback-providers <list> | CHATCLI_FALLBACK_PROVIDERS | Comma-separated provider chain, in order; installed only when at least two of the listed providers resolve | "" | --fallback-max-retries <n> | CHATCLI_FALLBACK_MAX_RETRIES | Retries per provider before moving on | 2 | --fallback-cooldown-base <dur> | CHATCLI_FALLBACK_COOLDOWN_BASE | Base cooldown after a provider failure | 30s | --fallback-cooldown-max <dur> | CHATCLI_FALLBACK_COOLDOWN_MAX | Maximum cooldown | 5m | --mcp-config <path> | CHATCLI_MCP_CONFIG | MCP servers config JSON (CHATCLI_MCP_ENABLED=true loads the default path) | "" | --watch-config <path> | CHATCLI_WATCH_CONFIG | Multi-target watcher config YAML | "" | --watch-deployment <name> | CHATCLI_WATCH_DEPLOYMENT | Single K8s deployment to monitor (enables the watcher) | "" | --watch-namespace <ns> | CHATCLI_WATCH_NAMESPACE | Namespace of that deployment | "default" | --watch-interval <dur> | CHATCLI_WATCH_INTERVAL | Collection interval | 30s | --watch-window <dur> | CHATCLI_WATCH_WINDOW | Observation window | 2h | --watch-max-log-lines <n> | CHATCLI_WATCH_MAX_LOG_LINES | Max log lines per pod | 100 | --watch-kubeconfig <path> | CHATCLI_KUBECONFIG | Kubeconfig | In-cluster or default |
CHATCLI_BIND_ADDRESS (unset means 127.0.0.1, or 0.0.0.0 inside Kubernetes) and CHATCLI_JWT_SECRET / CHATCLI_JWT_PUBLIC_KEY / CHATCLI_JWT_ISSUER / CHATCLI_JWT_AUDIENCE. On any bind that is not loopback the server refuses to start without a credential: a token, a client CA (mTLS) or JWT material that loads. JWT material that fails to load also stops the server when it is the only credential. The server answers the standard grpc.health.v1.Health service and /healthz on the metrics port, both without authentication. One grpc.health.v1.Health/Check against a ChatCLI server; the server image’s HEALTHCHECK. Exit 0 when the answer is SERVING, 1 otherwise (the reason goes to stderr), 2 on a usage error. Boots nothing else.| Flag | Default | Description |
|---|
-addr <host:port> | the local server’s port and bind | Server address | -service <name> | "" (the whole server) | Service to ask about, e.g. chatcli.v1.ChatCLIService | -timeout <dur> | 4s | How long to wait for the answer | -tls-cert <path> | the local server’s certificate | Certificate the server serves; turns TLS on and is the only one trusted | -tls-server-name <name> | the certificate’s first DNS name or IP | Name to verify it by | -tls-client-cert, -tls-client-key | CHATCLI_TLS_CLIENT_CERT, CHATCLI_TLS_CLIENT_KEY | Client pair for a server that requires mTLS |
CHATCLI_SERVER_* variables, overridden by the flags of the running chatcli server process, so the check follows a server configured either way. Details in Health checks. Connects to a remote server via gRPC.| Flag | Env | Description | Default |
|---|
<address> | — | Address (positional) | | --addr <host:port> | CHATCLI_REMOTE_ADDR | Address (flag) | "" | --token <string> | CHATCLI_REMOTE_TOKEN | Sent as authorization: Bearer; the shared token or a JWT | "" | --provider <name> | — | Override the server’s provider (DEVIN is not offered: the server image has no Devin CLI) | "" | --model <name> | — | Override the server’s model | "" | --llm-key <string> | CHATCLI_CLIENT_API_KEY | Your own LLM API key or OAuth token, forwarded to the server | "" | --use-local-auth | — | Use the credential from ~/.chatcli/auth-profiles.json | false | --tls | — | TLS 1.3, verified with --ca-cert or the system CAs; the connection is TLS even without it | false | --ca-cert <path> | — | CA certificate that verifies the server; implies --tls | "" | --client-id, --client-key, --realm, --agent-id | — | StackSpot credentials | "" | --ollama-url <url> | — | Ollama base URL | "" | -p <prompt> | — | Remote one-shot | "" | --raw | — | Unformatted output | false | --max-tokens <int> | — | Max tokens | 0 |
--tls the client still dials TLS with the system CAs; a plaintext server needs CHATCLI_ALLOW_INSECURE=true. A client certificate for mTLS comes only from CHATCLI_TLS_CLIENT_CERT and CHATCLI_TLS_CLIENT_KEY, together with --tls; there is no flag for it.The interactive session is bound to the server like the in-REPL /connect: the server’s plugins run remotely, /agent list and /agent skills add the server’s entries, /session offers remote sessions, /watch status queries the server’s watcher and /disconnect returns to the local provider. See Remote Connection. Monitors K8s workloads with AI.| Flag | Env | Description | Default |
|---|
--deployment <name> | CHATCLI_WATCH_DEPLOYMENT | Deployment (required unless --config) | "" | --config <path> | — | Multi-target watch config YAML | "" | --namespace <ns> | CHATCLI_WATCH_NAMESPACE | Namespace | "default" | --interval <dur> | CHATCLI_WATCH_INTERVAL | Collection interval | 30s | --window <dur> | CHATCLI_WATCH_WINDOW | Observation window | 2h | --max-log-lines <n> | CHATCLI_WATCH_MAX_LOG_LINES | Max log lines per pod | 100 | --kubeconfig <path> | CHATCLI_KUBECONFIG | Kubeconfig | In-cluster or default | --provider <name> | LLM_PROVIDER | LLM provider | .env | --model <name> | — | LLM model | Provider default | -p <prompt> | — | One-shot with K8s context | "" | --max-tokens <int> | — | Max tokens | 0 |
One-shot self-update for scripts and automation — the same flow as /update, without entering the REPL. Updates through the detected install channel (Homebrew, go install or verified binary self-replace); manual channels (Docker, source build) get instructions instead.| Argument | Description |
|---|
| (none) | Check and apply through the detected channel | check | Report only — never applies |
0 updated or already on the latest version (including check), 1 check/apply failure or a manual channel with a pending update, 2 invalid usage. See Auto-Update for channel detection and the verified self-replace pipeline.
Memory
| Command | Description |
|---|
/memory or /memory today | Show today’s notes | /memory yesterday | Show yesterday’s notes | /memory <date> | Show notes from a date (YYYY-MM-DD, YYYYMMDD, DD/MM/YYYY) | /memory week | Notes from the last 7 days | /memory longterm | MEMORY.md content (long-term facts) | /memory list | List all memory files (includes structured JSONs) | /memory load <date> | Load notes into conversation context | /memory profile | User profile (name, role, company, location, skills, certifications, goals, interests, directives, stances, milestones, environment; 🔒 marks sensitive fields) | /memory profile set <field>=<value> | Set/update a profile field. Lists upsert (restating supersedes the old entry); suffixes rewrite: goals_replace= overwrites all, goals_done=/goals_remove= delete. New keys: stance=position :: reason, milestone=, env_<key>=, directives=[scope:<project>] rule, sensitive_mark= | /memory remember <fact> | Explicitly add a long-term fact (accepts a [category] prefix) | /memory forget <substring> | Remove long-term facts containing the given substring | /memory topics | Tracked recurring topics | /memory projects | Tracked projects with status | /memory stats | Usage statistics (sessions, peak hours, errors, features) | /memory facts [category] | Facts with scores (filter: architecture, pattern, preference, gotcha, project, personal) | /memory timeline [q] | Dated episode history; q filters by time (“3 meses atrás”, “april”, “2026-04”) and/or content | /memory compact | Force memory compaction (LLM + old note cleanup) | /memory export [path] | Export facts, episodes, topics, projects, profile and explicit links as JSONL (sealed only with a key from CHATCLI_ENCRYPTION_KEY; plaintext with the default keychain key) | /memory import <path> | Merge a memory export; nothing is deleted | /memory recall <query> | Dry-run auto-recall with the reason behind each fact | /memory why | Why the last turn recalled what it recalled | /memory links <note> | Links (→), backlinks (←) and nearby notes of a note of the knowledge graph; the note is a node id, a fact id, a title/alias or [[a wikilink]] (completion offers the graph’s hubs) | /memory link <from> -> <to> [--rel <relation>] [--note <why>] | Draw an explicit link between two notes (persisted in links.json; → and quoted "a" "b" work too). An ambiguous name is refused with the candidate ids | /memory unlink <from> -> <to> [--rel <relation>] | Remove links you drew (both directions). Links derived from the data (tags, projects, wikilinks, mentions) are explained instead | /memory vault [status|sync [--force]|path] | The Obsidian vault of the graph (~/.chatcli/vault): last sync report, sync now (--force also regenerates notes you edited by hand), or print its directory |
Compaction and Rewind
| Command | Description | |
|---|
/compact | Automatic compaction (3-level pipeline) | | /compact <instruction> | Guided compaction — preserves specific information | | /autocompact [60% | 0.6 | 150k | default] | Show or set, for this session, how full the window gets before auto-compact fires (percent, fraction or token count; default restores the mode default: 75% in chat, 60% in coder) | Precedence: this override > the catalog’s per-model threshold > the mode default (0.75 chat, 0.60 agent/coder). | /rewind | Display checkpoint menu for restoration | | /rewind compact | Undo the latest compaction (auto, /compact or recovery); journal-backed after a resume | | | Esc+Esc | Quick shortcut for /rewind (2x Esc within 500ms, only when input is empty) | |
/compact accepts a natural language instruction. Example: /compact preserve file paths and decisions.
Keyboard Shortcuts
| Shortcut | Action |
|---|
| Alt/Option + arrows | Move cursor by word | | Ctrl + arrows | Move cursor by word | | Cmd + arrows / Home/End | Beginning/end of line | | Esc+Esc | Open rewind menu (double Esc within 500ms, only when input is empty) | / or /menu + Enter | Open the command palette (arrows to navigate) |
| Shortcut | Action |
|---|
| Alt + Backspace | Delete word to the left | | Ctrl + W | Delete word to the left | | Ctrl + K | Delete from cursor to end of line |
Automatic detection via Bracketed Paste Mode:
- Small pastes (150 chars or less): rendered normally
- Large pastes (more than 150 chars): placeholder
«N chars | M lines»
The actual content is preserved and sent when pressing Enter. |