iframe-proxy | Sunbelt Computer Software

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
`/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)
`/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

Items come live from the same autocomplete engine the prompt uses — models, sessions, config sections, providers, files — so the palette and <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

“Run as-is” entry (↵): 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 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)

Patterns use prefix matching on <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`

Full rule schema and examples: MCP Config — Trigger rules.

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

Full reference: Agent Harness/Quality Pipeline · Configuration

`/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 and live graph node/edge stats
`/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

Precedence: setting (db) > 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

Supported providers are keyless: 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)

The /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`, `snapshot`, `click`, `type`, `scroll`, `eval`, `screenshot`, `console`, `network`, `back`, `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`, `status`, `logs`, `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`, `list`, `mark`	Atomic Tools
`@websearch`	`search`	Web Tools
`@webfetch`	`fetch`	Web Tools
`@scheduler`	`schedule`, `wait`, `query`, `list`, `cancel`	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`, `forget`, `profile`, `timeline` (dated episodes), `neighbors`, `map` (knowledge graph)	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`, `get`, `toc`	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.

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

Stores: costs, checkpoints, sessions, transcripts, parked, memory-pending, attachments, taskgraph, pulse, ccr, hub; every other store (memory, 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

Main 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

There are no flags for the bind address or for JWT: use 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

The local server’s settings come from its 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`

Without --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

Exit codes: 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 and profile 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

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

Navigation
Editing
Paste

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.

Sunbelt Computer Software

PL/B Language Development and Support

Get started

Documentation

Complete Command Reference

Internal Commands (`/`)

Interactive Command Palette

External subcommand `chatcli daemon`

External subcommands `chatcli mcp-server` and `chatcli acp`

`/config security` — mutable rules

`/channel` — MCP channels inbox and triggers

Harness/Quality Pipeline — At a Glance

`/reflect` — subcommands

`/config` — Panorama and Sections

`/config hub` — mutable settings

`/websearch` — Web Search Provider

Provider and Model Switching (`/switch`)

Context Commands (`@`)

LLM-callable plugins (`@<tool>`)

Agent Mode — Actions

Sessions (`/session`)

Persistent Contexts (`/context`)

Skills (`/skill`)

Command-Line Flags (One-Shot)

Subcommands

Memory

Compaction and Rewind

Keyboard Shortcuts

Sunbelt Computer Software

PL/B Language Development and Support

​Internal Commands (/)

​Interactive Command Palette

​External subcommand chatcli daemon

​External subcommands chatcli mcp-server and chatcli acp

​/config security — mutable rules

​/channel — MCP channels inbox and triggers

​Harness/Quality Pipeline — At a Glance

​/reflect — subcommands

​/config — Panorama and Sections

​/config hub — mutable settings

​/websearch — Web Search Provider

​Provider and Model Switching (/switch)

​Context Commands (@)

​LLM-callable plugins (@<tool>)

​Agent Mode — Actions

​Sessions (/session)

​Persistent Contexts (/context)

​Skills (/skill)

​Command-Line Flags (One-Shot)

​Subcommands

​Memory

​Compaction and Rewind

​Keyboard Shortcuts

Internal Commands (`/`)

Interactive Command Palette

External subcommand `chatcli daemon`

External subcommands `chatcli mcp-server` and `chatcli acp`

`/config security` — mutable rules

`/channel` — MCP channels inbox and triggers

Harness/Quality Pipeline — At a Glance

`/reflect` — subcommands

`/config` — Panorama and Sections

`/config hub` — mutable settings

`/websearch` — Web Search Provider

Provider and Model Switching (`/switch`)

Context Commands (`@`)

LLM-callable plugins (`@<tool>`)

Agent Mode — Actions

Sessions (`/session`)

Persistent Contexts (`/context`)

Skills (`/skill`)

Command-Line Flags (One-Shot)

Subcommands

Memory

Compaction and Rewind

Keyboard Shortcuts