@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/composer-input.d.ts

@@ -3,10 +3,20 @@ export interface ComposerSubmitResult {
     accepted: boolean;
     reason?: string;
 }
+/**
+ * A fill carries the prompt body; `submit` folds "insert and send" into the SAME
+ * transaction, so `Ctrl+Enter` in the picker is literally the Enter key one step
+ * later rather than a second submission path (quick-prompt-library P0-1 / I-9).
+ */
 export type ComposerInputIntent = InputSegment | {
     kind: 'newline';
 } | {
     kind: 'submit';
+} | {
+    kind: 'fill';
+    text: string;
+    mode: 'insert' | 'replace';
+    submit: boolean;
 };
 export interface ComposerInputOptions {
     editor: EditorState;

package/dist/ui/composer-input.js

@@ -1,5 +1,28 @@
 import { editorReducer } from './editor-reducer.js';
+import { planPromptFill } from '../prompts/fill.js';
 const MORE_INPUT_NOTICE = 'More input is kept in the draft; press Enter to send.';
+/**
+ * Apply one fill to one draft. TWO CALLS PER INTENT, on purpose: the same plan runs
+ * against the accepted and the rejected draft (P0-1), so a submission the host
+ * refuses leaves the FILLED text in the composer rather than the text from before
+ * the fill. Doing it once and sharing the result would silently drop the prompt the
+ * user just chose, which is the data loss this design exists to prevent.
+ *
+ * THE REDUCER OWNS THE RESULT. `planPromptFill` says what to insert; `insert` and
+ * `replace` decide the caret, the paste-token snapping and the draft-flag reset,
+ * exactly as they do for typing.
+ */
+function applyFill(editor, intent) {
+    const plan = planPromptFill({
+        draft: editor.buffer,
+        cursor: editor.cursor,
+        content: intent.text,
+        mode: intent.mode,
+    });
+    return plan.mode === 'replace'
+        ? editorReducer(editor, { type: 'replace', buffer: plan.text, cursor: plan.cursor })
+        : editorReducer(editor, { type: 'insert', text: plan.text });
+}
 /**
  * Plan both accepted and rejected drafts before any submission side effect.
  * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
@@ -13,34 +36,44 @@ export function planComposerInput(options) {
     let submission;
     let notice;
     for (const intent of options.intents) {
-        if (intent.kind === 'submit') {
-            const text = options.resolveSubmit(nextEditor);
-            if (submission !== undefined) {
-                notice = MORE_INPUT_NOTICE;
-            }
-            else if (text !== null && text.trim().length > 0) {
-                submission = text;
-                nextEditor = editorReducer(nextEditor, { type: 'clear' });
-                acceptedBase = nextEditor;
-                acceptedPastes = [];
+        if (intent.kind === 'fill') {
+            nextEditor = applyFill(nextEditor, intent);
+            rejectedEditor = applyFill(rejectedEditor, intent);
+            // A plain fill stops here: the draft is filled, nothing is sent (AC-16).
+            if (!intent.submit)
+                continue;
+        }
+        else if (intent.kind !== 'submit') {
+            const segment = intent.kind === 'newline'
+                ? { kind: 'text', text: '\n' } : intent;
+            const segments = [segment];
+            if (segment.kind === 'paste') {
+                // Inline pastes have no map entry; count every paste in this callback as before.
+                acceptedPastes.push(segment);
+                rejectedPastes.push(segment);
+                const refusal = options.checkPasteLimit(acceptedPastes, acceptedBase)
+                    ?? options.checkPasteLimit(rejectedPastes, options.editor);
+                if (refusal) {
+                    return { nextEditor: options.editor, rejectedEditor: options.editor, refusal };
+                }
             }
+            nextEditor = editorReducer(nextEditor, { type: 'input', segments });
+            rejectedEditor = editorReducer(rejectedEditor, { type: 'input', segments });
             continue;
         }
-        const segment = intent.kind === 'newline'
-            ? { kind: 'text', text: '\n' } : intent;
-        const segments = [segment];
-        if (segment.kind === 'paste') {
-            // Inline pastes have no map entry; count every paste in this callback as before.
-            acceptedPastes.push(segment);
-            rejectedPastes.push(segment);
-            const refusal = options.checkPasteLimit(acceptedPastes, acceptedBase)
-                ?? options.checkPasteLimit(rejectedPastes, options.editor);
-            if (refusal) {
-                return { nextEditor: options.editor, rejectedEditor: options.editor, refusal };
-            }
+        // THE ONE SUBMIT PATH. A `fill` with `submit` and a bare `submit` reach this
+        // block and nothing else, so queueing, paste expansion and the
+        // accepted/rejected contract are inherited rather than re-implemented.
+        const text = options.resolveSubmit(nextEditor);
+        if (submission !== undefined) {
+            notice = MORE_INPUT_NOTICE;
+        }
+        else if (text !== null && text.trim().length > 0) {
+            submission = text;
+            nextEditor = editorReducer(nextEditor, { type: 'clear' });
+            acceptedBase = nextEditor;
+            acceptedPastes = [];
         }
-        nextEditor = editorReducer(nextEditor, { type: 'input', segments });
-        rejectedEditor = editorReducer(rejectedEditor, { type: 'input', segments });
     }
     return { nextEditor, rejectedEditor, submission, notice };
 }

package/dist/ui/entries/TeamCard.d.ts

@@ -15,6 +15,7 @@ import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { SubagentRun } from '../../team/types.js';
+import { type RosterCounts } from '../team-status.js';
 export interface TeamCardProps {
     requested: number;
     runs: SubagentRun[];
@@ -25,9 +26,24 @@ export interface TeamCardProps {
     reducedMotion?: boolean;
     theme: Theme;
     caps: TermCapabilities;
+    /**
+     * Wall-clock seconds, set only while the dispatch is live (`nowSecFor`). WITHOUT
+     * IT a running child's elapsed time came from `(endedAt ?? 0) - startedAt` - a
+     * negative number clamped to `0ms`, the readout that contradicted the roster
+     * beside it (A-1 / E4).
+     */
+    nowSec?: number;
 }
-/** The card's aggregate colour: any failure dominates. */
-export declare function teamCardColor(runs: SubagentRun[], active: boolean, aborted: boolean, theme: Theme): string | undefined;
+/**
+ * The card's aggregate colour.
+ *
+ * FAILURES DOMINATE, THEN A CANCELLATION, THEN A DISPATCH THAT NEVER SETTLED.
+ * The old version asked `runs.some((r) => !isOk(r))`, so an entry whose children
+ * were still working - and one the user had cancelled - was painted `toolError`
+ * (A-1 / E8). `RosterCounts` is passed IN rather than recomputed, so this colour
+ * and the headline cannot disagree inside one card.
+ */
+export declare function teamCardColor(counts: RosterCounts, active: boolean, aborted: boolean, theme: Theme): string | undefined;
 declare function TeamCardImpl(props: TeamCardProps): React.ReactElement;
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

package/dist/ui/entries/TeamCard.js

@@ -18,37 +18,71 @@ import Spinner from 'ink-spinner';
 import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
 import { formatDuration } from '../../agent/usage.js';
-function isOk(run) {
-    return run.phase === 'done' && !run.error;
-}
-/** The card's aggregate colour: any failure dominates. */
-export function teamCardColor(runs, active, aborted, theme) {
+import { childElapsedMs, childStatus, outcomePhrase, rosterCounts, statusColor, statusMarkerCell, } from '../team-status.js';
+/**
+ * The card's aggregate colour.
+ *
+ * FAILURES DOMINATE, THEN A CANCELLATION, THEN A DISPATCH THAT NEVER SETTLED.
+ * The old version asked `runs.some((r) => !isOk(r))`, so an entry whose children
+ * were still working - and one the user had cancelled - was painted `toolError`
+ * (A-1 / E8). `RosterCounts` is passed IN rather than recomputed, so this colour
+ * and the headline cannot disagree inside one card.
+ */
+export function teamCardColor(counts, active, aborted, theme) {
     if (active)
         return theme.toolRunning;
-    if (aborted || runs.some((r) => !isOk(r)))
+    if (counts.failed > 0)
         return theme.toolError;
+    if (aborted || counts.aborted > 0 || counts.queued > 0 || counts.running > 0) {
+        return theme.noticeWarn;
+    }
     return theme.toolDone;
 }
+/** `nowSec` is seconds (`App`'s 1 Hz clock); a card measures in milliseconds. */
+function liveClockMs(nowSec) {
+    return nowSec === undefined ? Date.now() : nowSec * 1000;
+}
+/**
+ * The elapsed column for one child: a MEASUREMENT, or an empty cell.
+ *
+ * `liveNow` is defined only while the dispatch is live, and that distinction is the
+ * whole point. A child restored by `/resume` keeps its `startedAt` and has no
+ * `endedAt` - `session/persist.ts` settles the ENTRY, it does not invent an end time
+ * for the run - so a figure computed against `Date.now()` would claim hours of work
+ * that never happened, next to an `interrupted (session resumed)` headline that says
+ * the opposite. An unmeasurable duration is left blank instead.
+ */
+function elapsedCell(run, liveNow) {
+    const end = run.endedAt ?? liveNow;
+    if (run.startedAt === undefined || end === undefined)
+        return '';
+    return formatDuration(childElapsedMs(run, end));
+}
 function TeamCardImpl(props) {
     const { requested, runs, aborted, durationMs, active, expanded, reducedMotion, theme, caps } = props;
     const glyphs = pickGlyphs(caps);
-    const color = teamCardColor(runs, active, aborted, theme);
-    const ok = runs.filter(isOk).length;
-    const failed = runs.length - ok;
+    // ONE COUNTING AUTHORITY (A-1): `ok`/`failed` used to be `isOk(...)` and
+    // `runs.length - ok`, which counted a cancelled child - and a still-working one -
+    // as a failed one (E3 / E8).
+    const counts = rosterCounts(runs);
+    const color = teamCardColor(counts, active, aborted, theme);
+    // A CLOCK ONLY WHILE THE DISPATCH IS LIVE: a settled card has nothing left to time,
+    // and a clock in the settled path is how a resumed dispatch came to read like a run
+    // that is still going (`elapsedCell`).
+    const liveNow = active ? liveClockMs(props.nowSec) : undefined;
     // A dispatch entry restored from `/resume` is settled and aborted but has no
     // duration: nothing measured it, because the process it belonged to is gone.
     // Saying so plainly beats rendering `0.0s (0 ok, 3 failed)`, which reads like
     // a dispatch that ran and lost (§5.3 / P1-5).
     const interrupted = !active && aborted && durationMs === undefined;
-    const settled = runs.filter((r) => r.phase === 'done' || r.phase === 'failed' || r.phase === 'aborted').length;
     const headline = interrupted
         ? 'interrupted (session resumed)'
         : active
-            ? `${runs.length - settled} running`
-            : `${formatDuration(durationMs ?? 0)}  (${ok} ok, ${failed} failed)`;
+            ? `${counts.queued + counts.running} running`
+            : `${formatDuration(durationMs ?? 0)}  (${outcomePhrase(counts)})`;
     const count = `${runs.length} ${runs.length === 1 ? 'subagent' : 'subagents'}`;
     const dropped = requested > runs.length ? `  (${runs.length} of ${requested} requested)` : '';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "team" }), _jsxs(Text, { color: theme.muted, children: [' ', count, dropped, '  '] }), active && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " ", headline] })) : (_jsxs(Text, { color: color, children: [active ? `${glyphs.spinnerStill} ` : '', headline] }))] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [runs.map((run) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: isOk(run) ? theme.toolDone : theme.toolError, children: isOk(run) ? glyphs.toolDone : glyphs.toolError }), _jsxs(Text, { color: theme.primary, children: [' ', run.label.padEnd(8).slice(0, 8)] }), _jsxs(Text, { color: theme.muted, children: [' ', run.description, '  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? 0) - run.startedAt)) : '', `  ${run.turns} turns`, run.filesTouched.length > 0 ? `  ${run.filesTouched.length} files` : '', run.error ? `  ${run.error}` : ''] }), run.retry && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', "retry ", run.retry.attempt, "/", run.retry.maxRetries] }))] }, run.label))), expanded &&
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "team" }), _jsxs(Text, { color: theme.muted, children: [' ', count, dropped, '  '] }), active && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " ", headline] })) : (_jsxs(Text, { color: color, children: [active ? `${glyphs.spinnerStill} ` : '', headline] }))] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [runs.map((run) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: statusColor(childStatus(run), theme), children: statusMarkerCell(childStatus(run), glyphs) }), _jsxs(Text, { color: theme.primary, children: [' ', run.label.padEnd(8).slice(0, 8)] }), _jsxs(Text, { color: theme.muted, children: [' ', run.description, '  ', elapsedCell(run, liveNow), `  ${run.turns} turns`, run.filesTouched.length > 0 ? `  ${run.filesTouched.length} files` : '', run.error ? `  ${run.error}` : ''] }), run.retry && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', "retry ", run.retry.attempt, "/", run.retry.maxRetries] }))] }, run.label))), expanded &&
                         runs.map((run) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: theme.accent, children: [run.label, " ", glyphs.midDot, " ", run.description] }), _jsx(Text, { color: theme.muted, children: run.summary ?? '(no summary)' })] }, `s-${run.label}`))), !expanded && !active && runs.length > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", runs.length, " ", runs.length === 1 ? 'summary' : 'summaries', " (Ctrl+O)"] })), expanded && _jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" })] })] }));
 }
 /**

package/dist/ui/entries/TodoCard.d.ts

@@ -1,25 +1,39 @@
 /**
- * TodoCard — the transcript checklist entry (todo-plan-execution §6.2).
+ * TodoCard — the transcript checklist entry (todo-plan-execution §6.2;
+ * todo-acceptance-criteria §6.10).
  *
  * ASCII ONLY: every glyph comes from `pickGlyphs`.
  *
- * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is
- * the HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It
- * renders through the shared `EntryFrame` supplied by `EntryView`, so a plan
- * reads as one more step in the transcript rather than a second kind of object.
+ * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is the
+ * HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It renders
+ * through the shared `EntryFrame` supplied by `EntryView`, so a plan reads as one
+ * more step in the transcript rather than a second kind of object.
  *
  * THE FULL LIST, NO WINDOWING (the transcript scrolls; the rail does not), and
- * NEVER ANIMATED even while `live` — a resumed session would otherwise spin
- * forever on a card whose run ended days ago.
+ * NEVER ANIMATED even while `live` — a resumed session would otherwise spin forever
+ * on a card whose run ended days ago.
+ *
+ * THE ACCEPTANCE BLOCK ADDS ROWS, NOT A CARD (§6.10): same frame, same marker
+ * column, one block underneath. Only a FAILED criterion gets an evidence line
+ * (D-14), which is what keeps the height exactly `1 + items.length + failedCount`.
  */
 import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
-import type { TodoItem } from '../../todo/types.js';
+import type { AcceptanceSnapshot, TodoItem } from '../../todo/types.js';
 export interface TodoCardProps {
     items: TodoItem[];
     doneCount: number;
     total: number;
+    /**
+     * The acceptance projection (todo-acceptance-criteria §6.10).
+     *
+     * OPTIONAL, unlike `TodoSnapshot.acceptance` (P1-4): a `TodoSnapshot` has exactly
+     * one writer and can fail closed, while this entry's sources include transcript
+     * entries read back from a session file written before the feature existed. A
+     * required field there would be typed "present" and be `undefined` at runtime.
+     */
+    acceptance?: AcceptanceSnapshot | null;
     live: boolean;
     /** Saved mid-run and resumed: the run behind this card died with the process. */
     interrupted?: boolean;
@@ -31,9 +45,10 @@ export declare function todoCardColor(doneCount: number, total: number, live: bo
 declare function TodoCardImpl(props: TodoCardProps): React.ReactElement;
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
- * `mapEntry` already preserves object identity for untouched entries, so the
- * array props below are stable references on a settled card, and `theme` /
- * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ * `mapEntry` already preserves object identity for untouched entries, so the array
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1). `acceptance` is a NEW object whenever a verdict
+ * lands and the SAME reference otherwise, which is exactly what the comparator wants.
  */
 export declare const TodoCard: React.MemoExoticComponent<typeof TodoCardImpl>;
 export {};

package/dist/ui/entries/TodoCard.js

@@ -1,22 +1,28 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * TodoCard — the transcript checklist entry (todo-plan-execution §6.2).
+ * TodoCard — the transcript checklist entry (todo-plan-execution §6.2;
+ * todo-acceptance-criteria §6.10).
  *
  * ASCII ONLY: every glyph comes from `pickGlyphs`.
  *
- * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is
- * the HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It
- * renders through the shared `EntryFrame` supplied by `EntryView`, so a plan
- * reads as one more step in the transcript rather than a second kind of object.
+ * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is the
+ * HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It renders
+ * through the shared `EntryFrame` supplied by `EntryView`, so a plan reads as one
+ * more step in the transcript rather than a second kind of object.
  *
  * THE FULL LIST, NO WINDOWING (the transcript scrolls; the rail does not), and
- * NEVER ANIMATED even while `live` — a resumed session would otherwise spin
- * forever on a card whose run ended days ago.
+ * NEVER ANIMATED even while `live` — a resumed session would otherwise spin forever
+ * on a card whose run ended days ago.
+ *
+ * THE ACCEPTANCE BLOCK ADDS ROWS, NOT A CARD (§6.10): same frame, same marker
+ * column, one block underneath. Only a FAILED criterion gets an evidence line
+ * (D-14), which is what keeps the height exactly `1 + items.length + failedCount`.
  */
 import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
+import { derivePlanPhase } from '../../todo/acceptance.js';
 /** The card's aggregate colour: complete is done, anything else is in flight. */
 export function todoCardColor(doneCount, total, live, theme) {
     if (live)
@@ -39,19 +45,54 @@ function rowColor(item, theme) {
         return theme.primary;
     return theme.hintFg ?? theme.muted;
 }
+/** `passed` reuses the done glyph; `failed` is the one new meaning (D-9). */
+function acceptanceMarker(item, glyphs) {
+    if (item.status === 'passed')
+        return glyphs.todoDone;
+    if (item.status === 'failed')
+        return glyphs.todoFail;
+    if (item.status === 'in_progress')
+        return glyphs.todoActive;
+    return glyphs.todoPending;
+}
+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;
+}
+/**
+ * All passed reads as done, any failure as an error, otherwise muted; while the run
+ * is live and the plan is in VERIFY it reads as running - the same expression family
+ * `todoCardColor` uses one level up.
+ */
+function acceptanceTitleColor(acceptance, items, live, theme) {
+    if (acceptance.failedCount > 0)
+        return theme.toolError;
+    if (live && derivePlanPhase(items, acceptance.items) === 'verify')
+        return theme.toolRunning;
+    if (acceptance.total > 0 && acceptance.checkedCount === acceptance.total)
+        return theme.toolDone;
+    return theme.muted;
+}
 function TodoCardImpl(props) {
-    const { items, doneCount, total, live, interrupted, theme, caps } = props;
+    const { items, doneCount, total, acceptance, live, interrupted, theme, caps } = props;
     const glyphs = pickGlyphs(caps);
+    const criteria = acceptance && acceptance.total > 0 ? acceptance : null;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "Todos" }), _jsxs(Text, { color: todoCardColor(doneCount, total, live, theme), children: ['  ', doneCount, "/", total] }), interrupted && (
-                    // A resumed `2/7` would otherwise read as a run still in flight
-                    // (P2-6). Saying so plainly is the same fix `TeamCard` makes for a
-                    // dispatch that never got a duration.
-                    _jsxs(Text, { color: theme.muted, children: ['  ', "interrupted (session resumed)"] }))] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: items.map((item, index) => (_jsxs(Text, { wrap: "truncate", color: rowColor(item, theme), children: [marker(item, glyphs).padEnd(3), item.status === 'in_progress' ? item.activeForm : item.content] }, `${index}-${item.content}`))) })] }));
+                    // A resumed `2/7` would otherwise read as a run still in flight (P2-6).
+                    // Saying so plainly is the same fix `TeamCard` makes for a dispatch that
+                    // never got a duration.
+                    _jsxs(Text, { color: theme.muted, children: ['  ', "interrupted (session resumed)"] }))] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: items.map((item, index) => (_jsxs(Text, { wrap: "truncate", color: rowColor(item, theme), children: [marker(item, glyphs).padEnd(3), item.status === 'in_progress' ? item.activeForm : item.content] }, `${index}-${item.content}`))) }), criteria && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.accent, bold: true, children: "Acceptance" }), _jsxs(Text, { color: acceptanceTitleColor(criteria, items, live, theme), children: ['  ', criteria.checkedCount, "/", criteria.total, " checked", criteria.failedCount > 0 ? `  !${criteria.failedCount} failed` : ''] })] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: criteria.items.map((item, index) => (_jsxs(React.Fragment, { children: [_jsxs(Text, { wrap: "truncate", color: acceptanceRowColor(item, theme), children: [acceptanceMarker(item, glyphs).padEnd(3), item.content] }), item.status === 'failed' && item.evidence.length > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['      ', item.evidence] }))] }, `acc-${index}-${item.content}`))) })] }))] }));
 }
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
- * `mapEntry` already preserves object identity for untouched entries, so the
- * array props below are stable references on a settled card, and `theme` /
- * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ * `mapEntry` already preserves object identity for untouched entries, so the array
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1). `acceptance` is a NEW object whenever a verdict
+ * lands and the SAME reference otherwise, which is exactly what the comparator wants.
  */
 export const TodoCard = React.memo(TodoCardImpl);

package/dist/ui/glyphs.d.ts

@@ -86,6 +86,15 @@ export interface Glyphs {
     scrollThumb: string;
     /** Redaction dot for `maskSecret` in the settings screen (§4.1 tier B). */
     maskDot: string;
+    /**
+     * The Agents board's selection cursor (tui-subagent-panel D-14).
+     *
+     * BYTE-IDENTICAL to `todoActive`, and still a field of its own: the two carry
+     * different meanings - "the item the run is on" versus "the child this panel is
+     * showing" - and reusing the todo glyph would restyle the board the day someone
+     * redraws the TODO rail. `scrollTrack` / `scrollThumb` above are the same precedent.
+     */
+    cursor: string;
     /**
      * Team mode (team-subagents §6.1). The rail marker for a dispatch card and
      * the prefix on the panel's incoming-message preview.
@@ -108,6 +117,16 @@ export interface Glyphs {
     todoPending: string;
     todoActive: string;
     todoDone: string;
+    /**
+     * The ONLY glyph this feature adds (todo-acceptance-criteria D-9): `passed` is a
+     * settled positive and reuses `todoDone`, while `failed` is a genuinely new
+     * meaning.
+     *
+     * The ASCII tier must still tell "done" from "failed", so `[!]` joins `[x]` - the
+     * same three columns, which is what keeps the mixed-width list aligned with no
+     * per-tier branch.
+     */
+    todoFail: string;
     /**
      * API retry (llm-api-retry-backoff §6.5). The rail marker on the retry card.
      *

package/dist/ui/glyphs.js

@@ -60,12 +60,14 @@ const UNICODE_GLYPHS = {
     scrollTrack: '│',
     scrollThumb: '█',
     maskDot: '•',
+    cursor: '▸',
     boxStyle: 'round',
     teamAgent: '◆',
     teamMail: '⇄',
     todoPending: '○',
     todoActive: '▸',
     todoDone: '✓',
+    todoFail: '✗',
     retry: '↻',
     compaction: '⤓',
     queued: '◷',
@@ -124,12 +126,14 @@ const ASCII_GLYPHS = {
     scrollTrack: '|',
     scrollThumb: '#',
     maskDot: '*',
+    cursor: '>',
     boxStyle: 'classic',
     teamAgent: '*',
     teamMail: '@',
     todoPending: '[ ]',
     todoActive: '>',
     todoDone: '[x]',
+    todoFail: '[!]',
     retry: '[r]',
     compaction: '[c]',
     queued: '*',

package/dist/ui/layout/agents-board.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The Agents board's row model — pure projection, no Ink (tui-subagent-panel §4.4 / §7).
+ *
+ * WHY A PURE MODULE AND NOT JSX. The board's whole value is that it shows EVERY fact
+ * about every child, and the two things that can go wrong with that are both
+ * properties of a list: a row wider than the overlay (which silently desynchronises
+ * `OverlayFrame`'s position indicator) and a row count that grows without a bound.
+ * Both are assertable here, against plain strings, without a terminal - which is the
+ * same reason `layout/team-panel.ts` and `layout/budget.ts` are separate modules.
+ *
+ * LIVE-ONLY RULE (§4.4.2, RV-P0-2). The board has two sources with DIFFERENT fields:
+ * a live `TeamSnapshot` (has `messageCount`, `startedAt`, the activity prose and the
+ * timeline) and a settled `kind: 'team'` entry (has `durationMs` and the runs, and
+ * nothing else - `agent/reducer.ts`'s entry member carries no `messageCount` and no
+ * `startedAt`). A section whose source is missing is OMITTED, never filled with a
+ * zero: `mail 0` would be a lie, and an empty section title tells the reader nothing.
+ * The one section that survives both sources is `result` (`summary` / `error` is
+ * never stripped), which is precisely the fact a user opens the board to find.
+ *
+ * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts`'s static scan, so every symbol
+ * (the ellipsis, the separator, the cursor) arrives through `glyphs`.
+ */
+import type { Entry } from '../../agent/reducer.js';
+import type { SubagentRun, TeamSnapshot } from '../../team/types.js';
+import type { Glyphs } from '../glyphs.js';
+export type BoardRowKind = 'summary' | 'blank' | 'section' | 'child' | 'field' | 'event' | 'hint';
+/** Which palette slot a row draws with. Mapped to `Theme` one level up, in the component. */
+export type BoardTone = 'accent' | 'primary' | 'muted' | 'warn' | 'error' | 'done' | 'hint';
+export interface BoardRow {
+    /** React key: stable and unique (`kind:subject:index`). */
+    key: string;
+    kind: BoardRowKind;
+    /** One already-folded line, safe to hand to `<Text wrap="truncate">`. */
+    text: string;
+    tone: BoardTone;
+    selected?: boolean;
+}
+export interface BoardSource {
+    dispatchId: string;
+    active: boolean;
+    /**
+     * When the dispatch started. **A settled `team` entry has no such field**
+     * (`agent/reducer.ts`'s entry member), so it is optional: with no `startedAt` the
+     * summary shows `durationMs` alone rather than inventing an absolute instant.
+     */
+    startedAt?: number;
+    endedAt?: number;
+    requested: number;
+    runs: readonly SubagentRun[];
+    /**
+     * Team-mail count. Live snapshots carry it; a settled entry does **not** - absent
+     * means the clause is omitted rather than rendered as `mail 0` (RV-P0-2).
+     */
+    messageCount?: number;
+    /** A settled entry's own total (`teamEnd` writes it). */
+    durationMs?: number;
+}
+/**
+ * The board's single source shape, resolved in ONE place.
+ *
+ * PRIORITY: live snapshot > (the component's frozen copy) > the most recent settled
+ * entry. This function answers the first and the third; the frozen copy belongs to
+ * the component because it only exists while a dispatch is being read (§4.4.5).
+ */
+export declare function resolveBoardSource(input: {
+    team: TeamSnapshot | null;
+    entries: readonly Entry[];
+}): BoardSource | null;
+/**
+ * The child the board is showing, resolved from its LABEL every frame (D-8).
+ *
+ * Labels are the only stable handle: `panel-rows.ts` re-sorts the roster by phase, so
+ * an index would silently jump to a different child the moment one of them settles.
+ * Fallback order is "the first running child, else the first child", which is the
+ * one a reader opening the board mid-dispatch wants.
+ */
+export declare function resolveSelection(runs: readonly SubagentRun[], label: string | null): SubagentRun | null;
+export interface AgentBoardInput {
+    source: BoardSource;
+    /** Overlay content width. */
+    cols: number;
+    now: number;
+    selectedLabel: string | null;
+    glyphs: Glyphs;
+    native: boolean;
+}
+/**
+ * The board's rows, in the order a reader wants them: what the dispatch did, then who
+ * is in it, then everything about the selected child, then its history.
+ *
+ * Bounded by `TEAM_LIMITS.boardMaxRows`, and the truncation is ANNOUNCED rather than
+ * silent - a list that stops mid-fact with no notice reads as a rendering bug.
+ */
+export declare function buildAgentBoardRows(input: AgentBoardInput): BoardRow[];
+/**
+ * The facts, in a FIXED order, and with the zero-valued ones ABSENT.
+ *
+ * `supervisor` / `retries` / `compactions` / `truncated` only appear when they carry a
+ * fact; a row reading `supervisor  0` teaches a reader nothing and pushes the section
+ * a row down for every child that was never touched.
+ */
+export declare function factPairs(run: SubagentRun, glyphs: Glyphs): [string, string][];