atriumatrium

Tasks & runs

Task cards, runs, and how agents work against them.

atrium has a built-in task tracker. Tasks are first-class workspace objects with status, priority, size, labels, comments, and a run history, and they live right next to your panes — not in a separate web app.

Where you work with tasks

  • Tasks pane (Cmd+Shift+K) — opens on a kanban board by default (one column per status) and remembers your last-used view, so you can flip to the searchable, filterable list view and it sticks. Fuzzy title and ATR-# matching, inline editors for status, priority, size, and workspace, and color-matched priority dots. New cards land at the top of their column. A kanban card with an active run embeds a live agent chat so you can follow and reply to the agent right on the card, and shows live launch progress while its agent starts up. Click a card to open its detail pane.
  • Task detail pane (Cmd+Shift+J or clicking a task in the list) — full edit surface: title, rich Markdown description (with the same RTE/source toggle as the Markdown editor), status, priority, size, assignee, labels, due date, comments, and a live timeline of runs. The Save button is a split button with Save & Launch that commits changes and kicks off an agent run in one click.
  • Omni menu (Cmd+Shift+T) — fuzzy-search across every task in every workspace; prefix with # to scope directly to tasks. A Create task quick action creates a card from whatever you type.
  • Activity sidebar — agents working against a task show the task number on their card; click to jump.
  • CLI — every task action has a atrium task … equivalent for scripting and for agents to drive themselves. See the CLI reference.
See Tasks panes for the pane UIs in detail.

Task cards

A task card is one unit of work.

  • task_number — a human ID scoped to the workspace, formatted like ATR-42.
  • title — required, single line.
  • description — Markdown, edited in the detail pane with the same RTE/source toggle as the Markdown editor.
  • status_id — foreign key to a workspace-scoped Status row.
  • priority — critical / high / medium / low. Rendered as a colored dot.
  • size — xs / s / m / l / xl.
  • assignee — free-form string; a user handle or an adapter ID.
  • label_ids — zero or more labels.
  • source — who created or touched the card, formatted as user:<name> or adapter:<name>.
  • current_primary_run_id — the active run, if any.
Tasks are scoped to a workspace. Each workspace has its own numbering, statuses, and labels.

Skills & Agents context

A card optionally carries a Skills & Agents context — a bound agent profile and a list of attached skills the agent should see when the card launches. Three columns persist this on the card row:

  • agent_ref — the agent the card binds to (either a named profile slug or an ad-hoc { adapter, prompt } bundle).
  • skill_selection — an ordered list of { provenance, name, mode } entries that overlays the bound agent's own skills at launch (task selections win on (provenance, name) collisions).
  • profile_slug — convenience copy of the named profile's slug, for quick referencing without re-resolving.
The picker lives in an accordion section on the create modal, edit modal, and detail pane. When the card launches via Launch or atrium task launch, the bound context flows through SessionStart so the agent receives the prompt, the discovery-mode skill bullets, and the always-loaded skill bodies in one go — same shape an in-pane ++slug injection produces. See Skills & agents for the registry and Sigils for the expansion contract.

Statuses and labels

Statuses and labels are workspace-configurable. Default statuses are Todo, In progress, and Done. Reorder them by dragging in the tasks list pane's status column header, or via atrium task status reorder. Same for labels.

Create, edit, and delete statuses and labels from the Settings → Tasks tab, or via CLI.

Runs

A run is a single execution segment of a task by an agent. A task can have multiple runs over its lifetime. A run ends when the agent completes the task, cancels it, or the pane is closed mid-work.

Run states:

  • active — an agent is currently working on this run.
  • interrupted — the pane closed or crashed before the agent completed or cancelled. Resumable.
  • completed — the agent called atrium task set-done or atrium run complete.
  • cancelled — user cancelled via the activity sidebar or CLI.
Each run captures a launch profile (adapter, flags, args) so resuming recreates the same environment.

The task detail pane shows every run in chronological order with inline output, a Replay button on completed runs, and a Cancel button on active runs.

Launching a task to an agent

A card can carry an attached launch configuration — a launch profile set from the create or edit modal — so Launch becomes one click with no dispatch dialog. One-click Launch works even before you've configured one, falling back to a sensible default. From the omni menu and the launch modal you can also launch a task (or an agent) into a specific git worktree, isolating its work from the parent branch.

For full control, click Launch from the task detail pane to open the dispatch dialog:

  1. Pick a target pane (existing empty pane or create a new one).
  2. Pick an adapter.
  3. Optionally choose a review and completion status.
  4. Optionally set execution mode (worktree vs current branch) and adapter-specific flags.
  5. Press Launch.
This creates a run, binds the pane to the task, injects ATRIUM_TASK_ID / ATRIUM_TASK_RUN_ID into the pane's shell, and sends the task's title and description as the initial prompt to the agent.

For scripting, the CLI equivalent is:

"$ATRIUM_CLI_PATH" task launch ATR-42 \
    --pane-id <pane-id> \
    --adapter claude-code \
    --source user:me

The agent does work, then uses atrium task set-in-review (move to review status) or atrium task set-done (mark complete) to signal state changes. Both commands read $ATRIUM_TASK_RUN_ID from the environment, so the agent does not need to pass the run ID manually.

See Task dispatch for the full walkthrough.

Resuming interrupted runs

The tasks list pane shows an Interrupted filter chip that isolates runs in that state. Clicking an interrupted run opens a Resume dialog where you pick a fresh pane and adapter; atrium attaches a new segment to the same run and injects the same ATRIUM_TASK_ID / ATRIUM_TASK_RUN_ID into the new pane.

Equivalent CLI flow:

"$ATRIUM_CLI_PATH" run list --state interrupted
"$ATRIUM_CLI_PATH" run resume <run-id> --pane-id <new-pane-id>

Storage

Tasks and runs live in a SQLite database at ~/.atrium/tasks.db. The frontend reads from in-memory stores that hydrate from Tauri commands; every change is persisted immediately.

Safe to back up the file when atrium is not running. The schema is an internal implementation detail — use the CLI or the task panes for migrations between versions.