<!-- Source: https://console.uubright.com/docs/tasks/ -->
# Run and control tasks

## When an agent hits its usage limit

A usage limit opens a decision card in the task and **Needs you**, with a push notification under the usual decision notification policy. It shows the reported reset time and offers **Continue with Codex** (or Claude for a Codex task), **Continue on Claude API** for Claude tasks, and **Wait for the reset**. When a Zhipu GLM key is saved, it also offers **Switch to GLM**, which starts one new task on GLM and does not become the automatic choice. A paired device can make the choice. Saving a new Anthropic API key, making Claude API the automatic choice, and raising the API spend cap are owner-only.

Continuing with the other agent saves uncommitted repository work in a WIP commit, pushes the old branch, and starts a new task from it. The new task keeps the Manager relationship, permission mode when supported, and PR links. The old task stops and links to the new one; **Undo** stops the new task and resumes the old one. Switching agents starts a fresh conversation from a handoff note.

Claude API continuation restarts the same task with its saved Anthropic API key or Bedrock access, preserving its conversation. Each workspace has an API spend cap based on the task's reported cost (default $20); reaching it asks again. **Do this automatically next time** saves a workspace policy. In **Workspace settings**, both the Manager and workers default to asking, so nothing continues on a paid API key unless you choose it. You can change either to the other agent, API, wait, or ask. Connect your model says this next to the API key field.

A task is one Claude Code session with its own workspace and conversation. This
page covers the choices you make when starting a task and the controls you use
while it runs.

## Structured brief and PR handoff (beta)

An owner can choose **Start from a GitHub issue** in New task. Select a saved project, enter its canonical `https://github.com/OWNER/REPO/issues/N` URL, and write the goal, constraints, acceptance criteria, and approval boundaries. Confirm the brief before starting. The goal becomes the task's first instruction; the source URL and the four authored fields are saved together with the task. The issue's text is not fetched. The source link appears in task Details beside the brief and in the PR handoff view. The issue repository must exactly match the selected project's GitHub repository. Paired devices and task tokens cannot use this intake; ordinary task creation stays available.

Open a task's **Details**, then choose **Add** or **Edit** under **Task brief** to enter its goal, constraints, acceptance criteria, and approval boundaries. The fields start empty and are never filled from the task's prompt or transcript. The owner can edit them in the task view. The task's own author token can edit only that task's brief through `PUT /api/sessions/:id/brief`; another task, a reviewer, and a paired device cannot edit it. Each field is limited to 2,000 characters.

For a tracked open pull request, **Author handoff** records what changed, tests and check evidence, remaining uncertainty, and the next owner decision. It is separate from the independent reviewer verdict. A handoff requires the tracked PR URL and its full current head SHA through `PUT /api/sessions/:id/pr-handoff`. When PR watch sees a new head, the old handoff is immediately marked **Stale** until the author or owner updates it. It does not satisfy review, check, permission, or merge gates. These fields are authored explicitly; no raw prompt text is copied into them or into the edit history. Do not paste private prompt excerpts into these fields; prompt sharing requires a separate consent flow.

The handoff can also list **Acceptance criterion evidence** entries. Each names the criterion, linked PR, full commit SHA, check/test or validation evidence, status (`implemented`, `verified-with-evidence`, or `still-needs-real-world-validation`), and next responsible role or person. Verified entries need evidence. An old entry stays visible and becomes stale after a push; add evidence for the new head before treating it as current. The author can add entries in the task's PR details or send a `criteria` array in the handoff API. These authored claims never become independent reviewer verdicts.

**Review history** on the PR shows each reviewer's task, agent, time, outcome, and full reviewed head. A stopped attempt shows a safe reason, such as “Reviewer login expired”; it is separate from a code FAIL. The current or stale independent verdict and one next action with its responsible role appear there too. A recorded PASS remains visible if the Manager wakes later; the review loop deduplicates Manager wakes and owner notifications. On a local or designated Worker FAIL, the server queues one sanitized repair brief for the author at that head. The Manager can inspect the reviewer task's safe `handoff` or `reviewHandoffs` status (`queued`, `awaiting_author`, or `new_head`) and verdict, delivery, and next-head timestamps through `task_status` or `task_wait`. The brief is retried after a delivery cap or restart and retired when the PR moves to a new head. Local review runtime ends with the reviewer turn; dispatch delay runs from verdict to delivery, and author wait from delivery to the next head. These timings do not include reviewer text or prompts. Check, risk, permission, and merge holds still apply.

A trusted reviewer's exact-head FAIL comment blocks a prior PASS and returns the next action to the author. A later PASS comment on that same head does not clear the FAIL. Commit-status provider errors appear only as “Commit status update unavailable”; provider error text is not put in the Board label, task summary, or Manager wake.

## Start a task

Select **New**, choose a **Repository task** or a **Scratch task** (an empty
folder), describe the outcome you want and how Claude should check it, then choose:

- **Model**: which model the agent runs, like the CLI's `/model`. See
  [Choose the model](#choose-the-model).
- **Permissions for this task**: how much Claude may do without asking you.
- **Response style**: how much Claude writes while it works.
- **Model access** (when a CCR gateway is configured, or a Zhipu GLM key is saved):
  your Claude account, the CCR gateway, or GLM. See [Switch models with CCR](https://console.uubright.com/docs/switch-models/)
  and [Zhipu GLM](https://console.uubright.com/docs/bring-your-own-model/#zhipu-glm).

Permissions and response style are fixed for the life of the task, including after
Stop and Resume; to change them, start a new task. Model access can change when you
resume a stopped task, and the model can change at any time.

A task starts a new conversation, unless you continue one you started yourself: see
[Continue a session you started yourself](#continue-a-session-you-started-yourself).

### Continue a session you started yourself

When tasks run directly on the computer (the desktop app's This Mac, or a server in
host mode), a task can pick up a Claude Code or Codex conversation you started in a
terminal or the Codex App, with its history. In **New task**, choose the project, open
**Continue a session…** and pick one. The list shows the newest sessions for the
project's folder and its Git worktrees (up to 30): what each was about, the agent, how
many messages it has and when it last changed. Picking one sets the task's agent; the
first message is optional.

The task continues a copy in its own worktree, so the original stays as it was and you
can keep using it where you started it:

- **Claude Code** sessions are found in `~/.claude/projects` (or `CLAUDE_CONFIG_DIR`).
  The session file is copied into the task worktree's project folder and Claude Code
  starts with `--resume <id> --fork-session`, which writes the continued conversation
  under a new session ID.
- **Codex** threads are found in `~/.codex/sessions` (or `CODEX_HOME`) by the folder
  they ran in, and forked with the app-server's `thread/fork`, with the task's worktree
  as the working folder. See [Codex host tasks](https://console.uubright.com/docs/codex/#continue-a-codex-thread).

A session that changed in the last two minutes is marked **may still be open**: it is
probably still running in a terminal or the Codex App. You can still continue it, but
what happens there afterwards doesn't reach the task. The list reads only the
summary of each session; nothing is moved or edited, and the file contents aren't
sent to your browser or phone.

There's nothing to continue, and the list says why, when:

- tasks run in Docker containers, which have their own agent logins and can't see
  the sessions on the server;
- the workspace uses its own Claude Code or Codex login (see
  [Workspaces](https://console.uubright.com/docs/workspaces/)): its tasks can't read sessions made with the computer's
  login. Use the host login for that agent, or continue from the Default workspace;
- the project is cloned from a URL for each task instead of being a checkout on this
  computer. Add the checkout as a project instead.

Sessions in uuBright Console's own task worktrees aren't listed: those are already tasks.

For a step-by-step guide, see [Continue a terminal session in a task](https://console.uubright.com/docs/continue-a-session/).

### Choose the model

**Model** sits next to **Agent** and starts at **Default**, which is the workspace's
default model for that agent if it has one (shown as, for example, **Default: haiku
(workspace)**), or else the agent's own setting. The list offers only models the task
can run:

| Agent and model access | Choices |
|---|---|
| Claude Code, Claude account | **Opus** (most capable for complex work), **Fable** (for the hardest, longest tasks), **Sonnet** (balanced speed and capability), **Haiku** (fastest and cheapest). These are Claude Code's aliases; each runs the newest model of its family. |
| Claude Code, CCR gateway | The models the gateway lists, if it answers `GET /v1/models`. Otherwise only **Default**: the gateway's routing rules pick the model. |
| Codex | The models your Codex installation lists, with **Default** naming the model in your Codex configuration. |

To use a model that isn't listed, open **Options** and enter its ID under **Custom
model ID**, for example `claude-opus-5-5`; it overrides the picker. A model that
doesn't suit the agent is refused before the task starts, for example a Claude model
for Codex, or a non-Claude model on the Claude account.

After you pick a model, **Use for new tasks in this workspace** makes it the
workspace's default for that agent, so **Default** means that model from then on. You
can also set each agent's default under [Workspace settings](https://console.uubright.com/docs/workspaces/#default-models).

### Change the model during a task

Select the model chip under the message box (for example **opus ▾**), or open the task
menu (⋯) and select **Change model…**, or open **Details** and select **Change** next
to **Model**. Choose a model, or **Default** for the agent's own setting, and select
**Change model**.

On a phone nothing sits under the message box but the tab bar: **＋** in the box holds the files menu,
**Model: … ▾** (which opens the same form) and the permission mode's short name (for example **Auto** or
**Ask first**). While the task is idle or working there is no status line either; the task's badge and
the activity line at the end of the conversation say what it's doing. A note that needs you, such as a
stopped session, shows above the message box. A Manager's **Details** sit in its Chat / Team log row.

- **Claude Code** switches between turns, the way `/model` does in the CLI. The
  conversation continues on the new model.
- **Codex** uses the new model from its next turn.
- **A stopped task** takes the new model when you resume it. Until then, **Details**
  shows the pending change.

The model only ever changes between turns, never during a tool call. While a turn is
running the button reads **Stop turn and switch**: it stops the turn, and the change
applies once the turn has ended. Messages you send meanwhile wait for the change.

**Compact first.** The prompt cache belongs to the model that built it, so the new
model's first turn reads the whole conversation at the full input price. Once a Claude
Code conversation passes about 50K tokens, the form shows its size and offers
**Compact first**, which runs Claude Code's `/compact` before switching.

**A smaller context window.** If the conversation doesn't fit comfortably in the new
model's window (more than 80% of it), the change is refused with the sizes, for example
*about 300K tokens, too much for claude-haiku-4-5's 200K window*. Tick **Compact first**
and try again, or choose a model with a larger window. The running model's window is
the one Claude Code reports. For others: Claude Code's aliases (`opus`, `sonnet`,
`haiku`, `fable`) and the 5.x model IDs have 1M, as do names ending in `[1m]`;
`claude-haiku-4-5` and Claude 3 models have 200K. Other model IDs are never refused for
size. If compacting doesn't finish within 10 minutes, the change is abandoned, the
conversation says so, and the task keeps its model.

**Another provider.** On the CCR gateway, the picker and the API accept only models the
gateway lists, when it lists them. A model from another provider (CCR names them
`provider,model`) can't continue the conversation, and neither can a name whose
provider isn't clear, because the gateway may route it anywhere: extended-thinking blocks are
signed by the provider that wrote them, and another provider's blocks can't be
replayed. The form offers **Hand off on** that model instead, which starts a new task
from a handoff note.

**Another agent.** Claude Code and Codex can't resume each other's conversations.
**Hand off to Codex** (or **Hand off to Claude Code**) starts a new task on the other
agent from a note written from this task's log: the goal, the branch, the pull request,
what is done and what is next. The old worktree's changes are committed and pushed first;
the new task starts from that branch and the original task stops. The old task offers Undo.

The conversation shows each change as a short line, for example **Model: sonnet →
opus (claude-opus-5-5)**, with **compacted first** when it ran `/compact`. If the
agent refuses a model name, the conversation says so and the task keeps its model. The
change lasts for the rest of the task, including after End session and Resume. When
the provider is overloaded or rate-limited and Claude Code retries, one line says
**Provider busy, retrying (attempt 2 of 10)** until the model answers. When the retries don't get through,
the task [waits and continues by itself](https://console.uubright.com/docs/reliability/#rate-and-usage-limits) once the limit lifts.
When the plan's usage limit is reached, a card offers another agent, Claude API access, or waiting.

The task header and **Details** show the model that is running, as the agent reported
it, with the name you chose in brackets when it differs, for example
**claude-opus-5-5 (opus)**.

Tasks started before this version can't change their model while they run. **Details**
says **Changing the model is available after Resume**: end the session, resume it, and
then change the model.

### The message box

Under the message box, one quiet row shows the task's settings: the model (select it
to change the model) and the permission mode, which is set when the task starts. On a
phone the row scrolls sideways. For Claude Code tasks the box accepts `@` file
references (Claude Code reads the file into the message) and `/` commands such as
`/compact`; Codex tasks take plain text.

### Permissions

| Choice | Behavior |
|---|---|
| Ask for approval | Claude's normal permission rules. Actions that need a decision appear in the app. |
| Accept edits | File edits and common filesystem commands run without asking. Other actions may ask. |
| Auto | Claude reviews actions itself, where your Claude version, model, account and policy support it. It can fall back to asking. |
| Plan only | Claude explores and plans before making changes. |
| Bypass permissions | Skips most checks. You must confirm a warning first. Use only in an isolated environment. |

Permissions reset to **Ask for approval** for every new task. The task shows
**Requested permissions**, because Claude can still apply its own rules or fall
back from Auto. For details on each mode, see Claude Code's
[permission modes](https://code.claude.com/docs/en/permission-modes).

> [!WARNING]
> Host tasks run with your server user's access. A worktree doesn't limit that, and
> Bypass is not a read-only mode.

Tasks created before permissions were recorded, and tasks created from Discord,
show **Host default**.

### Response style

| Choice | Behavior |
|---|---|
| Default | Claude Code's normal style, or your server's own `outputStyle` setting if it has one. Claude explains its work as it goes. |
| Concise | Claude Code's built-in Concise style: leads with the result, skips narration and recaps, keeps simple answers short. The work itself is unchanged. |

Response style is independent of permissions; **Concise** with **Auto** is a
useful combination. Unlike permissions, your browser remembers your last choice.

## Find what needs you

The selected task has a strong outline and a **Current** label in the task list.
Switching tasks updates the heading immediately and shows a loading state while
activity arrives; task controls become available once that task has loaded.

The task list is one stable list: pinned tasks on top, then every other task,
newest started first. A row never moves because its state changed, so new messages,
finished turns and questions leave the list where it is. Only pinning or unpinning,
a new task or a deleted one changes positions. On a touch screen the list holds
still while your finger is on it, so a new task never slides in just before you tap:
it appears once you lift your finger and the scroll settles, or after 8 seconds.
A click in progress is kept too: the task lists, the sidebar's counts, the workspace
switch and the Manager overview on a phone wait for a press to end (at most 8 seconds)
before they refresh, so a button doesn't change under the pointer between pressing
and releasing.

Each row shows its state as a status chip, an icon and a word, and then anything the word doesn't say (a countdown,
background work, a project on the phone). The task's header, its Needs you card and the Manager's overview show the
same chip, in the same states as [the board](#see-the-board):

- **Needs you**: waiting for your approval or answer, a decision, a held message, review comments to send on, a browser
  hand-off, a Manager over its budget, or a task that is [stalled or can't continue](#when-a-task-gets-stuck). The row
  is also shaded.
- **Working** (its icon pulses; steady when your system reduces motion): working or starting, or its open PR has a
  review running.
- **Ready to review**: finished a turn since you last opened it on this device, or its PR is ready to merge, until it
  merges.
- **Paused**: the agent's turn is over while its background work or jobs go on.
- **Stopped**: a failure ended the turn, or you stopped the task.
- **Done**: everything else, such as finished tasks you've already seen.

Pin a task with the pin on its row, or **Pin task** in the task's ⋯ menu, to keep it
at the top of the list. Pinned tasks stay in the order you pinned them. Pins are
remembered on this device. The phone's Tasks list is the same list, with the same
order, pins and chips. Cmd+1 to Cmd+9 (Ctrl on Windows and Linux) open the tasks in the order listed.
In the sidebar, each row also shows how long ago its task last did something, such as **15m** or **3h**.

At the bottom of the sidebar (on a phone, under the Tasks list), a small card points out one setup gap at a
time. First, a project in this workspace without a [setup script](https://console.uubright.com/docs/repositories/#prepare-each-task-with-a-setup-script) whose
tasks are paying for it: at least 2 of its tasks started in the last 7 days spent their early steps (before
their first edit, in their first turn) installing dependencies. The card names the time, such as "2 tasks in demo
spent 6 min installing dependencies this week before starting work". Without that evidence there is no such
card. After it: notifications that are off on this device, or no phone connected yet. Its link goes straight
to the fix. Select **×** to dismiss it; this device remembers that, and the next gap, if any, takes its place.

**Needs you** counts what waits on you: decisions, questions and approvals, held
messages, browser help, stuck tasks, a Manager over its monthly budget, PR notices to route, room hand-offs and,
when the relay's copy of the app is out of date, that notice: one card each, and the sidebar, the phone's Inbox tab
and the Needs you tab show the same number. The installed app shows it on its icon where the browser supports it. Finished work isn't
counted: it is under **Updates**, next to Needs you, with notes your agents posted to
you in rooms. Opening a task marks it as seen on that device; the first time
you open the app on a device, earlier activity counts as seen.

## See the board

The board shows a workspace's work at a glance, as a Kanban board: **To do**, **In progress**, **Waiting on you**,
**Ready to review** and **Done this week**. Each card leads with the task's [status chip](#find-what-needs-you); a paused or
stopped task sits under **Ready to review** or **Done this week**, and its chip says Paused or Stopped. A task is in the
same state on the board as in the sidebar.

| Column | Means |
|---|---|
| **To do** | Workers your Manager started that haven't begun their first turn yet, oldest first. Their cards say **Planned**, not a status. |
| **In progress** (Working) | A task is working or starting, its open PR has a review running, or a deploy is in progress. |
| **Waiting on you** (Needs you) | A task is blocked on you (as in the task list), or a deploy failed or never reported back within 2 hours. Its count is the same as **Needs you** in the sidebar; a room hand-off, which has no card here, gets a link to Needs you. |
| **Ready to review** | A task finished a turn you haven't looked at on this device, or its PR is ready to merge (until it merges). |
| **Done this week** | From the last 7 days, newest first: merged or closed PRs, finished deploys, and tasks that are stopped or that you've seen. Five show, then **Show N more**. |

A task with a pull request shows as one card for the PR, titled with its number. The card's second line says what
happened and what's next: "In review · round 2", "Round 2: 2 P2 → fixing", "Ready to merge · Review round 2 passed ·
checks pass". A [local review](https://console.uubright.com/docs/lead/#local-pr-review) shows on its PR's card; a review of a PR no task here tracks gets its own card
with a **Review** badge. The board is derived from what happened, so there is nothing to drag or file.

Select a card to open its task. A PR card has a separate **#198 ↗** link to the PR on GitHub. Cards keep their order
within a state, newest first, so live updates never shuffle them.

- **Board page:** **Board** in the sidebar, or the **Open as board** button on the panel, opens the five columns side by
  side, each scrolling on its own. The link appears once there is something on the board, so a new workspace doesn't
  show an empty one. While the page is open the panel steps aside. On a phone, the same page stacks the columns,
  Waiting on you first.
- **Desktop:** beside a task, the board is a panel to the right, listing the same columns from Waiting on you down. Toggle it with **Board** in the header or ⌘ and the
  period key (Ctrl and period on Windows and Linux). Drag its left edge, or focus the edge and use the arrow keys, to set the width (300 to 420 px);
  double-click the edge to reset. The width and whether it's open are remembered on this device. The task keeps at
  least 420 px: the board narrows first, then opens as a sheet instead until there is room again.
- **Phone:** a one-line strip under the header reads like "For you: Choose the isolation approach · 3 working", or
  "2 working · #198 In review · round 2" when nothing needs you; the **Inbox** tab carries the count. Tap it,
  swipe up on it, or tap the board button in the header to open the board as a sheet. Drag its top up for full
  height; drag it down, tap outside or press Escape to close.

The board shows only the selected workspace. When other workspaces have live work, one quiet line under the columns
says so: "3 in other workspaces →", then each workspace with its task counts, tasks needing you first, marked **● N**
(for example **SciMigo dev ● 1 · 2 working**). The line counts tasks, as the board's columns do; the sidebar's ● N
counts decisions and room items, so the two numbers can differ. Select a workspace to switch to its board. A task
counts there while it isn't stopped, while it needs you, or while it's Done within the last 7 days, so the line is
hidden when nothing is going on elsewhere. A review shows with its PR's task, as on that workspace's board. A main thread in Default can see the workers it started in another workspace this way.

The board updates live. If the connection drops, the last board seen on this device stays on screen marked
"as of 06:42" until it reconnects. Deploys appear when your deploy scripts report them; see
[`POST /api/deploys`](https://console.uubright.com/docs/api/#board-and-deploys).

## Answer approvals

When Claude needs permission, the task shows **Needs you** and a notice
appears above the message box. Select **Review request** to jump to the request.
On a Mac-sized window, the first unanswered request stays visible with its
details and Allow / Deny buttons; later requests scroll within that area.

Each request shows the tool, Claude's description and the exact command or input.
Commands are shown literally, never reformatted. **Copy command** copies them
exactly, and **Raw input** shows the original JSON.

- **Allow once** runs that one request.
- **Allow web research for this task** appears on web searches and on fetches of public
  pages. It allows this request and every later WebSearch, and every WebFetch of a public
  http(s) page, in this task without asking. It never covers commands, file changes, MCP
  tools, or fetches of local, private or credentialed addresses, which still ask. The feed
  records when you allow it; turn it off in **Details**, and searches ask again. Codex
  tasks don't offer it, because Codex doesn't ask before its web searches. It is a
  convenience with a cost: an agent misled by something it reads could send task data out
  in a search or URL without asking. See [Security](https://console.uubright.com/docs/security/#what-uubright-console-enforces).
- **Deny** refuses it, and Claude continues without it.

After you decide, the notice shows that the decision is waiting for the task to
confirm it, then disappears. Interrupting, stopping or restarting a task cancels
any open requests.

On a phone, deciding an approval in **Needs you** opens the next pending approval
and brings its details into view. Read it and choose Allow or Deny separately;
opening it never grants permission.

Everything a task waits on you for appears in one dock directly above the follow-up composer, under **Needs your answer**: questions the task asked you (choose an answer), the agent's own question, and tool and plan approvals, oldest first, each with its buttons. In the conversation, a question the task asked leaves a line, **Answer it below ↓**, where it was asked. When the dock holds more than fits, it scrolls on its own and **↓ More** (or **↓ 2 more**) brings the next one into view, so the message box stays reachable. If you've scrolled up the conversation when one arrives, a **↓ 1 needs your answer** button brings you back to it. With the window in the background, its title starts with the count, for example **(1) uuBright Console: Acme web: Add CSV export**.

When several requests are waiting, **Approve all pending** lists each tool and its command, path or query before you confirm the current batch for this session. It skips decisions already queued or being submitted, never answers questions, and does not approve requests that arrive later.

## Review a plan

When Claude asks to leave plan mode with a written plan, the approval card shows
readable headings, lists and code. Select **Copy plan** to copy its original
Markdown. **Raw input** keeps the full tool payload available for inspection.
Choose **Approve plan** or **Deny** after reading it; rendering does not change
the underlying permission decision.

## Answer Claude's questions

Claude sometimes stops to ask you something, such as which approach to take, with a
few options to choose from. The task shows **Needs you**, and the question is
pinned just above the message box, with its options and **Answer** and **Dismiss**
always in view. Its text is formatted like a reply, with lists, code and links, and
task ids and #123 references link to the task or to the issue in the task's repository.
A long question shows about six lines; **Show more** opens the rest.
When a question arrives, the card takes focus and screen readers announce it, unless
you're typing a message at the time.

- Pick an option, or several where the question says **Choose one or more**, then
  **Answer**.
- Or type your own answer in the message box, which reads **Type your own answer…**
  while a question waits, and press **Send**. For a question that takes one answer,
  typing replaces the option you picked; for one that takes several, what you type is
  added to your picks.
- **Dismiss** tells Claude you didn't answer; it won't assume one and may ask again in
  its reply.

While a question waits, **Send** answers it: it never sends your text as a normal
message by mistake. With nothing picked or typed, **Send** is off and the hint points
you at the options. For the rare follow-up that isn't an answer, use **Send as a normal
message instead** under the message box; the question stays pinned.

An answer is text, so files you attach while a question waits travel separately: **Send**
answers the question with what you typed or picked (or "See the attached files." when
there's neither), then sends the files as a message the agent gets with its next turn. The
help line under the box says so. If the files can't be sent, they stay attached with an
error, and **Send** tries them again.

If the question is answered on another device first (or skipped there, or the task is
interrupted), the card goes away. When you had typed an answer, it stays in the message
box and uuBright Console asks **That question was answered elsewhere. Send this as a
message?**: choose **Send as message** or **Keep as draft**. When you had only picked an
option, it says the question was answered elsewhere.

A question stays open until you answer or dismiss it. It survives closing the app,
losing the connection and restarting the server; it never times out or gets
answered for you. Interrupting, stopping or restarting the task cancels it, as with
approvals, and an answer to a cancelled question is refused. Your answer appears in
the transcript as **You answered**.

If Claude asks in a form this version of uuBright Console can't show, the card says so and
offers **Skip so Claude asks in plain text**: Claude is told to ask again in its
reply, which you answer with a normal message.

When Claude asks several questions at once, the pinned card shows them one at a time,
on a phone and a computer alike: answer, then **Next**, and **Send answers** on the
last. **Back** returns to the previous question with your picks and typed answer kept.
If another request asks more questions while one is pinned, the card says how many
wait after it.

You can also answer from [Discord](https://console.uubright.com/docs/discord/), [WeChat](https://console.uubright.com/docs/wechat/) and
[WhatsApp](https://console.uubright.com/docs/whatsapp/). Questions are numbered there; reply with an option number,
several comma-separated for a multi-choice question, or your own words. For a request
with several questions, put one answer per line, or separate them with `;`.

## Answer decisions

A task can ask you for a decision only you can make, such as which approach to build
or whether to ship, with the `ask_owner` tool. Unlike a question, the task doesn't
stop and wait: it carries on with other work, or ends its turn, and gets your answer
as a message when you give it.

The decision appears as a card in the task's chat, where it was asked, and in **Needs
you**. It has a title, a line of context, a link to its source (an issue or PR) and
one or more questions with options. The option the agent recommends is selected and
marked **Recommended**, so accepting it takes one tap on **Send answer**. **Something
else…** is always there for your own words.

- On a phone the questions come one at a time: pick, then **Next**. Each question
  takes two taps.
- **Send answers** sends them to the task, which acts on them.
- **Dismiss** closes the decision without an answer; the task is told not to assume
  one. It can't be undone, so on a phone it sits on its own row, below Next and Send.

Once answered, the card shrinks to what you chose and when. If the decision came from
a GitHub issue or PR of the task's repository, or of a project in the task's workspace, the
card says so and your answers are also posted there as a comment, with any @mentions
broken so nobody is notified by it. A task that is
stopped gets your answers when you resume it.

Decisions are the one thing that [notifies](https://console.uubright.com/docs/notifications/) you by default. A
task can have at most five open decisions; a PR reviewer can't ask.

## Check where a message goes

A new task reads **Starting…**, in the sidebar and by its title, until the agent
starts on your first message; it is never **Ready to review** before then. The first message
shows **Starting…** too, not as queued. The same goes for a message you send to an
idle task.

You can send another follow-up while Claude or Codex is working. It appears at the
bottom of the task, below whatever the current turn still writes, with a dashed
border and **Queued · sends when the current turn ends** until the agent starts it.
It then stays just above the turn it started. Several queued follow-ups wait at
the bottom in the order you sent them. **Edit** withdraws the queued message and puts its text back before any
text already in the composer. **Withdraw** leaves a Withdrawn note where you sent it.
If the agent starts in the meantime, the message remains in the log and the app
says it already started. While the agent is running, **Stop response** interrupts its
current turn. On a wide screen, Esc does the same when no menu, palette, dialog,
screen view, or browser takeover is open.

A new task is titled from the start of its prompt. Early in its first turn the agent names it in a
few words (for example "Roadmap and market evaluation") with the `ccr-task` `set_title` tool, and the
feed shows that step. The full prompt stays the task's first message. To choose your own title, open
**Details** and use **Rename**; the agent can't change a title you chose, or one given when the task
was created through the API or by a lead. The agent can rename a task at most 5 times a minute, and
titles lose bidirectional-override and zero-width characters; chat apps show them without formatting
or mentions.

A long answer (over about 1,200 characters) opens on its first section, usually the
conclusion, with **Show full answer** below it for the supporting analysis. The button
works from the keyboard and tells screen readers whether the rest is shown;
**Copy Markdown** always copies the whole answer.

Open **Details** below the task title to see where your follow-ups go: the server and
whether tasks run as your server account or in containers, then the repository, its
local worktree or clone URL, the task's branch (or "scratch folder" for a task
without one), and the base branch and commit it started from. The new-task form shows the same for the project you picked before you
start. A task always stays in the repository it started with; to work on another
one, start a new task.


## Review changes

For a repository task, select **Changes** (on the phone, **View changes** in the task
menu) to see what the task changed since it started: commits on its branch, edits
not yet committed, and new files, file by file with added and removed lines. Open a
file to see its diff, which wraps to fit a phone screen; **Copy diff** copies it.

The task reports its changes after each turn, and the latest summary stays available
after the task stops. Files listed in `.gitignore` aren't included. Binary files, very
large diffs and anything beyond the first 300 files are listed as a summary only, so
review those on the server or in the task's branch.

## Open a pull request

The button at the top right of a task is its next step for the code:

- **Open PR** when a repository task is idle and has changes.
- **Merge** when its pull request is ready to merge (as the [board](#see-the-board) shows it), or
  **View PR #N ↗** otherwise.
- Nothing, when there is nothing to do, such as a scratch task.

Its **▾** menu has the rest: **Squash and merge**, the task's other pull requests and **Track a PR…**.
**Merge** asks you to confirm, then merges on GitHub with the GitHub login the workspace's tasks use (a merge
commit; **Squash and merge** squashes). It merges only the commit that was Ready to merge: if anything was pushed
since, GitHub refuses, the app says the PR changed and to review it again, and the button goes back to **View PR**
until it is ready again. GitHub's branch protection still applies; if it refuses, the reason appears in the app.
Only you and your paired phones can use the in-app Merge action. In a repository whose review policy assigns routine merges to the Manager, the Manager uses that repository's gated merge workflow after a PASS on the exact head; risky paths still require the owner's decision.

**Open PR** opens a form that starts with the task's title and Claude's latest reply as the
description; edit both.

- **Commit uncommitted changes first** (on by default) commits everything in the task's
  workspace, using the title as the commit message.
- **Open as a draft** (on by default).

uuBright Console then pushes the task's branch, `ccr/SESSION_ID`, to the repository's `origin`
and runs `gh pr create`. The task shows the pull request's link, and each task opens
one pull request.

This uses the credentials the task already has: in host mode, your server account's
Git credentials and `gh auth login`; in Docker mode, `GH_TOKEN`. Install the
[GitHub CLI](https://cli.github.com) on the server for host mode. If something fails,
such as missing push access, the error appears in the task's activity.

## Send follow-ups

Type in the message box and press **Enter**, or select **Send**. **Shift+Enter** starts a
new line. On a phone or tablet, Return starts a new line and **Send** sends. Ctrl+Enter
(⌘+Enter on a Mac) also sends everywhere. Room messages work the same way. A message sent
while the agent is working waits until the current turn ends. A message to a stopped
task starts it, then delivers the message.

The message box grows with your text up to about 40% of the screen, then scrolls, and
shrinks back after you send. For a long message, select **⤢ Expand editor** in its corner
to write in a tall editor (the whole screen on a phone). There, **Enter** starts a new line
and **Ctrl+Enter** (⌘+Enter) sends; **⤡** or **Esc** returns to the normal box with your
text intact. The New task prompt and the room message box have the same button. Unsent
text is kept as a draft in the browser, including across reloads.
## Attach files

Attach screenshots, PDFs, logs, data or documents to a new task or a follow-up. In
**New task**, select **📎 Attach files** under the prompt (or paste an image into it): the
files upload once the task exists and go out with its first message. In a task, select **📎** to pick
files, drag them onto the task, or paste an image into the message box. On a phone, **📎**
offers **Take photo**, **Photo library** and **Files**. Each file uploads right away and
shows as a chip with its type, size and scan state; an image (PNG, JPEG, GIF or WebP)
shows a thumbnail, there and in your sent message. Select **×** to remove one before
you send. You can send files without any text. The same works in a chat: paste a
screenshot into the message box or drop files anywhere on the chat.

| Accepted | Refused |
|---|---|
| Images, PDFs, text, code and data (CSV, JSON, SQLite, Parquet), Word, Excel and PowerPoint files (docx, xlsx, pptx), zip, tar and gzip archives, audio and video | Programs and apps (Linux, Windows and macOS executables, zipped macOS apps, scripts with binary content), older Office files (doc, xls, ppt), and anything else the server doesn't recognize |

The server decides a file's type from its contents, not its name: a renamed `.exe` is
still refused. Archives are never unpacked. By default a file can be up to 25 MB and one
message up to 100 MB. To change that for a workspace, run this on the server:

```sh
uubright workspace set-attachment-limits default 50 200   # MB per file, MB per message
uubright workspace set-attachment-limits default --default
```

Limits can't be raised from the browser app.

If ClamAV's daemon (`clamd`) runs on the server, files are scanned, and a file it
flags is quarantined on the server and not attached. Without it, files are attached and
marked **Not scanned**. A clamd the server finds on its own may also leave a file
**Not scanned** when it can't scan it (for example a file over clamd's 25 MB default
`StreamMaxLength`); set `CCR_CLOUD_CLAMD_SOCKET` to refuse such files instead.
uuBright Console doesn't install ClamAV; see
[What uuBright Console enforces](https://console.uubright.com/docs/security/#what-uubright-console-enforces).

Files waiting to be sent can add up to 200 MB per task; send or remove some to attach
more. Files picked but never sent are removed after a day, the next time the server
starts. A message with files sent while its task is still starting waits until the task
is running. If the task turns out to run an older session image that can't take files,
the message isn't sent: the task says so, and **Send without files** sends its text alone.

The agent finds the files in its workspace under `.ccr/attachments/<message>/`, a folder
Git ignores. Claude Code also gets images (PNG, JPEG, GIF and WebP up to 10 MB) as image
input, and Codex gets them as local images. The message labels the files as data to work
on, not instructions to follow. Files stay with the task until you delete it, and its
**Details** list them.

Attaching works over the [encrypted relay](https://console.uubright.com/docs/phone-access/) too: the phone sends each file in
encrypted pieces the Mac acknowledges, so a dropped connection picks up where it stopped, and the
Mac checks and scans it as it does a direct upload, with the same limits. It goes at up to about
1 MB a second, so a 25 MB video takes about half a minute. A file still uploading when you close
the app is dropped; attach it again.

## Stop, resume and delete

| Control | Effect |
|---|---|
| **Stop response** | Stops the current turn. The task stays ready for your next message. |
| **End session** (task menu ⋯) | Stops the agent process after confirmation. The workspace and conversation are kept, and you can resume later. |
| **Resume session** | Restarts a stopped task, continuing the same conversation and files. Sending a stopped task a message does the same. With a CCR gateway configured, **Resume on** can [move it to the other model route](https://console.uubright.com/docs/switch-models/#switch-a-task-to-the-other-route). |
| **Retire: free its disk** (task menu ⋯) | Frees a stopped task's disk and keeps everything else. See [Retire and delete](#retire-and-delete). |
| **Delete task…** (task menu ⋯) | Removes the task, its workspace, its attachments, its deliverables and its history, after a confirmation that names what is lost. Only the owner's sign-in can delete. |

Closing the browser or the SSH tunnel doesn't stop a task. A server reboot does;
tasks that were mid-turn start again and continue on their own afterwards. See
[Operate your server](https://console.uubright.com/docs/operations/#after-a-reboot).

## Retire and delete

A stopped task keeps its workspace on disk so it can resume: the checkout, installed
dependencies such as `node_modules` or `.venv`, its browser profile and the runner's
scratch files. Workers pile up quickly, so a finished task can be **retired**.

Retiring frees all of that and keeps the task record, its event log and conversation,
its attached files and its deliverables. It never loses work:

1. Only a task's own checkout of its repository is removed. A task without a repository
   keeps every file in its workspace, even if the agent ran `git init` there, and loses
   only its installed dependencies.
2. Uncommitted changes become a WIP commit on the task branch: changed, deleted and
   untracked files, even where the repository's settings hide them from `git status`.
   Dependency folders are never committed, except one the repository keeps files in.
   Retire then checks that nothing uncommitted is left. It refuses, and frees nothing,
   when a commit can't save the work or would land in the wrong place:
   - a separate git repository inside the checkout;
   - a submodule with anything its origin doesn't have: uncommitted changes, ignored
     files, stash entries, or commits on any branch or tag that origin doesn't report;
   - a changed file the repository passes through a clean filter (git-lfs, nbstripout,
     git-crypt), since the commit would hold the filter's output rather than the file;
   - a task branch that is also checked out in another worktree, or that moved outside
     the checkout, where a WIP commit would undo someone else's commits.
3. A clone is saved whole as a git bundle kept with the task on the server: every local
   branch and tag, and every stash entry. Commits on the task branch that origin doesn't
   have are also pushed to `backup/<task id>` there. A worktree of a repository on the
   server keeps its branches in that repository; commits origin lacks are pushed to
   `backup/<task id>`, or bundled without push access. Whether origin has a commit is
   asked of origin, not read from possibly stale remote-tracking branches.
4. Ignored files such as `.env` are kept in an archive with the task. Dependency folders
   (`node_modules`, `.venv` and the like) are not, wherever they are; setup makes them
   again. Neither is an ignored build output folder at the top of the workspace (`dist`,
   `out`, `build`, `target`, `coverage`, `.cache`, `.gradle`) larger than 50 MB. Publish
   or commit anything there you want to keep before retiring; smaller ones are kept.
5. Published deliverables are copied out of the workspace first, so they still open, with
   the content that was published.
6. Only then are the checkout and scratch files removed.

If any of that fails, nothing is freed and the task's log says why. A task with a durable
job still running can't be retired until the job is stopped.

A retired task shows **Retired · workspace freed (1.5 GB)**. **Resume** makes the
checkout again, puts back its branches, tags, stash entries and ignored files from the
bundle, archive or backup, runs the project's setup again, and continues the same
conversation. A bundle or archive is deleted only once Resume has applied it.

Retire a stopped or exited task from its ⋯ menu, from **Clean up finished tasks…** at the
bottom of the board, or with [`POST /api/sessions/:id/retire`](https://console.uubright.com/docs/api/#sessions). Paired
devices can retire, since it loses nothing; deleting needs the owner's sign-in. Details
shows each task's disk use and whether its branch is pushed; the count is taken when you
open Details and kept for ten minutes.

Deleting a retired task also deletes the bundle and archive kept with it. For a task
that worked in its own clone, that bundle is the only copy of whatever origin doesn't
have: its commits when the backup could not be pushed, and any other local branches and
stash entries. The Delete confirmation says so: "3 commits not pushed, kept only in the
backup on this server". Resume the task and push first if you want them. A task that
worked in a worktree of your repository keeps its branch there, so the confirmation only
says "3 commits not pushed". The count is taken when the task is retired; if origin
didn't answer then, the confirmation says it can't tell. A retired task whose work
reached origin is deleted without that warning.

**Clean up finished tasks…** lists the workspace's stopped and exited tasks with their
disk use and whether their work is pushed. Select some, then **Retire** them or, with the
owner's sign-in, **Delete** them.

### Automatic retire

The server retires a worker on its own once it has been idle or exited for 24 hours and
its work is safe elsewhere: origin has all of its commits (its branches, for a clone) and
it has nothing uncommitted or stashed, or every PR it tracks is merged or closed. A worker is a task a [lead](https://console.uubright.com/docs/lead/) started, or one another
task started through the API (such as your Manager's). Tasks you started are never
retired automatically. Neither is a task with an open approval, question, decision or
form, a message waiting, or a durable job running. An idle worker is stopped first. The
task's log records it, for example "Retired automatically (idle for 24 hours and its
branch is pushed)".

Set `CCR_CLOUD_AUTO_RETIRE_HOURS` to change the 24 hours, or to `0` to turn automatic
retire off ([Configuration](https://console.uubright.com/docs/configuration/)).

## When a task gets stuck

A task can't always carry on by itself. Each case shows as a card in Needs you, and in
the task above the message box:

| Card | What happened | What you can do |
|---|---|---|
| **Stalled** | The turn has had no output or tool calls for 20 minutes, and none of the agent's commands is running. Usually it waits for a background job that died. | **Nudge** interrupts it and asks it to check its state and continue. **Restart fresh from branch** saves uncommitted work as a WIP commit and starts a new agent session in the same worktree, with a handoff note. |
| **Stopped unexpectedly** | The task stopped in the middle of the same turn three times; it was [continued automatically](https://console.uubright.com/docs/reliability/#turns-cut-off-by-a-crash-or-restart) twice. | **Try again** starts it and continues once more, or **Restart fresh from branch**. |
| **Worktree on another branch** | The agent left its worktree on another branch, and putting it back would lose work. The card shows the exact commands to fix it. | Run them, then **Try again**. |
| **Could not start** | Starting the task failed, with the reason. | Fix the cause, then **Try again**. |
| **Rate limited** | The provider's request limit persisted after [automatic continues](https://console.uubright.com/docs/reliability/#rate-and-usage-limits) reached a cap. | **Try again** continues it now. A plan usage limit has its own continuation card. |

**Dismiss** closes a card and leaves the task as it is. See
[Failure and recovery](https://console.uubright.com/docs/reliability/) for what each one does exactly.

## See what a task used

Under the task's title, open **Details** to see **Usage**: what its model calls used so far, an estimated
cost, the tokens, and how they were paid for. The figure is Claude Code's own estimate
at Anthropic's API prices, added up across turns and across Resume.

- **On your Claude subscription** (the Claude account route): you aren't charged this
  amount. It shows how much of your plan's 5-hour and weekly limits the task is using.
- **Through the CCR gateway:** Claude Code prices the tokens as Claude, so if CCR sends
  them to another model, the gateway's own figures are the accurate ones.
- **Codex tasks** don't report usage yet.

Each **Turn finished** notification also carries that turn's estimate. To cap what a
group of agents can use, give their [room a budget](https://console.uubright.com/docs/rooms/#limits-pause-and-disband).

## Give the conversation the room

On a desktop, nothing spans the top of the window. The uuBright Console name, the connection dot, the **Board** panel
toggle and the app's ⋯ menu sit at the top of the sidebar. A task is one row: its title (the whole title shows when
you hover over it), its status, **Chat | Team log | Deliverables** for the Manager, **Details** and ⋯.

- **Narrow task column:** when the task column is under about 640 px wide, for example with the Board panel open
  on a small window, **Deliverables** moves into the task's ⋯ menu.
- **Usage near a limit:** from 80% of a usage limit, a short chip such as **90%** shows in the row, with the
  whole line on hover. Below that, the line is in **Details**.
- **Focus mode** hides the task's row as well, leaving only the conversation and the message box. Needs you and
  approvals still show. Turn it on or off with **Focus mode** in the task's ⋯ menu, or with ⌘⇧F (Ctrl+Shift+F on
  Windows and Linux). The setting is remembered on this device.
  - **Desktop:** scroll up, move the pointer to the top edge, or Tab into the row to bring it back over the
    conversation.
  - **Phone:** an **Exit focus** button stays in the top corner.

## Read a task on your phone

The task view shows Claude's messages, your messages, approvals, failures and the
final answer. Tool calls between two of Claude's messages fold into one row, for
example **Explored · 14 steps (8 reads, 4 searches, 2 fetches) · 1 error**:

- Tap the row to list its steps, one line each: an icon, a verb and what it acted
  on, such as **Shell** `npm test` or **Read** `src/server/store.ts` · 412 lines.
  A long command is cut to fit the line; a long path is cut in its folders, so the
  file name stays whole. Tap a step to see its whole input and
  output. The app downloads them only then, so a long task stays light on a slow
  connection.
- **Thinking** rows show Claude's reasoning, when Claude Code reports it, among the
  steps. Tap one to read it in place. Thoughts aren't counted as steps.
- Errors Claude recovered from are counted in the row. When a tool error ended
  the turn, its row and the failing step are already open.
- While a turn runs, a line under the activity says what the agent is doing, such
  as *Running tests…*.

To see every step without tapping, open the **⋯** menu and turn on **Show all
steps**. The setting applies to this device only.

For reading at night, open the **⋯** menu and set **Theme** to **Dark**. **System**,
the default, follows your device's light or dark setting; **Light** and **Dark**
override it on this device. Previews of HTML and SVG outputs keep their own
colors.

## Read and copy output

Claude's replies render Markdown: headings, lists, tables, code blocks, quotes and
links. Raw HTML is shown as text. Your messages and tool output are always plain text.

A Markdown image in a reply shows as a picture when its path names an
image the task made: one it published as an [artifact](https://console.uubright.com/docs/artifacts/), or a draft in
`.ccr/artifacts/`. Claude can write the path from the task's workspace, an absolute
path ending in it, or just the file name. Tap the picture to see it larger. An image
from another website stays a link (**🖼** and the caption) that opens in a new tab:
loading it inside the reply would tell that site who reads the reply and when, so the
app never fetches it. Any other path stays as written.

Diagrams in a reply are drawn as pictures:

- A ` ```mermaid ` code block (a flowchart, sequence diagram, state machine, ER
  diagram, Git graph and so on) is drawn with [Mermaid](https://mermaid.js.org) in
  the app's light or dark colors, and redrawn when you change the theme. Mermaid is
  part of the app, so diagrams draw on a server with no internet access too; it
  loads the first time a diagram comes on screen.
- A ` ```svg ` code block, or any code block that starts with `<svg`, is shown as
  the picture it draws, on white, up to 512 KB. Larger SVG stays code.

Each diagram has **Expand**, which opens it as large as the window (tapping it does
the same), **Copy source** and **Download SVG**. A wide diagram shrinks to fit only so
far, so its labels stay readable, and past that scrolls sideways in place. A diagram
is a picture, not a page: nothing in it runs, links in it don't open, and it loads
nothing from elsewhere. A block Mermaid can't read stays code with the note
**Couldn't draw this diagram**, and so does every diagram while you're offline. A
block still arriving while Claude writes is shown as code until it's complete.

Math is drawn as it would be typeset, with [KaTeX](https://katex.org): `$…$` or
`\(…\)` in a line, and `$$…$$`, `\[…\]` or a bare `\begin{align}…\end{align}` on lines
of their own, plus chemistry with `\ce{H2O}`. A single `$` starts math only when text
follows it, and ends it only after text and before a non-digit, so prices like `$5`,
`$5 and $10` or `$40-$50` stay prices; write `\$` for a dollar sign. Math in code
stays code. A formula wider than the screen scrolls sideways in place. KaTeX is part
of the app and loads the first time a reply has math; offline, or when KaTeX can't
read a formula, the formula stays as written (hover it for the reason). When you
select and copy text, each formula copies as its source, so it pastes into a
document or another chat as LaTeX.

- **Copy Markdown** copies a reply's original text.
- **Copy code** copies one code block.
- **Copy output** (in an opened step) copies a tool's full output, even when the
  screen shows a shortened version. Images in tool output appear as `[image]`.

If the browser or app refuses clipboard access, the copy buttons fall back to the
browser's ordinary copy command, so the text still copies exactly as written. If that is
refused too, the button says why and tells you to select and copy the text manually.

A long task opens at its most recent activity, so it loads quickly on a slow
phone connection. When you scroll up, a round **↓** button above the message box
jumps back to the latest. Select **Load earlier** at the top to see older activity, one
page at a time. Approvals still waiting for you always show, however old they are.

## Next steps

- [Notifications](https://console.uubright.com/docs/notifications/): get approval requests on your phone.
- [Switch models with CCR](https://console.uubright.com/docs/switch-models/): keep working while you're at a
  Claude usage limit.
- [Access from your phone](https://console.uubright.com/docs/remote-access/)
- [HTTP API](https://console.uubright.com/docs/api/): start and control tasks from scripts.


## Background work

Long commands the agent runs as [durable jobs](https://console.uubright.com/docs/reliability/#long-commands-durable-jobs) show in the
same chip, as "· 1 job running", with each command, how long it has run and a **Stop** button. A job keeps
running when the task crashes or restarts on its own, and the agent gets a message when it finishes. Ending
the session stops its jobs. In Ask mode, starting a job asks for your approval with the exact command.
While a job runs after the agent's turn is over, the task reads **Idle** (not Ready) with that chip, and counts
as Working on the board and in the task list, never Done.

A foreground reply can finish while Claude's background agents or commands still
run. As in Claude Code's terminal, the foreground is free: the task reads **Idle** with a small
"· N in background" chip; tap it to list the background tasks and how long each
has run. The sidebar shows the task as Ready or Done, not Working.

A worker also shows what it last reported to its Manager, such as **Waiting on job j-…**. That chip's tooltip
and accessible name begin "Reported to its Manager", so it doesn't read as the task's own state. In the task
list, a finished task you've already looked at reads **Done**, matching its dot.
When a background task ends, the feed shows one muted line such as
"Background: Run the test suite finished"; a failed or stopped task's line takes
the warning color. Background tasks finishing don't mark the task as new again;
the agent's reply to them does. The foreground is free, so a
follow-up starts another turn while children work.
If the agent is responding, follow-ups queue. Pending approvals/questions keep
**Waiting for you** precedence and must be resolved first.

Background handbacks may trigger an autonomous response without another prompt.
A single **Turn finished** entry and completion notification appear once the work
settles. Empty duplicate result frames do not produce extra completion entries;
legitimate new user turns still do, including turns with no text response.
Failed or stopped children are recorded in runner activity. Claude's live task
snapshots reconcile missing terminal events. Restarted runners start with a fresh
activity tracker; they do not assume an old process's children are still alive.
