@aragon-agent/cli 0.6.35 → 0.6.36

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

@@ -119,7 +119,7 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
             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

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/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: '*',