@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/TeamPanel.js

@@ -1,148 +1,20 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs } from './glyphs.js';
+import { childStatus, isRunningStatus, rosterCounts, rosterHeadline, statusColor, } from './team-status.js';
 import { formatDuration } from '../agent/usage.js';
-import { describeToolActivity, sanitizeActivity } from '../team/activity.js';
-import { TEAM_LIMITS } from '../team/limits.js';
 import { buildTeamPanelLayout } from './layout/team-panel.js';
-function isRunning(run) {
-    return run.phase === 'starting' || run.phase === 'thinking' || run.phase === 'tool' ||
-        run.phase === 'waiting';
-}
-function isSettled(run) {
-    return run.phase === 'done' || run.phase === 'failed' || run.phase === 'aborted';
-}
-function statusColor(run, theme) {
-    if (run.phase === 'failed' || run.phase === 'aborted')
-        return theme.toolError;
-    if (run.phase === 'done')
-        return theme.toolDone;
-    if (isRunning(run))
-        return theme.toolRunning;
-    return theme.muted;
-}
-/**
- * How many characters the activity column may spend at this width (P0-1).
- *
- * `TEAM_LIMITS.activityChars` is a STORAGE ceiling; a terminal has a COLUMN
- * budget, and the two are not the same number. The row is
- *
- *     marker(3) + label(8) + description(flex) + 2 + activity + 2 + elapsed(~6)
- *
- * and the comment on the description cell below promises that activity and
- * elapsed never lose characters, i.e. that `description` absorbs ALL width
- * pressure. A 64-character prose tail plus `writing: ` is 73, which on an
- * 80-column terminal needs 94 columns before `description` gets one. The promise
- * cannot be kept by wishing; the column has to be sized from `cols`.
- *
- * `WIDE_CHAR_ALLOWANCE` is the concession to there being no display-width helper
- * in production code: this budget is denominated in code units while the
- * terminal is denominated in columns, and CJK and emoji occupy two columns per
- * unit, so the budget is halved against the reserve rather than spent to the
- * last cell. Erring small costs a few characters of prose; erring large costs
- * the elapsed column.
- */
-const ROW_RESERVED_COLS = 3 + 8 + 2 + 2 + 8 + 12; // marker, label, gaps, elapsed, min description
-const WIDE_CHAR_ALLOWANCE = 2;
-export function activityBudget(cols) {
-    const spare = Math.floor((cols - ROW_RESERVED_COLS) / WIDE_CHAR_ALLOWANCE);
-    return Math.max(TEAM_LIMITS.activityMinChars, Math.min(TEAM_LIMITS.activityChars, spare));
-}
-/**
- * The middle column: what this child is doing right now, in a few words.
- *
- * Two width policies, answering different questions. `wide` decides WHICH FACT
- * to show - a whole path or its basename, a whole command line or its program
- * name - mirroring `StatusBar`'s `statusCompactCols` degradation rather than
- * inventing a second threshold. `activityBudget(cols)` decides HOW MUCH OF IT
- * FITS, and it is a continuous function of width rather than a threshold,
- * because the failure it prevents - a row wider than the terminal - is
- * continuous.
- *
- * Exported for the same reason `buildSubagentTools` is: the width bound is the
- * property this round has to keep, and asserting it through a rendered frame
- * cannot distinguish "the arithmetic clamped it" from "Ink truncated it" - which
- * is precisely the confusion that let v1's fixed-width column look fine at 100
- * columns and break at 80.
- */
-export function activityLine(run, cols) {
-    const wide = cols >= TEAM_LIMITS.activityWideCols;
-    const budget = activityBudget(cols);
-    switch (run.phase) {
-        case 'queued':
-            return 'queued';
-        case 'starting':
-            // The one row that legitimately restarts its clock, saying why (P2-4):
-            // F-2 ranks the running group by `startedAt` and a retry re-stamps it.
-            return run.retries ? 'starting (retry)' : 'starting';
-        case 'thinking':
-            // Clamped AT RENDER, against this terminal's budget. `run.activity` was
-            // clamped at STORE against `activityChars`; that is a ceiling, not a fit.
-            return run.activity ? `writing: ${sanitizeActivity(run.activity, budget)}` : 'thinking';
-        case 'tool':
-        case 'waiting':
-            return run.lastTool
-                ? sanitizeActivity(describeToolActivity(run.lastTool, run.activityArgs, wide), budget)
-                : run.phase === 'waiting'
-                    ? 'waiting for mail'
-                    : 'tool';
-        case 'done':
-            // `compacted N` ON THE SETTLED ROW ONLY (hardening §3.4.4 / W3). A running
-            // row is already competing for `activityBudget(cols)` with the child's own
-            // prose, and a marker that displaces what the child is DOING right now
-            // buys nothing - the dispatch report carries the same fact for good.
-            return run.compactions
-                ? `done  ${run.turns} turns  compacted ${run.compactions}`
-                : `done  ${run.turns} turns`;
-        case 'failed':
-            return 'failed';
-        case 'aborted':
-            return 'aborted';
-    }
-}
-/** The past-tense word the supervisor badge and status line render. */
-function interventionWord(action) {
-    switch (action) {
-        case 'nudge':
-            return 'nudged';
-        case 'replace':
-            return 'replaced';
-        case 'abandon':
-            return 'abandoned';
-        default:
-            return 'waited';
-    }
-}
+import { interventionWord, teamRowCells, teamRowGeometry, TEAM_CLOCK_CELLS, } from './layout/team-row.js';
+import { fitCells } from './layout/cells.js';
 /**
- * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
- * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
- *
- * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
- * `startedAt`, so this is one subtraction - no second clock convention.
+ * THE ACTIVITY / BADGE HELPERS LIVE IN `layout/team-row.ts` NOW (v2 implementation
+ * note, recorded in the spec's "implementation findings"). `teamRowCells` has to
+ * compose the activity text with the supervisor badge, so keeping those functions
+ * in this component would make the two modules import each other. They are
+ * re-exported here so every existing import site keeps its path.
  */
-export function overseerBadge(run, at) {
-    const last = run.lastIntervention;
-    if (last === undefined)
-        return '';
-    return `${interventionWord(last.action)} ${formatDuration(Math.max(0, at - last.at))}`;
-}
-/**
- * The activity column WITH the badge composed in (AC-5 / risk table): the
- * badge rides the SAME `activityBudget(cols)` allocation the prose uses, so
- * a row can never grow past its terminal; on a narrow terminal the badge
- * degrades to the action word alone - the who-acted fact outranks the
- * what-they-are-doing tail exactly when there is room for only one.
- */
-export function activityWithBadge(run, cols, at) {
-    const last = run.lastIntervention;
-    if (last === undefined)
-        return activityLine(run, cols);
-    const badge = overseerBadge(run, at);
-    if (cols < TEAM_LIMITS.activityWideCols)
-        return interventionWord(last.action);
-    return sanitizeActivity(`${badge}; ${activityLine(run, cols)}`, activityBudget(cols));
-}
+export { activityBudget, activityLine, activityWithBadge, overseerBadge, teamClockText, teamRowCells, teamRowGeometry, } from './layout/team-row.js';
 /**
  * The panel's one supervisor status line (AC-5): the most recent intervention
  * across the roster, human-phrased. Empty when the supervisor has not acted
@@ -164,6 +36,9 @@ export function supervisorStatusLine(runs, at) {
     const head = latest.reasonHead.length > 0 ? ` (${latest.reasonHead})` : '';
     return `supervisor: ${interventionWord(latest.action)} ${label} ${ago} ago${head}`;
 }
+/** Columns the `ctrl+b` hint cell spends, and the width below which it is dropped. */
+const HINT_CELLS = 'ctrl+b'.length;
+const HINT_MIN_COLS = 100;
 export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, layout, }) {
     const projection = layout ?? buildTeamPanelLayout({
         snapshot, terminalRows: rows, availableRows: Infinity,
@@ -172,42 +47,57 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
         return null;
     const glyphs = pickGlyphs(caps);
     const at = now ?? Date.now();
-    const running = snapshot.runs.filter(isRunning).length;
-    const done = snapshot.runs.filter(isSettled).length;
+    // ONE COUNTING AUTHORITY (A-1): `queued` used to fall between `isRunning` and
+    // `isSettled`, so a fresh dispatch read `0 running  0 done` above rows that each
+    // said `queued`.
+    const counts = rosterCounts(snapshot.runs);
     const elapsed = formatDuration(Math.max(0, at - snapshot.startedAt));
-    const header = (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { wrap: "truncate", color: theme.accent, bold: true, children: [glyphs.teamAgent, " team", '  ', _jsxs(Text, { color: theme.muted, children: [running, " running ", glyphs.midDot, " ", done, " done ", glyphs.midDot, " ", elapsed] })] }), snapshot.messageCount > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.teamMail, " ", snapshot.messageCount] }))] }));
+    const g = teamRowGeometry(cols, glyphs);
+    // WIDTH IS BUDGETED ONCE (I-13). `rosterHeadline` subtracts its own
+    // HEADER_RESERVED_COLS(16) - it takes the ROW's column count, not a budget - so
+    // the caller may only take away the cells this feature ADDS. Subtracting 16 here
+    // too would spend the reserve twice and drop `done` / `queued` from a 100-column
+    // header that has room for them.
+    const showHint = cols >= HINT_MIN_COLS && !projection.collapsed;
+    const headlineCols = Math.max(0, cols - TEAM_CLOCK_CELLS - (showHint ? HINT_CELLS : 0));
+    const mailText = `${glyphs.teamMail} ${snapshot.messageCount}`;
+    // The badge takes its NATURAL width and the flexible left cell gives way: it is
+    // the only header cell whose content length varies, and pinning it to a computed
+    // width would clip `@ 12` on a row that has room for it.
+    const mailCells = Math.min(mailText.length, Math.max(0, cols - TEAM_CLOCK_CELLS));
+    /**
+     * The header is the row's own geometry one level up: a flexible left cell and
+     * fixed right-hand cells, so the dispatch clock and every child clock stand in
+     * the SAME column (I-5 / AC-2).
+     *
+     * THE ELAPSED TIME APPEARS ONLY IN THE CLOCK CELL (§4.3 / RV-P2-9). The old
+     * header also carried it inline among the count clauses; with a right-edge clock
+     * that would be the same number twice, and the pair could disagree for one frame
+     * every 200 ms.
+     */
+    const header = (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: theme.accent, bold: true, children: [glyphs.teamAgent, ' team  ', _jsx(Text, { color: theme.muted, children: rosterHeadline(counts, glyphs, headlineCols) })] }) }), showHint && (_jsx(Box, { width: HINT_CELLS, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.hintFg, children: "ctrl+b" }) })), snapshot.messageCount > 0 && (_jsx(Box, { width: mailCells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: mailText }) })), _jsx(Box, { width: TEAM_CLOCK_CELLS, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.accent, bold: true, children: elapsed }) })] }));
     // Short terminals or a long draft leave only the shared header projection,
-    // which still answers whether anything is running and for how long.
+    // which still answers whether anything is running and for how long. The header
+    // keeps the count clauses AND the right-edge clock, so the collapsed form loses
+    // no information - only the per-child rows.
     if (projection.collapsed) {
-        return _jsx(Box, { flexDirection: "column", flexShrink: 0, children: header });
+        return _jsx(Box, { flexDirection: "column", width: "100%", flexShrink: 0, children: header });
     }
     // RANKED, not sliced by array index (F-2). The slot pool hands out indices in
     // order, so `slice(0, 5)` showed the five children that finished FIRST and hid
     // everything still working behind `+N more` - at exactly the fan-out widths
     // the requirement permits.
     const { visible, hiddenTotal, hiddenRunning } = projection;
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [header, visible.map((run) => {
-                const color = statusColor(run, theme);
+    const supervisorLine = supervisorStatusLine(snapshot.runs, at);
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", flexShrink: 0, children: [header, visible.map((run) => {
+                const status = childStatus(run);
+                const color = statusColor(status, theme);
                 // One spinner per RUNNING row, and the row cap is 5 precisely because
                 // five is the documented maximum number of simultaneous spinners. Both
                 // `reducedMotion` and a non-Unicode terminal fall back to the same
                 // static marker, exactly as `AssistantEntry` and `ToolCard` already do.
-                const animate = isRunning(run) && !reducedMotion && caps.unicode;
-                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityWithBadge(run, cols, at)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
-            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), (() => {
-                // The panel's supervisor line (AC-5): one row, only when the
-                // supervisor has actually acted - the per-row badges above already
-                // carry the per-child facts.
-                const line = supervisorStatusLine(snapshot.runs, at);
-                return line ? (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', line] })) : null;
-            })(), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
-}
-function marker(run, glyphs) {
-    if (run.phase === 'done')
-        return glyphs.toolDone;
-    if (run.phase === 'failed' || run.phase === 'aborted')
-        return glyphs.toolError;
-    if (run.phase === 'queued')
-        return glyphs.toolPending;
-    return glyphs.spinnerStill;
+                const animate = isRunningStatus(status) && !reducedMotion && caps.unicode;
+                const cells = teamRowCells(run, cols, at, glyphs);
+                return (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: g.marker, flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : cells.marker, ' '] }) }), _jsx(Box, { width: g.label, flexShrink: 0, children: _jsx(Text, { wrap: "truncate", color: theme.primary, children: cells.label }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: cells.description }) }), _jsx(Box, { width: g.gap, flexShrink: 0, children: _jsx(Text, { children: " " }) }), _jsx(Box, { width: g.activity, flexShrink: 0, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: color, children: cells.activity }) }), _jsx(Box, { width: g.clock, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: cells.clock }) })] }, run.label));
+            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), supervisorLine.length > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', fitCells(supervisorLine, Math.max(0, cols - 2), glyphs.ellipsis)] })), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
 }

package/dist/ui/TodoPanel.d.ts

@@ -1,5 +1,6 @@
 /**
- * TodoPanel — the right rail (todo-plan-execution §6.1).
+ * TodoPanel — the right rail (todo-plan-execution §6.1; two sections per
+ * todo-acceptance-criteria §6.9).
  *
  * ASCII ONLY: every glyph comes from `pickGlyphs`; a literal here bypasses the
  * capability probe and shows mojibake on a legacy console (`glyphs.ts` header).
@@ -8,22 +9,24 @@
  * this component is not rendered at all, so a session that never plans has zero
  * columns and zero layout shift (R-g's "no furniture when idle" / AC-24).
  *
+ * NO NEW PROP CARRIES THE ACCEPTANCE TABLE (§6.9.1): `snapshot.acceptance` is
+ * already inside `snapshot`, and `null` IS the projection of "the capability is
+ * off", because a disabled store commits an empty table. Keeping the props surface
+ * narrow is what keeps `App`'s two mount points untouched.
+ *
  * IT MUST BE MOUNTED IN `AppShell`'s MIDDLE BAND, NEVER IN THE BOTTOM CHROME
  * (C-6 / I-4). This is a COLUMN BESIDE the viewport, and the middle band is the
- * only row-wrapped region there is; moved down into the bottom chrome it would
- * stop being a rail and start eating viewport height, growing and shrinking the
+ * only row-wrapped region there is; moved down into the bottom chrome it would stop
+ * being a rail and start eating viewport height, growing and shrinking the
  * transcript every time the list changed length.
  *
  * WIDTH IS MEASURED IN COLUMNS, NEVER IN CODE UNITS (P2-3). This rail is 14-36
  * columns wide and the system prompt's last line is "Respond in the language the
- * user writes in", so CJK item text in an 18-column rail is the NORMAL case
- * rather than the edge case. Every text cell is `wrap="truncate"` and Ink's
- * truncation is display-width aware, so nothing can overflow the box — and NO
- * ARITHMETIC HERE MAY BUDGET USER TEXT BY `.length`. The count string and
- * `padStart(2)` cells below are ASCII counts and indices, which is why they are
- * safe; a "characters that fit" calculation over `content` would not be. That is
- * the whole of the lesson `TeamPanel`'s `WIDE_CHAR_ALLOWANCE` records at length,
- * and the mitigation here is to have no such budget at all.
+ * user writes in", so CJK text in an 18-column rail is the NORMAL case rather than
+ * the edge case. Every text cell is `wrap="truncate"` and Ink's truncation is
+ * display-width aware, so nothing can overflow the box - and NO ARITHMETIC HERE MAY
+ * BUDGET USER TEXT BY `.length`. The count strings and `padStart(2)` cells below are
+ * ASCII counts and indices, which is why they are safe.
  */
 import React from 'react';
 import type { Theme } from './theme.js';
@@ -35,9 +38,9 @@ export interface TodoPanelProps {
     width: number;
     /**
      * From `buildTodoRailLayout` after actual team/menu rows are subtracted.
-     * (I-10 / P1-3). The gate that mounts this component and the number it lays
-     * out against are ONE value computed once in `App`: a panel that mounts on one
-     * number and lays out against another renders nothing and reports nothing.
+     * (I-10 / P1-3). The gate that mounts this component and the number it lays out
+     * against are ONE value computed once in `App`: a panel that mounts on one number
+     * and lays out against another renders nothing and reports nothing.
      */
     rows: number;
     /** Whether the agent is running; gates the spinner (never animate when idle). */

package/dist/ui/TodoPanel.js

@@ -1,6 +1,7 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
- * TodoPanel — the right rail (todo-plan-execution §6.1).
+ * TodoPanel — the right rail (todo-plan-execution §6.1; two sections per
+ * todo-acceptance-criteria §6.9).
  *
  * ASCII ONLY: every glyph comes from `pickGlyphs`; a literal here bypasses the
  * capability probe and shows mojibake on a legacy console (`glyphs.ts` header).
@@ -9,22 +10,24 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * this component is not rendered at all, so a session that never plans has zero
  * columns and zero layout shift (R-g's "no furniture when idle" / AC-24).
  *
+ * NO NEW PROP CARRIES THE ACCEPTANCE TABLE (§6.9.1): `snapshot.acceptance` is
+ * already inside `snapshot`, and `null` IS the projection of "the capability is
+ * off", because a disabled store commits an empty table. Keeping the props surface
+ * narrow is what keeps `App`'s two mount points untouched.
+ *
  * IT MUST BE MOUNTED IN `AppShell`'s MIDDLE BAND, NEVER IN THE BOTTOM CHROME
  * (C-6 / I-4). This is a COLUMN BESIDE the viewport, and the middle band is the
- * only row-wrapped region there is; moved down into the bottom chrome it would
- * stop being a rail and start eating viewport height, growing and shrinking the
+ * only row-wrapped region there is; moved down into the bottom chrome it would stop
+ * being a rail and start eating viewport height, growing and shrinking the
  * transcript every time the list changed length.
  *
  * WIDTH IS MEASURED IN COLUMNS, NEVER IN CODE UNITS (P2-3). This rail is 14-36
  * columns wide and the system prompt's last line is "Respond in the language the
- * user writes in", so CJK item text in an 18-column rail is the NORMAL case
- * rather than the edge case. Every text cell is `wrap="truncate"` and Ink's
- * truncation is display-width aware, so nothing can overflow the box — and NO
- * ARITHMETIC HERE MAY BUDGET USER TEXT BY `.length`. The count string and
- * `padStart(2)` cells below are ASCII counts and indices, which is why they are
- * safe; a "characters that fit" calculation over `content` would not be. That is
- * the whole of the lesson `TeamPanel`'s `WIDE_CHAR_ALLOWANCE` records at length,
- * and the mitigation here is to have no such budget at all.
+ * user writes in", so CJK text in an 18-column rail is the NORMAL case rather than
+ * the edge case. Every text cell is `wrap="truncate"` and Ink's truncation is
+ * display-width aware, so nothing can overflow the box - and NO ARITHMETIC HERE MAY
+ * BUDGET USER TEXT BY `.length`. The count strings and `padStart(2)` cells below are
+ * ASCII counts and indices, which is why they are safe.
  */
 import { useMemo } from 'react';
 import { Box, Text } from 'ink';
@@ -34,18 +37,21 @@ import { buildGauge } from './gauge.js';
 import { railBorderProps } from './layout/Gutter.js';
 import { TODO_RAIL_INDEX_MIN_COLS } from './layout/rail.js';
 import { TODO_LIMITS } from '../todo/limits.js';
-import { selectCompactTodoRows, selectTodoRows } from '../todo/panel-rows.js';
-/** Header row + the blank row under the gauge. */
-const FIXED_ROWS = 2;
+import { derivePlanPhase } from '../todo/acceptance.js';
+import { buildPlanSections } from '../todo/plan-sections.js';
+import { selectAcceptanceRows, selectCompactAcceptanceRows, selectCompactTodoRows, selectTodoRows, } from '../todo/panel-rows.js';
 /** The gauge is the one purely decorative element, so it is the first to go. */
 const GAUGE_MIN_ROWS = 8;
 const GAUGE_MIN_COLS = 20;
 /** Separator column + one space of padding, supplied by `railBorderProps`. */
 const CHROME_COLS = 2;
-/** Marker cell. Three, because the ASCII tier's `[x]` / `[ ]` are three wide. */
+/** Marker cell. Three, because the ASCII tier's `[x]` / `[ ]` / `[!]` are three wide. */
 const MARKER_COLS = 3;
 /** Index cell: two digits plus the space that separates it from the text. */
 const INDEX_COLS = 3;
+/** `ACCEPT` / `VERIFY` are both six columns, so switching phase shifts nothing (D-8). */
+const ACCEPT_LABEL = 'ACCEPT';
+const VERIFY_LABEL = 'VERIFY';
 function marker(item, glyphs) {
     // Ink's tokenizer otherwise treats the bare emoji-capable check as one cell,
     // while string-width counts two, adding an extra visible space to each row.
@@ -56,6 +62,21 @@ function marker(item, glyphs) {
         return glyphs.todoActive;
     return glyphs.todoPending;
 }
+/**
+ * `passed` REUSES THE DONE GLYPH ON PURPOSE (D-9): it is the same settled positive,
+ * so two colour ramps and two shapes for one meaning would be learned twice for
+ * nothing. `failed` is the only new meaning, and it gets the only new glyph.
+ */
+function acceptanceMarker(item, glyphs) {
+    if (item.status === 'passed') {
+        return glyphs.todoDone.length === 1 ? `${glyphs.todoDone}\uFE0F` : glyphs.todoDone;
+    }
+    if (item.status === 'failed')
+        return glyphs.todoFail;
+    if (item.status === 'in_progress')
+        return glyphs.todoActive;
+    return glyphs.todoPending;
+}
 function rowColor(item, theme) {
     if (item.status === 'completed')
         return theme.muted;
@@ -63,44 +84,131 @@ function rowColor(item, theme) {
         return theme.primary;
     return theme.hintFg ?? theme.muted;
 }
+function acceptanceRowColor(item, theme) {
+    if (item.status === 'failed')
+        return theme.toolError;
+    if (item.status === 'passed')
+        return theme.muted;
+    if (item.status === 'in_progress')
+        return theme.primary;
+    return theme.hintFg ?? theme.muted;
+}
 export function TodoPanel({ snapshot, width, rows, running, reducedMotion, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
-    // Ink reapplies all four Yoga borders when the borderStyle object changes,
-    // but unchanged borderTop/Bottom=false props are not reapplied on that update.
+    // Ink reapplies all four Yoga borders when the borderStyle object changes, but
+    // unchanged borderTop/Bottom=false props are not reapplied on that update.
     const border = useMemo(() => railBorderProps(glyphs.railVertical), [glyphs.railVertical]);
     if (snapshot.items.length === 0 || rows < TODO_LIMITS.panelMinRows)
         return null;
     const compact = rows < TODO_LIMITS.panelFullRows;
     const showGauge = width >= GAUGE_MIN_COLS && rows >= GAUGE_MIN_ROWS;
     const showIndex = !compact && width >= TODO_RAIL_INDEX_MIN_COLS;
-    const compactFooter = compact && snapshot.items.length > rows - 1;
-    const itemRows = compact ? rows - 1 - Number(compactFooter)
-        : rows - FIXED_ROWS - Number(showGauge);
-    const { visible, hiddenAbove, hiddenBelow } = compact
-        ? selectCompactTodoRows(snapshot.items, itemRows)
-        : selectTodoRows(snapshot.items, itemRows);
+    const acceptance = snapshot.acceptance;
+    const acceptanceItems = acceptance?.items ?? [];
+    const phase = derivePlanPhase(snapshot.items, acceptanceItems);
+    // EVERY ROW FIGURE COMES FROM ONE FUNCTION (§6.9.2). Not because arithmetic in a
+    // component is hard, but because `/perf` and the status-bar chip have to report
+    // the same answer, and a second copy is a second answer.
+    const sections = buildPlanSections({
+        rows,
+        width,
+        phase,
+        todoCount: snapshot.items.length,
+        acceptanceCount: acceptanceItems.length,
+        showGauge,
+    });
+    const compactFooter = sections.todoFooter;
+    const todoWindow = compact
+        ? selectCompactTodoRows(snapshot.items, sections.todoItemRows)
+        : selectTodoRows(snapshot.items, sections.todoItemRows);
+    const acceptanceSection = sections.acceptance;
+    const acceptanceWindow = acceptanceSection && acceptanceSection.itemRows > 0
+        ? compact
+            ? selectCompactAcceptanceRows(acceptanceItems, acceptanceSection.itemRows)
+            : selectAcceptanceRows(acceptanceItems, acceptanceSection.itemRows)
+        : { visible: [], hiddenAbove: 0, hiddenBelow: 0 };
     const pct = snapshot.total > 0 ? Math.round((snapshot.doneCount / snapshot.total) * 100) : 0;
     const gauge = buildGauge(pct, Math.max(4, width - CHROME_COLS - 2), theme, caps);
     const complete = snapshot.doneCount === snapshot.total;
     const countText = `${snapshot.doneCount}/${snapshot.total}`;
-    const showDone = complete
-        && width - CHROME_COLS >= 'TODO '.length + countText.length + ' done'.length;
+    const showDone = complete && fitsDone(width, countText, 'TODO');
     const count = `${countText}${showDone ? ' done' : ''}`;
+    // ONE CALL EACH: the text is both the header's right-hand cell and the width that
+    // cell is measured with, so computing it twice invites the two to drift.
+    const acceptanceCountLabel = acceptanceCountText(acceptance, width);
+    const acceptanceTone = acceptanceColor(acceptance, theme);
+    // The `summary` rung has NO `done` rung (§6.9.3): one muted line, or the error
+    // colour when something failed. Green is a verdict about a table the narrow rail is
+    // not showing, and claiming it in one line would be the only place in this feature
+    // where a colour says more than the text does.
+    const hasFailed = (acceptance?.failedCount ?? 0) > 0;
+    const acceptanceSummaryTone = hasFailed ? theme.toolError : theme.muted;
+    // `verify` collapses the step list to ONE row: every step is done, so seven rows
+    // of "completed" buy no information and cost the rows the eye needs (D-7). The
+    // marker cell is still reserved so the two sections stay column-aligned.
+    const showTodoItems = phase !== 'verify';
+    // THE `-N +M` FOOTER DESCRIBES A WINDOW THAT IS ON SCREEN. In `verify` the list is
+    // collapsed on purpose, so the marker would advertise rows the user cannot reach
+    // (`-0 +5` under "all steps complete" is the exact opposite of the sentence above
+    // it). The rows it would have occupied stay blank inside the fixed-height box.
+    const showCompactFooter = compactFooter && showTodoItems;
     return (
     // `flexShrink={0}` IS LOAD-BEARING (P1-4). Ink's `Box.defaultProps` is
-    // `{ flexWrap:'nowrap', flexDirection:'row', flexGrow:0, flexShrink:1 }`, so
-    // a `width={n}` box inside a shrinking row is SQUEEZED under pressure — and
-    // every piece of arithmetic in `rail.ts` silently becomes a suggestion at
-    // exactly the narrow widths where the guarantee matters. `ScrollIndicator`
-    // spells the same pair one level down. Height uses the same row budget as
-    // selection, so content cannot silently enlarge the middle band.
-    _jsxs(Box, { flexDirection: "column", flexShrink: 0, width: width, height: rows, overflow: "hidden", paddingLeft: 1, ...border, borderColor: theme.border, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.accent, bold: true, children: "TODO" }) }), _jsx(Box, { width: count.length, flexShrink: 0, children: _jsx(Text, { wrap: "truncate", color: complete ? theme.toolDone : theme.muted, children: count }) })] }), showGauge && (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty })] })), !compact && _jsx(Text, { children: " " }), !compact && hiddenAbove > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['   ', "+", hiddenAbove, " above"] })), visible.map(({ item, index }) => {
+    // `{ flexWrap:'nowrap', flexDirection:'row', flexGrow:0, flexShrink:1 }`, so a
+    // `width={n}` box inside a shrinking row is SQUEEZED under pressure - and every
+    // piece of arithmetic in `rail.ts` silently becomes a suggestion at exactly the
+    // narrow widths where the guarantee matters. `ScrollIndicator` spells the same
+    // pair one level down. Height uses the same row budget as selection, so content
+    // cannot silently enlarge the middle band.
+    _jsxs(Box, { flexDirection: "column", flexShrink: 0, width: width, height: rows, overflow: "hidden", paddingLeft: 1, ...border, borderColor: theme.border, children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.accent, bold: true, children: "TODO" }) }), _jsx(Box, { width: count.length, flexShrink: 0, children: _jsx(Text, { wrap: "truncate", color: complete ? theme.toolDone : theme.muted, children: count }) })] }), showGauge && (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty })] })), !compact && _jsx(Text, { children: " " }), !compact && showTodoItems && todoWindow.hiddenAbove > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['   ', "+", todoWindow.hiddenAbove, " above"] })), showTodoItems && todoWindow.visible.map(({ item, index }) => {
                 const active = item.status === 'in_progress';
-                // The spinner is gated on `running`: a spinner while the agent is idle
-                // is a lie about the state of the world, and this panel outlives the run
-                // that filled it. Reduced motion and a non-Unicode terminal fall back to
-                // the same static marker, exactly as `AssistantEntry` and `TeamPanel` do.
+                // The spinner is gated on `running`: a spinner while the agent is idle is a
+                // lie about the state of the world, and this panel outlives the run that
+                // filled it. Reduced motion and a non-Unicode terminal fall back to the same
+                // static marker, exactly as `AssistantEntry` and `TeamPanel` do.
                 const animate = active && running && !reducedMotion && caps.unicode;
                 return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, width: MARKER_COLS, children: _jsx(Text, { color: rowColor(item, theme), bold: active, children: animate ? _jsx(Spinner, { type: "dots" }) : marker(item, glyphs) }) }), showIndex && (_jsx(Box, { flexShrink: 0, width: INDEX_COLS, children: _jsx(Text, { color: theme.muted, children: String(index + 1).padStart(2) }) })), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: rowColor(item, theme), bold: active, children: active ? item.activeForm : item.content }) })] }, `${index}-${item.content}`));
-            }), compactFooter && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ["-", hiddenAbove, " +", hiddenBelow] })), !compact && hiddenBelow > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['   ', "+", hiddenBelow, " more"] }))] }, glyphs.railVertical));
+            }), phase === 'verify' && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['   ', "all steps complete"] })), showCompactFooter && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ["-", todoWindow.hiddenAbove, " +", todoWindow.hiddenBelow] })), !compact && showTodoItems && todoWindow.hiddenBelow > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['   ', "+", todoWindow.hiddenBelow, " more"] })), acceptanceSection && acceptanceSection.reason === 'summary' && (_jsxs(Text, { wrap: "truncate", color: acceptanceSummaryTone, children: ['   ', "AC ", summaryCount(acceptance)] })), acceptanceSection && acceptanceSection.reason === 'visible' && (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.accent, bold: true, children: phase === 'verify' ? VERIFY_LABEL : ACCEPT_LABEL }) }), _jsx(Box, { width: acceptanceCountLabel.length, flexShrink: 0, children: _jsx(Text, { wrap: "truncate", color: acceptanceTone, children: acceptanceCountLabel }) })] }), acceptanceWindow.visible.map(({ item, index }) => {
+                        const active = item.status === 'in_progress';
+                        const animate = active && running && !reducedMotion && caps.unicode;
+                        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, width: MARKER_COLS + 1, children: _jsx(Text, { color: acceptanceRowColor(item, theme), bold: active, children: animate ? _jsx(Spinner, { type: "dots" }) : acceptanceMarker(item, glyphs) }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: acceptanceRowColor(item, theme), bold: active, children: item.content }) })] }, `acc-${index}-${item.content}`));
+                    })] }))] }, glyphs.railVertical));
+}
+/**
+ * Does the section's count fit beside its label? The same width guard the TODO
+ * header uses for ` done`, so a narrow rail drops the suffix rather than the number.
+ */
+function fitsDone(width, countText, label) {
+    return width - CHROME_COLS >= label.length + 1 + countText.length + ' done'.length;
+}
+/** `<checked>/<total>`, ` !<failed>`, and ` done` when every criterion passed. */
+function acceptanceCountText(acceptance, width) {
+    if (!acceptance)
+        return '';
+    const base = `${acceptance.checkedCount}/${acceptance.total}`;
+    const failed = acceptance.failedCount > 0 ? ` !${acceptance.failedCount}` : '';
+    const allPassed = acceptance.checkedCount === acceptance.total && acceptance.failedCount === 0;
+    const done = allPassed && fitsDone(width, base, VERIFY_LABEL) ? ' done' : '';
+    return `${base}${failed}${done}`;
+}
+/** The `summary` rung's single line: `2/5`, plus ` !1` when something failed. */
+function summaryCount(acceptance) {
+    if (!acceptance)
+        return '';
+    return `${acceptance.checkedCount}/${acceptance.total}` +
+        (acceptance.failedCount > 0 ? ` !${acceptance.failedCount}` : '');
+}
+/**
+ * All passed reads as done, any failure reads as an error, everything else is
+ * muted - the same three-rung colour ladder the TODO header uses.
+ */
+function acceptanceColor(acceptance, theme) {
+    if (!acceptance)
+        return theme.muted;
+    if (acceptance.failedCount > 0)
+        return theme.toolError;
+    if (acceptance.total > 0 && acceptance.checkedCount === acceptance.total) {
+        return theme.toolDone;
+    }
+    return theme.muted;
 }

package/dist/ui/Transcript.js

@@ -12,6 +12,7 @@ import { QueuedEntry } from './entries/QueuedEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
+import { isLiveTeamCard, rosterCounts } from './team-status.js';
 import { TodoCard, todoCardColor } from './entries/TodoCard.js';
 import { RetryCard, retryCardColor } from './entries/RetryCard.js';
 import { FastCard, fastCardColor } from './entries/FastCard.js';
@@ -42,6 +43,12 @@ export function nowSecFor(entry, nowSec) {
     // function protects is unchanged for every other card, forever.
     if (entry.kind === 'compaction' && entry.live)
         return nowSec;
+    // THE FOURTH CONSUMER IS A LIVE DISPATCH CARD (tui-subagent-double-roster A-1):
+    // a child's elapsed time must advance while it works, and `TeamCard` reads this
+    // same 1 Hz clock instead of a second `Date.now()` per render. A suppressed card
+    // never mounts, so this only keeps the reading honest for a directly mounted one.
+    if (entry.kind === 'team' && entry.active)
+        return nowSec;
     // THE THIRD CONSUMER IS A LIVE JOB (long-task-jobs D-8), and it is the reason
     // this stays a single 1 Hz clock: a task's elapsed time and its `no output`
     // badge both have to move, and a per-card `setInterval` would be one timer per
@@ -96,10 +103,23 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
                 // comparator sees a fresh `[]` as a changed prop, which is why that
                 // file already keeps a shared `EMPTY_LINES`.
                 live: entry.live, lastOutputAt: entry.lastOutputAt, nowSec: nowSec, theme: theme, caps: caps }));
-        case 'team':
-            return frame(glyphs.teamAgent, teamCardColor(entry.runs, entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
+        case 'team': {
+            // THE LIVE DISPATCH HAS EXACTLY ONE SURFACE (tui-subagent-double-roster A-2):
+            // while `active`, the roster (`TeamPanel`) is the only live subagent block, so
+            // the transcript draws nothing for this entry and the card appears - once - as
+            // history the moment the dispatch settles. Returning BEFORE `frame(...)` draws
+            // neither the rail marker nor the separation row.
+            //
+            // `renderer.tsx`'s offscreen measurement goes through THIS function too, which is
+            // what makes the native print pump's `measureWindow` agree with the frame for
+            // free. `estimateEntryRows` carries the same predicate (0 rows), so no other
+            // arithmetic has to know about the suppression.
+            if (isLiveTeamCard(entry))
+                return null;
+            return frame(glyphs.teamAgent, teamCardColor(rosterCounts(entry.runs), entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps, nowSec: nowSecFor(entry, nowSec) }));
+        }
         case 'todo':
-            return frame(toolGlyph(glyphs, 'todo_write'), todoCardColor(entry.doneCount, entry.total, entry.live, theme), _jsx(TodoCard, { items: entry.items, doneCount: entry.doneCount, total: entry.total, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
+            return frame(toolGlyph(glyphs, 'todo_write'), todoCardColor(entry.doneCount, entry.total, entry.live, theme), _jsx(TodoCard, { items: entry.items, doneCount: entry.doneCount, total: entry.total, acceptance: entry.acceptance ?? null, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
         case 'retry':
             return frame(entry.phase === 'exhausted' ? glyphs.error : glyphs.retry, retryCardColor(entry.phase, theme), _jsx(RetryCard, { attempt: entry.attempt, maxRetries: entry.maxRetries, errorType: entry.errorType, phase: entry.phase, resumeAt: entry.resumeAt, totalRetries: entry.totalRetries, elapsedMs: entry.elapsedMs, 
                 // READ HERE, not threaded from `App`, and that is what keeps the memo