Work Summary

Attention-first project dashboard. The default (lean) mode answers four questions - what's moving, what's stuck, what's next, what's queued - in a bounded view (~45 lines) regardless of workspace size. The exhaustive inventory is an explicit mode: mature workspaces accumulate hundreds of terminal items, and rendering them all buries the actionable content.

Every call below is a 4.0 tool call. Shapes are in ../_generated/call-shapes.md and are not restated here. Every answer is the response envelope: read ok, then data; on ok: false read error.code (an unknown field is unknown_parameter, so a typo fails loudly rather than being ignored). All calls here are reads, so there is no per-element write envelope to check.

Supplement the data with brief observations only for a genuine anomaly or actionable insight.

Step 0 - Mode Selection

Step 0.5 - Project Scope Resolution

• Check the SessionStart context. A ## Project Scope section carries a project rootId, which scopes reads (ancestorId / anchorId). A ## Personal Scope section carries a personal root, which only anchors new items: in personal scope every call runs unscoped and the header says personal scope - whole database.
• Otherwise read the top-level project.rootId of .taskorchestrator/config.yaml (a file read).
• With no rootId from either path, every call runs unscoped: drop ancestorId / anchorId / rootId from the examples below.

Below, "<rootId>" marks a field you include only when a project rootId is known. Scoped mode resolves its own scope per invocation and ignores the project rootId.

Lean Mode (default)

Data collection (all parallel)

1. Non-terminal roots with childCounts roll-ups (items_read-overview). excludeTerminal keeps a terminal root that still has open descendants (active work parked under a done container) and drops the rest; page.truncated / page.next page it.

{"tool": "items_read", "select": "overview", "args": {"excludeTerminal": true, "anchorId": "<rootId>"}}

1. Health: data.active.items (work and review, longest in the role first), data.blocked.items, data.stalled, data.claimSummary (items_read-context). blocked holds explicit blocks (blockType: "explicit", with reason and, for awaiting_decision, decisionId) AND open items with an unsatisfied dependency (blockType: "dependency"). Each stalled entry is {id, title, role, missing[], guidanceKey?, skillPointer?}.

{"tool": "items_read", "select": "context", "args": {"ancestorId": "<rootId>", "limit": 100, "fields": ["ancestors"]}}

1. Recent transitions (the "where did I leave off" signal). The history select has no ancestorId: with no itemId it covers every item the caller may see, so the line is whole-tree even inside a project.

{"tool": "items_read", "select": "history", "args": {"since": "<now minus 48h, ISO 8601>", "limit": 20}}

1. Ranked recommendations (the default limit is 1, so ask for 5). fields: ["ancestors"] supplies the Container column.

{"tool": "items_read", "select": "next", "args": {"limit": 5, "ancestorId": "<rootId>", "fields": ["ancestors"]}}

1. The canonical source for queue children. Group rows by parentId; page.total is the true queued count. Subtract rows whose type or tag is container or project (a fresh container sits in queue until its first advance and would inflate N queued). When page.truncated, the headline count is approximate.

{"tool": "items_read", "select": "list", "args": {"role": "queue", "limit": 200, "ancestorId": "<rootId>"}}

1. The true terminal count is data.page.total.

{"tool": "items_read", "select": "list", "args": {"role": "terminal", "limit": 1, "ancestorId": "<rootId>"}}

Headline counts come from these sources, never from the overview payload (it covers the roots set only and may be truncated).

Runs (only when runs exist)

Issue both reads in parallel and render the section only when either returns a run. A run is a bounded, budgeted pass over a set of items.

{"tool": "runs_read", "select": "list", "args": {"rootId": "<rootId>", "status": "open"}}

{"tool": "runs_read", "select": "list", "args": {"rootId": "<rootId>", "status": "paused"}}

For each run (cap 5, newest first) read its frontier:

{"tool": "runs_read", "select": "frontier", "args": {"runId": "<run UUID>"}}

data.counts is members by role, ready the members nothing holds back, inFlight the active seats (each with its own stalled flag), waiting the members held back, each with a reason: manual, dependency (with blockers, short ids), awaiting_decision (with decisionId) or resource, and stalled the coordinator's flag. A paused run's list entry carries pauseReason. Render one row per run: label or title, short run id, status, counts, ready, in flight (N stalled), waiting.

Blocked-item decisions

For each health blocked entry with blockType: "explicit" (cap 10), read the item's context. Its item.blockedReason repeats the block reason and decisions[] lists the decisions raised on it as {id, class, status, option?} (withdrawn ones left out). The question text is not in this view: it is a director-profile read (runs_read decision), so show the decision class and status instead. This read supplies decisions[] class and status only; whether the item is resumable comes from the blocked read below.

{"tool": "items_read", "select": "context", "args": {"itemId": "<blocked item id>"}}

When health blocked holds an awaiting_decision entry, read items_read blocked once:

{"tool": "items_read", "select": "blocked", "args": {"ancestorId": "<rootId>", "fields": ["ancestors"]}}

Each awaiting_decision entry carries a server-computed resumable (true when its blocking decision is no longer open or acknowledged). Answering a decision never resumes its item, so flag a resumable one and point at advance op transition with trigger: "resume".

Enrichment

• Containers are shelves, not work. Items with tag or type = container never count as active; exclude them from the In Flight list.
• Active = health active.items minus containers. Blocked / stalled = the health lists as they are. Items of a lifecycle: none schema have no role, so role-filtered lists and counts leave them out: the dashboard covers role-bearing work (config-reference.md, Lifecycle-free items).
• Workstreams = non-terminal roots with children. Progress = terminal / total from childCounts, rendered N/M terminal (not done: the terminal bucket includes cancelled items). "Next up" = the highest-priority queue row from step 5 whose parentId is that root.
• Standalone queue roots group by kind: the type if set; else the first tag not in {agent-observation, feature, container}; else "Uncategorized".
• Rollup threshold: a group of more than 5 renders as a count line by kind, listing items only when priority is medium or higher or tagged action-item.
• Hygiene candidates: empty non-terminal containers; evident test artifacts (probe/smoke titles, mtest-* tags).

Dashboard format

Render in this order; omit any section with no data.

## ◆ Work Summary

[One sentence: health and momentum.]

**N active · N blocked · N stalled · N queued · N terminal**

### ◉ In Flight
| ID | Item | Container | Status | Pri |
|----|------|-----------|--------|-----|
| `xxxxxxxx` | <title> | <parent title or —> | ◉ work | high |

↳ Recent: <up to 3 one-line transitions from history, newest first; omit if none in 48h>

### ⊘ Attention Required
| ID | Item | Container | Issue |
|----|------|-----------|-------|
| `xxxxxxxx` | <title> | <parent or —> | Blocked by: `<blocker-id>` <blocker-title> |
| `yyyyyyyy` | <title> | <parent or —> | Blocked (awaiting_decision): <class> <status>; resumable |
| `zzzzzzzz` | <title> | <parent or —> | Stalled: missing `<note-key>` |

### ▸ Recommended Next
| ID | Title | Container | Pri |
|----|-------|-----------|-----|

### ⟳ Runs
| Run | Status | Terminal / total | Ready | In flight | Waiting |
|-----|--------|------------------|-------|-----------|---------|

### ○ Backlog
**Workstreams**
| ID | Workstream | Progress | Next up | Pri |
|----|-----------|----------|---------|-----|

**<Kind>** (N): `id` <title> (pri) · ...           ← groups of 5 or fewer
**<Kind>** (N): X bug · Y optimization — highest: `id` <title> (pri)   ← groups of more than 5

### ✓ Terminal - N terminal items

↳ Hygiene: <N> test artifacts, <N> empty containers - candidates for /batch-complete

Naming a dependency blocker. items_read blocked (ancestorId, fields: ["ancestors"]) returns EVERY blocking dependency of each item as blockers[{id, title?, role?, threshold, satisfied}]; call it only when the health entries are not enough to name the blocker. For an explicit block the Issue text is Blocked (<reason>) with the reason read above.

Lean-mode rules:

• Target ~45 lines; rollups hold the budget.
• The Terminal section is one line (the step 6 count). No titles and no done/cancelled split; use full mode for that.
• The Hygiene line appears only when candidates exist.
• If In Flight, Attention and Recommended Next are all empty, say so in the health sentence ("Quiet board - nothing in flight...") instead of rendering empty sections.

Full Inventory Mode ($ARGUMENTS = full)

Everything lean mode shows, plus the complete per-container inventory.

Data collection

1. The compact roots list, without includeChildren; page with cursor (page.next) while page.truncated. Each root carries role, statusLabel, childCounts, tags and type but no subtree.

{"tool": "items_read", "select": "overview", "args": {"limit": 200, "anchorId": "<rootId>"}}

1. Per active container (a non-terminal root whose childCounts show open children), in parallel, a scoped overview. It returns the container, its open children, and any terminal child that still holds open work; childCounts stays full. Each call is bounded to one container.

{"tool": "items_read", "select": "overview", "args": {"itemId": "<root-id>", "excludeTerminal": true}}

1. Health, recommendations and the two role totals exactly as in lean steps 2, 4, 5 and 6.

Never fetch every root's children in one call (includeChildren: true across the whole tree): on a mature workspace the terminal subtrees exceed the tool-result ceiling. Terminal children are counted from childCounts, never enumerated; to see one container's completed items use Scoped mode on it.

Sections, in order

1. Health Headline, Attention Required, Recommended Next: as in lean mode.
2. Project Inventory - per active container, from its step-2 fetch:

   #### <Container Title> `<8-char-id>`
   <role-symbol> <role> · <N open> · <N terminal>

   | ID | Title | Status | Pri | Tags | Children |
   |----|-------|--------|-----|------|----------|

   ✓ N terminal - counted from childCounts, not listed

• The table lists only open children (queue / work / review / blocked), sorted ◉ active, then ⊘ blocked, then ○ queue.
• <N open> = queue + work + review + blocked from childCounts; <N terminal> = terminal.
• Children = compact role summary N○ N◉ N⊘ N✓ from the child's own childCounts (omit zero roles; — if childless).
• Tags = the tags or —; traits append with a ▸ prefix, needs- stripped.

1. Standalone Items - non-terminal childless roots, grouped by the grouping key below.
2. Terminal - ### ✓ Terminal - N terminal (N from the step 6 count). Split root-level terminal items by statusLabel: **Completed containers:**, **Completed standalone:** (+N more if over 5), and **Cancelled:** listed separately, never as completed work.
3. Empty containers - **Empty (no items):** <title>, ... at the end if any.

Scoped Mode ($ARGUMENTS = UUID or title)

Use the resolved UUID as the scope for a full-inventory-style rendering of one subtree.

{"tool": "items_read", "select": "overview", "args": {"itemId": "<parentId>"}}

Health runs with ancestorId: "<parentId>"; recommendations use parentId: "<parentId>" (direct children) or ancestorId (the whole subtree). Render the Full Inventory sections for that subtree only.

Multi-Project Mode ($ARGUMENTS = all)

One condensed section per project anchor, for workspaces where several project roots share one database.

{"tool": "items_read", "select": "list", "args": {"type": "project", "depth": 0}}

1. These are the anchors created by /task-orchestrator:init, /adopt-project-scope or by hand. An anchor tagged personal-root is the personal root; label it (personal).
2. If none are found, say so and stop: "No project anchors found - run /task-orchestrator:init to bootstrap one, or use /work-summary (no arguments) for the whole-DB view."
3. For each anchor, in parallel: the anchored overview (anchorId, excludeTerminal: true), health with ancestorId, and next with limit: 3 and ancestorId.

### ◆ <Project Name> (`<8-char-id>`)
N active · N blocked · N queued

**Attention:** <up to 2 blocked/stalled items, or "none">
**Next up:** <top next result, or "nothing queued">

Keep each section condensed - a cross-project scan, not a deep dive. Point at /work-summary for the full dashboard on any one project.

Shared Rendering Rules

Status symbols: ✓ terminal · ◉ work/review · ⊘ blocked/stalled · ○ queue.

Short IDs: compact views already carry 8-hex ids; render them in backticks. Truncate full UUIDs (run ids, history itemId, blockers[].id from items_read blocked) to their first 8 characters. Use — for empty values, not 0. Priority renders high / med / low.

Grouping key (standalone items, all modes): type if set; else the first tag not in {agent-observation, feature, container}; else "Uncategorized".

statusLabel: the role drives the symbol. Print the label only for a non-terminal item whose label differs from the role default; never on terminal items.

Cancelled is not done: wherever terminal items are broken down, count statusLabel: "cancelled" separately.

Truncation: if any response had page.truncated that paging could not resolve, end the dashboard with ⚠ showing X of Y - never silently drop data.

Observations: sparingly. A healthy project needs zero.

Internal: short ID to full UUID

Do NOT render a UUID table. Keep the short-to-full mapping as internal context; when the user cites a short id ("start 0499a6aa"), resolve it silently from the data already collected (every id field accepts 8 hex characters; an ambiguous prefix is ambiguous_id).