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

# ade CLI

> The ade command is the typed control plane for ADE from any shell — the same lanes, chats, PRs, and tests, scriptable for humans and agents alike.

`ade` is the typed control plane for ADE. Everything you do in the desktop app — create lanes, run agents, ship PRs, kick off tests, attach Linear issues — has a CLI command, so you can drive ADE from any shell. Agents running inside ADE use the same commands, which is how they inspect and operate the workspace they live in.

```bash theme={null}
ade lanes create "fix-checkout-flow"   # spin up a worktree for a task
ade brain status --text                # check the machine runtime
```

> [!TIP]
>
> Two commands discover everything: `ade <group> --help` for exact flags on any command, and `ade actions list --text` for the full service-backed action catalog behind the typed commands.

## Output modes

Most commands take an explicit output mode. Use `--text` for a human-readable summary and `--json` for stable, scriptable fields (the default when output is piped).

```bash theme={null}
ade lanes list --text   # readable summary
ade lanes list --json   # stable JSON for scripts and agents
```

## Command groups

> [accordion] Project & lanes
>
> Register projects and manage worktrees (lanes).
>
> ```bash theme={null}
> ade init                                # add the current directory as a project
> ade projects list --text                # list registered projects
> ade lanes list --text                   # list lanes in the active project
> ade lanes create "fix-checkout-flow"    # create a lane from the default branch
> ade lanes create --name auth-ui --from auth-base --on local
> ade lanes delete <lane-id> --force --delete-branch
> ```

> [accordion] Chats & sessions
>
> Start and inspect agent chats, terminals, and CLI sessions inside a lane.
>
> ```bash theme={null}
> ade chat list --lane <lane-id> --text
> ade chat create --lane <lane-id> --model gpt-5.5
> ade shell start-cli codex --lane <lane-id> --permission-mode edit --message "fix failing tests"
> ade shell start --lane <lane-id> -- npm test
> ```

> [accordion] Git & PRs
>
> Commit, push, and turn a lane into a pull request; read CI and comments.
>
> ```bash theme={null}
> ade git commit --lane <lane-id>
> ade git push --lane <lane-id>
> ade prs create --lane <lane-id> --base main --title "Fix checkout flow" --text
> ade prs list-open --text
> ade prs checks <pr> --text              # CI status for a PR
> ade prs comments <pr> --text
> ```

> [accordion] Tests
>
> Run test suites in a lane.
>
> ```bash theme={null}
> ade tests run --lane <lane-id> --suite unit --wait
> ```

> [accordion] Linear
>
> Attach and update Linear issues through ADE's own Linear connection — no API key needed.
>
> ```bash theme={null}
> ade lanes create --name ENG-431 --issue-id ENG-431 --start-chat --provider codex --type subagent
> ade linear attach --this-session --issue-id ENG-431
> ade linear comment "Pushed a fix; CI running"
> ade linear set-state ENG-431 <state-id>
> ```

> [accordion] Account & machines
>
> Link this machine to your ADE account so you can reach it from ADE desktop,
> the web client, and iOS. `ade connect` is idempotent — re-running it on a
> connected machine just prints status.
>
> ```bash theme={null}
> ade connect                             # sign in, install the service, publish this machine
> ade connect --status --text             # report the three steps, change nothing
> ade connect --headless                  # sign in from another device: QR code, link, and code
> ade connect --no-login                  # service only; stay local/LAN-only
> ade connect --no-service                # account only; skip the login service
> ade connect --timeout 120               # seconds to wait for the machine row (default 60)
> ade login                               # sign in without touching the service
> ade machines list --text                # machines registered to this account
> ade machines reconnect                  # re-pair this machine after it was removed
> ade logout                              # undo the account half of connect
> ```
>
> The machine row is published by the running brain, not by this command — so
> the brain must stay running for the machine to remain reachable. Full
> walkthrough, including running the brain on a Linux server:
> [Connect a machine](https://ade-app.dev/docs/getting-started/connect-machine.md).
>
> Removing a machine from your account is deliberate and terminal: heartbeats
> never re-register it, and its Activity, notifications, and Live Activities
> stop. `ade machines reconnect` is the way back. It takes no selector — it
> always re-pairs the machine you run it on — and it needs proof of a freshly
> completed interactive sign-in, so it prompts for one when the account
> directory asks and finishes the re-pair as soon as that lands. Only once the
> directory accepts does it lift the push gate, so Activity, alerts, and
> badges resume without restarting the brain. A normal `ade login` runs the
> same repair automatically, and ADE desktop offers it as **Reconnect this
> computer** in Settings.

> [accordion] Brain & pairing
>
> Control the machine-owned ADE runtime (the brain) and pair a phone.
>
> ```bash theme={null}
> ade brain status --text                 # endpoint, service, and sync state
> ade brain start                         # load the login service
> ade brain stop                          # unload the login service
> ade brain restart                       # re-exec after an app update
> ade brain pin generate                  # generate a phone pairing PIN
> ade brain pin set 123456                # set an explicit pairing PIN
> ```

> [accordion] Proof
>
> List the computer-use proof artifacts ADE captured for a chat or session.
>
> ```bash theme={null}
> ade proof list --arg ownerKind=chat --arg ownerId=<session-id>
> ```

> [accordion] Discovery
>
> Find commands, flags, and the full action catalog, and check local readiness.
>
> ```bash theme={null}
> ade <group> --help                      # exact flags for any command
> ade actions list --text                 # full service-backed action catalog
> ade actions run git.stageFile --arg laneId=<lane-id> --arg path=src/index.ts
> ade doctor                              # local runtime, git, provider readiness
> ade triage                              # hand a broken install to a coding agent ADE has downloaded
> ade triage --agent --text               # print the context + playbook paths instead of launching one
> ade skill list --text                   # bundled agent skills
> ```

> [!NOTE]
>
> Prefer typed commands — they validate arguments and return stable fields. Reach for `ade actions run <domain.action>` only when no typed command covers the workflow yet.

## Full reference

For every command, subcommand, flag, and the runtime modes behind them, see the complete CLI README on GitHub.

> [card] [ade CLI README](https://github.com/arul28/ADE/blob/main/apps/ade-cli/README.md)
>
> The full `ade` command reference, runtime modes, and install paths.

> [card] [Architecture](https://ade-app.dev/docs/architecture.md)
>
> How the control plane, runtime, and clients fit together.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.