> ## Documentation Index
> Fetch the complete documentation index at: https://continuum-three-olive.vercel.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# CLI

> The `continuum` terminal client — drive, watch, and script agent sessions from a shell, a script, or CI on macOS, Linux, and Windows.

`continuum` is the terminal client. It speaks the same wire protocol as the Mac, iPhone, and web apps, so a session you start from a shell shows up on your phone, and a session your Mac started is one `continuum sessions` away.

Everything it prints as a human table also prints as machine JSON with `--json`, which is the point: this is the client you script against.

<Note>
  The CLI is in **beta**. It is newer than the Mac and iPhone apps and still moving; expect the occasional rough edge.
</Note>

## Install

The installers are user-local — no `sudo`, no system directories touched. They resolve the newest CLI release, verify the archive against the checksums published with it, and atomically replace any existing binary.

<Tabs>
  <Tab title="macOS · Linux">
    ```bash theme={"dark"}
    curl -fsSL https://continuumcode.ai/install-cli.sh | sh
    # continuum installed to ~/.local/bin
    ```

    Prefer to read the script before running it, or pin a version:

    ```bash theme={"dark"}
    curl -fLO https://continuumcode.ai/install-cli.sh
    sh install-cli.sh --version 0.73.0
    sh install-cli.sh --version 0.73.0 --install-dir "$HOME/bin"
    ```
  </Tab>

  <Tab title="Windows">
    ```powershell theme={"dark"}
    Invoke-WebRequest https://continuumcode.ai/install-cli.ps1 -OutFile install-cli.ps1
    .\install-cli.ps1
    # continuum.exe installed to %LOCALAPPDATA%\Continuum\bin
    ```

    Pin a version with `-Version`, or change the destination with `-InstallDir`.
  </Tab>
</Tabs>

Neither installer edits your `PATH`. Both tell you to add the install directory if it is not already there.

Six archives ship per release, covering **macOS, Linux, and Windows** on both **x64 and arm64**. Windows gets a `.zip`; macOS and Linux get a `.tar.gz` so the executable bit survives.

<Warning>
  CLI archives are **not code-signed** — the release pipeline has no cross-platform signing certificate, and `manifest.json` says so explicitly. The SHA-256 checks detect accidental corruption; they do **not** authenticate the origin, because anyone who can replace the archive can replace its checksum too. GitHub's keyless build provenance is attached to the release artifacts on a best-effort basis. Verify the release origin yourself until Continuum ships a real release-signing trust root.
</Warning>

### Updating

Automatic updates are deliberately off for the same reason. Updating is an explicit opt-in:

```bash theme={"dark"}
continuum update --version 0.73.0 --check   # inspect that release's manifest
continuum update --version 0.73.0           # verify and replace the binary
```

A read-only or system-installed binary is never replaced — use the user-local installer instead. If you have your own signing setup, `CONTINUUM_UPDATE_MINISIGN_PUBLIC_KEY` makes the updater require a `minisign` signature, and `--require-signature` makes it fail closed.

## Connecting to a daemon

Every command resolves a daemon the same way. Direct HTTP defaults to `127.0.0.1:21731` — the canonical port for the Mac app's daemon and for a headless `continuum-agent`.

| What         | Resolution order                                                                                                                                      |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| Host / port  | `--profile`, else `CONTINUUM_PROFILE`, else the current profile · overridden by `--host` / `--port` · `CLAWDMETER_HTTP_PORT` changes the default port |
| Bearer token | `--token`, else `CONTINUUM_TOKEN`, else `<dataDir>/agent-token`                                                                                       |
| Data dir     | `CLAWDMETER_DATA_DIR`, else `~/.clawdmeter` (`%USERPROFILE%\.clawdmeter` on Windows)                                                                  |

A missing token gives you a clear `unauthorized` error rather than a silent failure.

<Tip>
  `~/.clawdmeter` is where a standalone daemon keeps its state. The [desktop app](/docs/surfaces/desktop) bundles its own daemon, which keeps state inside the app's data directory and binds a loopback port assigned at launch rather than the default `21731`. To drive it, set `CLAWDMETER_DATA_DIR` to that folder (or point `--token` at the `agent-token` inside it) and pass the port it actually bound with `--port`.
</Tip>

### Named profiles

```bash theme={"dark"}
continuum config set work --host 100.64.0.5 --port 21731 \
  --provider codex --account codex/work --model gpt-5.6-sol \
  --mode worktree --effort xhigh
continuum config list
continuum config use work
continuum sessions --profile work
```

Profiles hold non-secret connection metadata and new-session defaults, stored in your OS config directory (`~/Library/Application Support/continuum/config.json` on macOS, `~/.config/continuum/config.json` on Linux, `%AppData%\continuum\config.json` on Windows). **The file never accepts or stores bearer tokens.** Explicit flags always beat a profile's defaults.

### Reaching a host that isn't directly routable

`--relay` carries every request over the encrypted relay instead of direct HTTP — the same ChaCha20-Poly1305 channel the web app and iPhone use. The credential is the daemon's own `relay-pairing.json`: on the daemon's own box, bare `--relay` finds it; from another machine, copy it over and point at it with `--relay-pairing <path>` (which implies `--relay`).

Guard that file like a credential — it *is* one. One limit worth knowing: a relay request must fit a single 32 KiB frame, so a very large prompt body should go over the direct path.

## Commands

### Sessions

`session` is the canonical group; the older top-level verbs remain as aliases.

```bash theme={"dark"}
# Create in an existing repo, after the daemon validates provider/model/account.
continuum new -repo /src/project -provider claude -model opus -effort high

# Let the daemon own a worktree, and deliver the opening prompt with it.
continuum new -cwd /src/project -agent codex -effort xhigh \
  -worktree -base-branch main -prompt "Implement the fix"
```

| Command                                                         | Does                                                          |
| --------------------------------------------------------------- | ------------------------------------------------------------- |
| `continuum sessions`                                            | List managed sessions, live first (`--all` includes archived) |
| `continuum session show <id>`                                   | The canonical session record                                  |
| `continuum session new …`                                       | Create, after provider/model/account preflight                |
| `continuum send <id> <text…>`                                   | Deliver a prompt, with an idempotency key                     |
| `continuum session interrupt <id>`                              | Interrupt the active turn; the session stays available        |
| `continuum session stop <id>`                                   | Stop the process, keep the session                            |
| `continuum session rename <id> <name>`                          | Set the display name                                          |
| `continuum session archive <id>` / `unarchive <id>`             | Change archive state, idempotently                            |
| `continuum session delete --yes <id>`                           | Permanently delete                                            |
| `continuum session model <id> <model>` / `effort <id> <effort>` | Change model or reasoning effort                              |
| `continuum session mode <id> <local\|worktree>`                 | Switch workspace mode                                         |
| `continuum resume <id>`                                         | Continue the conversation as a new managed session            |
| `continuum attach <id>`                                         | Full-duplex terminal attach (relay only)                      |

Session creation is transport-only — the daemon does every process, repository, and worktree operation. If a provider has more than one account and you name none, creation **fails** rather than quietly billing the wrong subscription.

### Review and status

| Command                  | Does                                                                  |
| ------------------------ | --------------------------------------------------------------------- |
| `continuum diff <id>`    | Unified git diff for the session's worktree                           |
| `continuum pr <id>`      | PR status — title, state, checks, mergeability                        |
| `continuum usage`        | Live per-provider gauges: session and weekly percentages, reset times |
| `continuum context <id>` | Context-window fill, turn count, last-turn duration                   |
| `continuum providers`    | Per-provider availability and auth state                              |
| `continuum accounts`     | Multi-account rows                                                    |

Because every one of these takes `--json`, they compose:

```bash theme={"dark"}
continuum usage --json | jq '.gauges[] | select(.weeklyPct > 80)'
continuum sessions --json | jq -r '.[].id'
```

### Approvals and questions

```bash theme={"dark"}
continuum permissions list
continuum permissions respond <sessionId> <optionId>
continuum questions list
```

Destructive permission choices require `--confirm-destructive`. `questions` handles the structured AskUser forms an agent raises mid-run.

### Frontier groups

Run the same prompt across two or three provider/model/effort slots and keep the best answer:

```bash theme={"dark"}
continuum frontier create --slot claude:opus:high --slot codex:gpt-5.6-sol:xhigh
continuum frontier send <groupId> "Implement the fix"
continuum frontier pick-winner --yes <groupId> <childIndex>
```

`pick-winner` continues from one child and archives the others, so it requires `--yes`. `turn-winner` records a per-turn preference without destroying anything.

### Cross-provider memory

`continuum memory` stores durable learnings — conventions, decisions, debugging workflows — per repo or globally on the daemon, then materializes them into every new session's `CLAUDE.md` / `AGENTS.md` so **every** provider reads them natively. No single underlying CLI can do that.

```bash theme={"dark"}
continuum memory enable      # review the disclosure and opt in
continuum memory remember "the parser lives in parser.go; dedupe by messageId"
continuum memory remember "prefer ripgrep over grep" --global
continuum memory search parser
continuum memory flush <sessionId>   # summarize a session into repo memory
continuum memory disable     # opt out and scrub every materialized copy
```

It is **off by default** and asks for consent on first use, because memory captured from one provider is deliberately shared with all of them, and `flush` sends transcript text to an LLM for summarization. Storage is daemon-private (`<dataDir>/memory/`, mode `0600`) and bounded so materialization never blows the agent's context. A repo you never add memory to is never written to.

### The TUI

```bash theme={"dark"}
continuum tui                 # opens on the most-recent session
continuum tui --session <id>  # opens directly on one
```

A full terminal workbench: session list on the left, transcript and composer in the middle, a review pane on the right.

| Key                 | Action                                                                                                 |
| ------------------- | ------------------------------------------------------------------------------------------------------ |
| `↑` / `↓` + `Enter` | Pick a session, or choose a permission response                                                        |
| `Tab`               | Move focus between the session list and the composer                                                   |
| `Enter`             | Send the prompt (in the composer)                                                                      |
| `n`                 | New session, using the same preflight as `session new`                                                 |
| `/`                 | Command palette — `/diff` `/pr` `/usage` `/new` `/interrupt` `/theme` `/help`, plus your host's skills |
| `@`                 | Mention picker — open sessions, and files or artifacts the agent cited                                 |
| `d` / `p` / `u`     | Right pane: diff / PR / usage                                                                          |
| `c`                 | Return the pane to the session transcript                                                              |
| `t`                 | Attach the terminal to the session's pane (relay only; `Ctrl+]` detaches)                              |
| `T`                 | Cycle the color theme                                                                                  |
| `Ctrl+C`            | Interrupt a streaming turn, else quit                                                                  |

The transcript renders markdown, reasoning, bounded tool calls and results, plans, todos, sources, artifacts, and structured question forms. Pending permissions arrive as a first-class option card; a destructive choice needs a second `Enter`. `/remember` and `/flush` route to memory rather than to the provider. Narrow terminals hide the sidebar and keep the transcript usable.

### Shell completions

```bash theme={"dark"}
source <(continuum completion bash)
continuum completion zsh > "${fpath[1]}/_continuum"
continuum completion fish > ~/.config/fish/completions/continuum.fish
```

```powershell theme={"dark"}
continuum completion powershell | Out-String | Invoke-Expression
```

## The daemon behind it

The CLI ships out of the same Go codebase as `continuum-agent`, the headless daemon that hosts sessions on a box. They are two separate executables with different jobs:

* **`continuum`** is the client — it drives a daemon over HTTP or the relay, and runs everywhere.
* **`continuum-agent`** is the daemon — it owns the processes, the repos, and the worktrees.

The [Windows and Linux desktop app](/docs/surfaces/desktop) bundles both, which is why the CLI is already on any machine where you installed the desktop app. On a headless Linux VPS you install `continuum-agent` on its own and it becomes an execution host your other clients can target — see [Remote devices](/docs/features/remote-devices).