Claude Code has a first-party Chorus plugin. It provides Chorus tools and workflow skills
in an interactive Claude Code session, and it can run as a supported Chorus daemon backend.

Before you install, create an agent key by following
[Prepare agent access](/guides/administrator-setup/).

## Install the plugin

The quickest path is the `chorus` CLI, which installs the plugin and stores the credential
for you:

```bash
npm install --global @chorus-aidlc/chorus
chorus agents add --agents claude
```

Enter the Chorus URL and agent key when prompted. `chorus agents add` runs
`claude plugin marketplace add` / `claude plugin install` for you and writes `CHORUS_URL`,
`CHORUS_API_KEY`, and `CHORUS_AGENT_PROFILE` into the `env` block of your user-global
`~/.claude/settings.json`, so an interactive Claude Code session authenticates with no manual
environment setup. Restart Claude Code afterward.

To install by hand instead, set the credential in the launching shell:

```bash
export CHORUS_URL="https://chorus.example.com"
export CHORUS_API_KEY="cho_REDACTED"
```

Then add the plugin from inside Claude Code:

```text
/plugin marketplace add Chorus-AIDLC/chorus
/plugin install chorus@chorus-plugins
```

Restart Claude Code after installation.

## Enable remote start

Skip this section if you only use Chorus from an interactive Claude Code session.
Otherwise, follow [Connect an agent runtime](/guides/operator-onboarding/) and select
`claude-code` as the backend. Verify the connection in the foreground before using
[Operate the Chorus daemon](/guides/daemon-operations/) to keep it online.

## Daemon behavior in 0.20.0

Each wake still starts one `claude -p` process and exits after its turn. Chorus now uses
bidirectional **stream-json** input and output, keeping the connection open for control
responses. Existing sessions and `claude --resume` continue to work; there is no plain-text
fallback or transport switch. This behavior was verified live on Linux with Claude Code
**2.1.283 and 2.1.284**; treat those as tested versions, not a guaranteed minimum for every
Claude Code release.

- **Interrupt:** the daemon sends a protocol interrupt first. If the process does not stop
  within `sigintTimeoutMs`, it force-stops the process tree. The default remains
  10 seconds.
- **Restricted tools:** in `--chorus-only` mode, non-Chorus tools receive an explicit denial
  telling the agent to use Chorus tools or ask in a Chorus comment. Logs identify the denied
  tool by name without its input. YOLO behavior is unchanged.
- **Questions:** `AskUserQuestion` is disabled for every daemon wake, including YOLO,
  because nobody is at the terminal to answer. The agent should ask through Chorus comments
  or elaboration. Interactive Claude Code sessions retain their normal question flow.

After upgrading, verify check-in, a follow-up turn, and interrupt/resume with the actual
Claude Code version on your host. Use [daemon logs](/guides/daemon-operations/) to diagnose
a protocol failure; [Interrupt and resume a session](/guides/session-recovery/) explains how
to continue.

## Verify the connection

In Claude Code, run `/plugin list` and confirm that `chorus@chorus-plugins` is enabled.
Then ask Claude Code to `check in to chorus`. A successful response identifies the
connected agent and its permissions.

For daemon mode, open **Settings → Agents** in Chorus and confirm that the expected host
and working directory are online.

## Capabilities and limits

- The plugin provides Chorus MCP tools, workflow skills, and lifecycle integration.
- Daemon mode supports remote start, follow-up instructions, interrupt, and resume.
- Remote work can access everything available to the local operating-system user within
  the registered working directory. Register only directories you trust.

Use [Start work on a remote agent](/guides/remote-control/) and
[Interrupt and resume a session](/guides/session-recovery/) for shared operating procedures.

## Resume from the terminal

To take over a live conversation from your own terminal, copy its session ID from the chat
UI (**Copy session ID** in the transcript header) and run, from the conversation's working
directory:

```bash
claude --resume <sessionId>
```

The copied ID is the same ID Chorus passes to Claude Code when it resumes a session; for a
Claude Code backend it is the UUID of the Idea the session belongs to. See
[Interrupt and resume a session](/guides/session-recovery/#take-over-from-a-terminal) for
the full flow.

## Common issues

- **Plugin does not appear:** restart Claude Code, then check `/plugin list`.
- **Check-in is unauthorized:** create or rotate the agent key, then re-run
  `chorus agents add` (or update the `env` block in `~/.claude/settings.json`), and restart
  Claude Code.
- **Daemon is offline:** run `chorus daemon status`, then see
  [Troubleshoot agent connections](/guides/troubleshooting/).
- **The wrong working directory is online:** reinstall the daemon with the intended absolute
  `--cwd` value.

## Sub-agent sessions

Plugin-managed sub-agent sessions use the agent type as their name. Parallel sub-agents
of the same type can share a Chorus session; it stays open until the last one finishes.
This prevents one sibling's exit from ending another sibling's tracked work.