Interrupt and resume a session

Use these controls when an agent is taking the wrong approach, waiting indefinitely, or needs additional direction. They act on an existing conversation; use Start work on a remote agent to create a new one.

Hermes recovery

Restore the original Hermes gateway, not the Chorus daemon. Interrupt cancels gateway work; Resume requires a server with Hermes continuation-turn support and keeps the original repository. Inspect partial changes before resuming.

Background agents (0.22.0)

Claude daemon wakes wait up to 60 minutes (3600000 ms) after the main turn for background children. CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS takes precedence over CHORUS_CLAUDE_BG_WAIT_CEILING_MS. This is not a whole-wake timeout. Parents must collect completion or explicitly stop their children before ending the turn. Forced background termination is abnormal even with a raw zero exit code; Chorus attempts to comment on the triggering idea/task without repairing task status or retrying automatically. See daemon timeout settings for zero/empty-value risks, configuration, and diagnostics.

Interrupt active work

1. Open the running conversation.
2. Review the latest output to confirm an interrupt is necessary.
3. Select Interrupt.
4. Wait for the conversation to report that execution has stopped.

A running conversation shows its active turn, elapsed time, and Interrupt control.

Each conversation has its own controls. Interrupting a Task: or Review: child conversation stops only that work; the idea’s conversation and other child conversations keep running. Some runtimes, such as OpenClaw and Hermes, still keep one conversation per idea.

Interrupt first asks the agent process to stop gracefully. If it does not stop within the configured timeout, the daemon ends the process.

An interrupt does not undo work

Files, commands, comments, and external actions completed before the interrupt remain in place. Review the partial result before starting another execution.

When a conversation stays running

If the process has finished but the conversation still says Running, select Interrupt in that conversation. The control is available even when no live execution is listed. If Chorus has no live run to stop, it can mark the turn interrupted directly; otherwise it forwards the request to the daemon and waits for the stop report.

Chorus retries reporting that a turn finished after temporary failures, and treats the agent as finished once its process exits, even if a background process it started is still running. None of this limits how long a turn may run, but backend limits still apply: DeepSeek Harness (dsh) defaults to 30 minutes per turn, configurable through CHORUS_DSH_TIMEOUT_MS. Check the final output and any remaining processes before resuming.

Read a failed turn’s diagnostics

From Chorus 0.21.0, a failed startup or execution shows an Agent wake failed summary in its conversation turn, even when the agent produced no reply. Select Show error details when available to inspect captured diagnostic output, exit code, or signal. These diagnostics are saved with the turn and remain available after refreshing or reopening the conversation.

Details are not always available. Older turns or failures without captured diagnostics show a fallback explanation; a user-requested interrupt is not a crash. Use the summary to check the working directory, backend login/model configuration, or credentials, and consult chorus daemon logs if needed. Inspect partial changes before resuming: failure does not undo files or external actions. From Chorus 0.22.2, the daemon replaces known credentials, such as the agent’s Chorus key and credential-like environment values, with [redacted] before it saves the details, including a key cut at the truncation boundary. This covers known credentials only. Diagnostic text can still contain other sensitive information, so review and redact it before sharing.

Mention recovery (0.22.1)

If a comment or mention reaches the daemon but fetching or routing it fails, the daemon keeps the wake context and retries with bounded backoff, independently of the SSE connection’s health. When the server is reachable again the wake is queued once; you do not need to send a chat message or restart the daemon. Each wake’s status is recorded on the exact turn that triggered it, so a later chat message and the original comment keep separate turns and transcripts. See daemon operations.

Inspect the partial result

Before resuming:

• read the final agent output and error details;
• inspect changed files and any running processes;
• decide whether to continue, provide a corrected instruction, or discard the partial changes using your normal version-control workflow.

Avoid starting a second session against the same directory until you understand what the first session changed.

Resume the conversation

When the conversation is interrupted or recoverable after a crash:

1. Restore the original daemon connection if it is offline.
2. Open the same conversation.
3. Add any correction or missing context.
4. Select Resume.

Resume continues the same conversation, whether it is the idea’s conversation or a task or review child conversation. A child conversation has no reply box, so select Resume there directly and send any correction from the idea’s conversation. Resume uses the original agent connection and working directory. It does not migrate the session to another machine or directory. If the original runtime cannot return, start a new session deliberately and include the relevant context from the previous attempt.

For repeated failures, use Troubleshoot agent connections.

Take over from a terminal

You can continue a conversation from your own terminal instead of the in-UI Resume button. Open the conversation and select Copy session ID in the transcript header. This copies the session ID that the agent CLI itself uses to resume, so a manual resume rejoins the same conversation rather than starting a fresh one.

From the working directory the conversation ran in, pass the copied session ID to your backend’s resume command:

• Claude Code — claude --resume <sessionId>
• Codex — codex exec resume <thread_id>
• Kiro — kiro-cli chat --resume-id <sessionId>

Each backend has its own ID format, so the copied value is whatever that backend accepts. See your platform’s reference page for the exact command: Claude Code, Codex, and Kiro.

Chorus keeps one main conversation per agent per idea. If you start work on the idea from a different working directory, Chorus moves that conversation there instead of starting a new one — so each agent always has exactly one idea conversation to take over, wherever it last ran. Task and review child conversations have their own session IDs: copy the ID from the child conversation you want to continue, not from the idea’s conversation. See the Online agents overview for the full model.