@aragon-agent/cli 0.6.35 → 0.6.37

package/dist/agent/agent-mode.d.ts

@@ -41,17 +41,33 @@ export declare function nextMode(current: AgentMode): AgentMode;
  * PowerShell, a foreign process resetting the mode), so a rung that depends on
  * NOTHING has to exist underneath it.
  *
- * `ctrl+p` IS MEASURED, not guessed. On the lossy path it arrives as `0x10`,
+ * `ctrl+n` IS MEASURED, not guessed. On the lossy path it arrives as `0x0e`,
  * because Windows generates a real control character for `Ctrl+<letter>` and
  * libuv's character branch forwards it untouched; `Alt+M` produces no bytes at
  * all and `Ctrl+Tab` collapses exactly like `Shift+Tab` (analysis section 3.6).
  * Any idle `Ctrl+<letter>` in the `0x01-0x1A` range would work; this one is free
- * throughout the package - `keymap.ts` claims a/e/w/u/k, `App` claims c/l/t/o,
+ * throughout the package - `keymap.ts` claims a/e/w/u/k, `App` claims c/g/k/l/o/r/t,
  * and `PromptInput` returns early on every `key.ctrl` - so binding it takes no
  * behaviour away from anyone. `Ctrl+B` survives the same path but is tmux's
  * default prefix, and this binding is unconditional and cross-platform, so it
  * would be silently dead for a whole class of macOS and Linux users.
  *
+ * THIS KEY MOVED FROM `ctrl+p`, WHICH NOW OPENS THE PROMPT LIBRARY
+ * (quick-prompt-library D-1). The requirement names `ctrl+p` as the first entry
+ * to a feature users will build muscle memory for, and a key that is sometimes
+ * the prompt library and sometimes the mode switch is a key nobody can learn.
+ * `ctrl+n` was the only idle C0 byte left that survives the same lossy path, and
+ * it carries no conflicting behaviour: readline's `next-history` is `Up`/`Down`
+ * in this product.
+ *
+ * `^N` IS NOT AN ACCEPTABLE SPELLING OF IT, ANYWHERE. `^N` is already this
+ * product's word for TRANSCRIPT LINE OFFSET - the header's scroll chip reads
+ * `^<n>` and the help overlay has a `^N` row about the distance from the bottom -
+ * while every other `^X` in the same row is a key. Writing the mode fallback as
+ * `^N` would put two meanings of `^` on one line, so the header, the help
+ * overlay, `doctor`, the README and the one-shot migration notice all spell out
+ * `Ctrl+N`.
+ *
  * BOUND UNCONDITIONALLY, on every platform. A binding that only exists where it
  * is needed cannot be documented in one place, cannot be taught by muscle
  * memory, and is missing on precisely the machine whose capability probe was
@@ -59,13 +75,13 @@ export declare function nextMode(current: AgentMode): AgentMode;
  *
  * THESE ARE THE LABELS, NOT THE BINDING. Editing a value here changes only what
  * the user is TOLD to press - the hint row, the startup notice, `doctor`. The
- * key that is actually listened for is `input === 'p'` in `App`'s `useInput`,
+ * key that is actually listened for is `input === 'n'` in `App`'s `useInput`,
  * and the help overlay and README spell both keys out in their own title case.
  * Change one without the others and the product advertises a key it ignores.
  */
 export declare const MODE_TOGGLE_KEYS: {
     readonly primary: "shift+tab";
-    readonly fallback: "ctrl+p";
+    readonly fallback: "ctrl+n";
 };
 /** The two tools that only exist because a human is attached. */
 export declare const PLAN_TOOL_NAMES: readonly ["ask_user", "submit_plan"];

package/dist/agent/agent-mode.js

@@ -43,17 +43,33 @@ export function nextMode(current) {
  * PowerShell, a foreign process resetting the mode), so a rung that depends on
  * NOTHING has to exist underneath it.
  *
- * `ctrl+p` IS MEASURED, not guessed. On the lossy path it arrives as `0x10`,
+ * `ctrl+n` IS MEASURED, not guessed. On the lossy path it arrives as `0x0e`,
  * because Windows generates a real control character for `Ctrl+<letter>` and
  * libuv's character branch forwards it untouched; `Alt+M` produces no bytes at
  * all and `Ctrl+Tab` collapses exactly like `Shift+Tab` (analysis section 3.6).
  * Any idle `Ctrl+<letter>` in the `0x01-0x1A` range would work; this one is free
- * throughout the package - `keymap.ts` claims a/e/w/u/k, `App` claims c/l/t/o,
+ * throughout the package - `keymap.ts` claims a/e/w/u/k, `App` claims c/g/k/l/o/r/t,
  * and `PromptInput` returns early on every `key.ctrl` - so binding it takes no
  * behaviour away from anyone. `Ctrl+B` survives the same path but is tmux's
  * default prefix, and this binding is unconditional and cross-platform, so it
  * would be silently dead for a whole class of macOS and Linux users.
  *
+ * THIS KEY MOVED FROM `ctrl+p`, WHICH NOW OPENS THE PROMPT LIBRARY
+ * (quick-prompt-library D-1). The requirement names `ctrl+p` as the first entry
+ * to a feature users will build muscle memory for, and a key that is sometimes
+ * the prompt library and sometimes the mode switch is a key nobody can learn.
+ * `ctrl+n` was the only idle C0 byte left that survives the same lossy path, and
+ * it carries no conflicting behaviour: readline's `next-history` is `Up`/`Down`
+ * in this product.
+ *
+ * `^N` IS NOT AN ACCEPTABLE SPELLING OF IT, ANYWHERE. `^N` is already this
+ * product's word for TRANSCRIPT LINE OFFSET - the header's scroll chip reads
+ * `^<n>` and the help overlay has a `^N` row about the distance from the bottom -
+ * while every other `^X` in the same row is a key. Writing the mode fallback as
+ * `^N` would put two meanings of `^` on one line, so the header, the help
+ * overlay, `doctor`, the README and the one-shot migration notice all spell out
+ * `Ctrl+N`.
+ *
  * BOUND UNCONDITIONALLY, on every platform. A binding that only exists where it
  * is needed cannot be documented in one place, cannot be taught by muscle
  * memory, and is missing on precisely the machine whose capability probe was
@@ -61,11 +77,11 @@ export function nextMode(current) {
  *
  * THESE ARE THE LABELS, NOT THE BINDING. Editing a value here changes only what
  * the user is TOLD to press - the hint row, the startup notice, `doctor`. The
- * key that is actually listened for is `input === 'p'` in `App`'s `useInput`,
+ * key that is actually listened for is `input === 'n'` in `App`'s `useInput`,
  * and the help overlay and README spell both keys out in their own title case.
  * Change one without the others and the product advertises a key it ignores.
  */
-export const MODE_TOGGLE_KEYS = { primary: 'shift+tab', fallback: 'ctrl+p' };
+export const MODE_TOGGLE_KEYS = { primary: 'shift+tab', fallback: 'ctrl+n' };
 /** The two tools that only exist because a human is attached. */
 export const PLAN_TOOL_NAMES = ['ask_user', 'submit_plan'];
 /**

package/dist/agent/controller.d.ts

@@ -30,7 +30,7 @@ import { type FastStatus } from '../fast/wiring.js';
 import type { FastEventListener, FastSnapshot } from '../fast/types.js';
 import { ContextMeter, type ContextUsageListener } from '../compaction/meter.js';
 import type { CompactionEventListener, CompactionSnapshot, ContextUsageSnapshot } from '../compaction/types.js';
-import type { TodoEventListener, TodoSnapshot } from '../todo/types.js';
+import type { AcceptanceItem, TodoEventListener, TodoSnapshot } from '../todo/types.js';
 import { type HumanInputGate } from '../tools/human-input.js';
 import { SkillService, type ApprovalGate } from '../skills/service.js';
 import { type ConversationResetOptions, type ConversationResetResult } from './conversation-reset.js';
@@ -587,6 +587,37 @@ export declare class AgentController {
      */
     setTodoConfig(patch: Partial<TodoConfig>): TodoConfig;
     getTodoSnapshot(): TodoSnapshot | null;
+    /**
+     * Whether the acceptance table is live for this session: the config key AND the
+     * session switch. Two flags, exactly as `isTodoEnabled` needs `isTodoRegistered`
+     * first - a capability that is on while `todo_write` refuses is not a
+     * capability.
+     */
+    isTodoAcceptanceEnabled(): boolean;
+    /**
+     * Flip the acceptance capability and RE-RENDER THE PROMPT, byte for byte the
+     * contract `setTodoEnabled` records above: the paragraph is part of
+     * `<todo_planning>`, and the tool reads the same live value through its
+     * `hasAcceptance` closure (D-11).
+     */
+    setTodoAcceptanceEnabled(enabled: boolean): void;
+    /**
+     * The acceptance table as DATA, independent of whether it is being drawn.
+     *
+     * The persistence surfaces must use this and not `getTodoSnapshot()?.acceptance`:
+     * the projection is `null` whenever the capability is off, and a checkpoint or a
+     * `/save` that silently dropped the user's verdicts because a display switch was
+     * off would be a data loss dressed as a setting.
+     */
+    getAcceptanceItems(): AcceptanceItem[];
+    /**
+     * `/todo acceptance reset`: every verdict back to `pending`, evidence dropped.
+     *
+     * The count comes BACK from the store rather than being recomputed by the
+     * command, so the notice and the state cannot disagree about how many criteria
+     * moved.
+     */
+    reopenAcceptance(): number;
     /**
      * Subscribe to the CLI-local todo event stream.
      *
@@ -594,8 +625,12 @@ export declare class AgentController {
      * every caller can subscribe unconditionally.
      */
     subscribeTodos(listener: TodoEventListener): () => void;
-    /** `/resume`. An absent or empty list CLEARS — see `TodoStore.restore` (P0-2). */
-    restoreTodos(items: unknown): void;
+    /**
+     * `/resume`. An absent or empty todo list CLEARS both tables — see
+     * `TodoStore.restore` (P0-2). `acceptance` is optional so every existing caller
+     * keeps compiling, and an omitted table reads as "this file has none".
+     */
+    restoreTodos(items: unknown, acceptance?: unknown): void;
     /**
      * `/todo clear` and `/clear screen`. A user override of a projection (I-2's
      * standing exception). `/todo` refuses mid-run before it gets here;

package/dist/agent/controller.js

@@ -346,7 +346,9 @@ export class AgentController {
         this.todoRegistered = config.todo.enabled;
         this.todoEnabled = config.todo.enabled;
         this.todoPanelCapable = deps.todoPanelCapable === true;
-        this.todos = this.todoRegistered ? new TodoStore() : null;
+        this.todos = this.todoRegistered
+            ? new TodoStore(Date.now, () => this.isTodoAcceptanceEnabled())
+            : null;
         // --- Fast model tier ---------------------------------------------------
         //
         // RESOLVED BEFORE THE AGENT, because `fastRegistered` decides whether the
@@ -558,6 +560,12 @@ export class AgentController {
                         store: this.todos,
                         // Read LIVE: `/todo off` flips the flag, it cannot unregister.
                         isEnabled: () => this.todoEnabled,
+                        // LIVE for the same reason (D-11): `/todo acceptance off` must take
+                        // effect in a session already running, because the tool array
+                        // itself cannot change. THE SAME PREDICATE the store was given, on
+                        // purpose: two switches for one capability that could disagree is
+                        // the shape of a session that cannot exist (IF-7).
+                        hasAcceptance: () => this.isTodoAcceptanceEnabled(),
                     }),
                 ]
                 : [],
@@ -912,6 +920,9 @@ export class AgentController {
             todoBlock: this.todoRegistered && this.todoEnabled
                 ? buildTodoBlock({
                     panelVisible: this.todoPanelCapable && config.todo.panel,
+                    // LIVE, never snapshotted (D-11): the paragraph is part of the
+                    // block, and `/todo acceptance off` rebuilds the prompt.
+                    acceptance: config.todo.acceptance,
                 })
                 : '',
             // The SAME two flags one more time, plus the live resolution — all three
@@ -1594,6 +1605,51 @@ export class AgentController {
     getTodoSnapshot() {
         return this.todos?.snapshot() ?? null;
     }
+    /**
+     * Whether the acceptance table is live for this session: the config key AND the
+     * session switch. Two flags, exactly as `isTodoEnabled` needs `isTodoRegistered`
+     * first - a capability that is on while `todo_write` refuses is not a
+     * capability.
+     */
+    isTodoAcceptanceEnabled() {
+        return this.config.todo.acceptance && this.todoEnabled;
+    }
+    /**
+     * Flip the acceptance capability and RE-RENDER THE PROMPT, byte for byte the
+     * contract `setTodoEnabled` records above: the paragraph is part of
+     * `<todo_planning>`, and the tool reads the same live value through its
+     * `hasAcceptance` closure (D-11).
+     */
+    setTodoAcceptanceEnabled(enabled) {
+        this.setTodoConfig({ acceptance: enabled });
+        // THE RAIL READS THE PROJECTION, NOT THE FLAG, so the flip has to re-project or
+        // `/todo acceptance off` would leave the second section on screen until the
+        // model's next write (P0-2's complaint, one path further in). The verdicts
+        // themselves are kept: `getAcceptanceItems()` still returns them for `/save`,
+        // the checkpoint and `exec`.
+        this.todos?.refreshAcceptanceProjection();
+    }
+    /**
+     * The acceptance table as DATA, independent of whether it is being drawn.
+     *
+     * The persistence surfaces must use this and not `getTodoSnapshot()?.acceptance`:
+     * the projection is `null` whenever the capability is off, and a checkpoint or a
+     * `/save` that silently dropped the user's verdicts because a display switch was
+     * off would be a data loss dressed as a setting.
+     */
+    getAcceptanceItems() {
+        return this.todos?.acceptanceItems() ?? [];
+    }
+    /**
+     * `/todo acceptance reset`: every verdict back to `pending`, evidence dropped.
+     *
+     * The count comes BACK from the store rather than being recomputed by the
+     * command, so the notice and the state cannot disagree about how many criteria
+     * moved.
+     */
+    reopenAcceptance() {
+        return this.todos?.reopenAll() ?? 0;
+    }
     /**
      * Subscribe to the CLI-local todo event stream.
      *
@@ -1605,9 +1661,13 @@ export class AgentController {
             return () => { };
         return this.todos.subscribe(listener);
     }
-    /** `/resume`. An absent or empty list CLEARS — see `TodoStore.restore` (P0-2). */
-    restoreTodos(items) {
-        this.todos?.restore(items);
+    /**
+     * `/resume`. An absent or empty todo list CLEARS both tables — see
+     * `TodoStore.restore` (P0-2). `acceptance` is optional so every existing caller
+     * keeps compiling, and an omitted table reads as "this file has none".
+     */
+    restoreTodos(items, acceptance = undefined) {
+        this.todos?.restore(items, acceptance);
     }
     /**
      * `/todo clear` and `/clear screen`. A user override of a projection (I-2's

package/dist/agent/headless.js

@@ -6,6 +6,7 @@
  */
 import { formatCost, formatTokens, formatDuration, computeCost } from './usage.js';
 import { formatStreamError } from './reducer.js';
+import { derivePlanPhase } from '../todo/acceptance.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 /** Run a single prompt headlessly and resolve with the process exit code. */
 export async function runHeadless(controller, prompt, options = {}) {
@@ -139,6 +140,11 @@ export async function runHeadless(controller, prompt, options = {}) {
     // stream that is already `--quiet`-able in full.
     let announcedTotal = 0;
     let lastActive = -1;
+    // THE ACCEPTANCE SECTION'S DEDUPE KEY (todo-acceptance-criteria §6.13.1 / P2-9).
+    // `phase` is DERIVED, never cached (I-3), so the key carries a freshly computed
+    // phase plus the two counters that can only move when a verdict lands: a
+    // constant-size string is cheaper than a field that could drift from the truth.
+    let lastAcceptance = '';
     const unsubscribeTodos = controller.subscribeTodos?.((event) => {
         if (quiet || event.type !== 'updated')
             return;
@@ -147,6 +153,20 @@ export async function runHeadless(controller, prompt, options = {}) {
             announcedTotal = total;
             err.write(`\n[todo] ${total} ${total === 1 ? 'step' : 'steps'} planned\n`);
             lastActive = -1;
+            // A NEW PLAN GETS ITS OWN FIRST `[accept]` LINE, for the reason `lastActive`
+            // is reset one line up: the key below is (phase, checked, failed) and two
+            // different plans can share all three. Without this reset the second plan's
+            // 0/3 in a `-p` run that already printed 0/3 would go unreported.
+            lastAcceptance = '';
+        }
+        const acceptance = event.snapshot.acceptance;
+        if (acceptance && acceptance.total > 0) {
+            const key = `${derivePlanPhase(items, acceptance.items)}|` +
+                `${acceptance.checkedCount}|${acceptance.failedCount}`;
+            if (key !== lastAcceptance) {
+                lastAcceptance = key;
+                err.write(`[accept] ${acceptanceLine(acceptance)}\n`);
+            }
         }
         if (activeIndex < 0) {
             if (lastActive !== -2) {
@@ -220,6 +240,17 @@ export async function runHeadless(controller, prompt, options = {}) {
                 `(${formatTokens(r.tailRelief.charsRemoved)} chars)\n`);
         }
     });
+    /**
+     * `[accept] <n>/<total> checked`, plus the failure count when there is one.
+     *
+     * ONE LINE PER TRANSITION, and the transitions are the ones a `-p` reader can
+     * act on: a verdict landed, or a criterion failed. `evidence` is NEVER printed
+     * (I-8): it belongs to the human-facing surfaces, and a machine log is not one.
+     */
+    function acceptanceLine(acceptance) {
+        const base = `${acceptance.checkedCount}/${acceptance.total} checked`;
+        return acceptance.failedCount > 0 ? `${base}, ${acceptance.failedCount} failed` : base;
+    }
     // --- The bounded continuation loop (todo-plan-followthrough §3.6). --------
     //
     // THE THREE `unsubscribe` CALLS STAY OUTSIDE IT (rule 4). The loop wraps the

package/dist/agent/reducer.d.ts

@@ -16,13 +16,13 @@ import type { AgentMode } from './agent-mode.js';
 import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
 import type { FastReview, FastSnapshot } from '../fast/types.js';
 import type { CompactionMode, CompactionRecord, CompactionSnapshot, CompactionUiTrigger, ContextUsageSnapshot } from '../compaction/types.js';
-import type { TodoItem, TodoSnapshot } from '../todo/types.js';
+import type { AcceptanceSnapshot, TodoItem, TodoSnapshot } from '../todo/types.js';
 import type { JobKind, ServiceSnapshot, ServiceStatus } from '../proc/types.js';
 import type { RetryPhase } from './retry-view.js';
 import type { FilePatch } from '../tools/patch.js';
 export type NoticeLevel = 'info' | 'warn' | 'error';
 export type ToastLevel = NoticeLevel | 'success';
-export type Overlay = null | 'settings' | 'model' | 'help' | 'queue' | 'confirm' | 'question' | 'plan' | 'kit';
+export type Overlay = null | 'settings' | 'model' | 'help' | 'queue' | 'confirm' | 'question' | 'plan' | 'kit' | 'prompts' | 'prompt-pick' | 'agents';
 export type ToolStatus = 'pending' | 'running' | 'done' | 'error';
 /** Ephemeral, auto-dismissed acknowledgement (spec §3.9). */
 export interface Toast {
@@ -147,6 +147,17 @@ export type Entry = {
     items: TodoItem[];
     doneCount: number;
     total: number;
+    /**
+     * The acceptance projection, copied from `TodoSnapshot.acceptance` on every
+     * `todoUpdate` (todo-acceptance-criteria §6.10).
+     *
+     * OPTIONAL, NOT `AcceptanceSnapshot | null` REQUIRED, and that asymmetry with
+     * the snapshot is deliberate (P1-4): `TodoSnapshot` has exactly one writer, so
+     * it can fail closed; an `Entry` does not - its sources include `entries` read
+     * back from a session file written before this feature existed, where the key
+     * is simply absent.
+     */
+    acceptance?: AcceptanceSnapshot | null;
     /** The turn that owns this card is still running, so it may be rewritten. */
     live: boolean;
     /**

package/dist/agent/reducer.js

@@ -1020,6 +1020,7 @@ export function viewReducer(state, action) {
                 items: action.snapshot.items,
                 doneCount: action.snapshot.doneCount,
                 total: action.snapshot.total,
+                acceptance: action.snapshot.acceptance,
                 live: true,
             });
             // Rewrite the turn's card when there is one; otherwise append and record

package/dist/cli.js

@@ -170,6 +170,10 @@ function toFlags(opts) {
         // C-9). A value flag is no less inert than a boolean one when this line is
         // missing.
         todoFollow: opts.todoFollow,
+        // Site three of three once more, for `--todo-acceptance`: a flag declared in
+        // commander and on `CliFlags` but missing HERE is inert, with no compile error
+        // and no runtime error (todo-acceptance-criteria §6.8.2).
+        todoAcceptance: opts.todoAcceptance,
         // Site three of three for `--retry` / `--retry-max` — five features, same
         // trap (`mouse` P1-2, `team` P1-4, `todo` C-9, render L4, now retry). A flag
         // needs the `.option()` declaration below, a field on `CliFlags`, AND a line
@@ -1319,6 +1323,9 @@ function createSessionWriter(input) {
         readView: input.readView,
         readHistory: () => controller.getSessionSnapshot(),
         readTodos: () => controller.getTodoSnapshot()?.items ?? [],
+        // The verdicts travel with the plan; read from the STORE, not from the render
+        // projection, so a checkpoint taken while the capability is off still saves them.
+        readAcceptance: () => controller.getAcceptanceItems(),
         // READ AT WRITE TIME: `/model` rebuilds the config, and a checkpoint that
         // recorded the model from launch would name the wrong one after a switch.
         readModel: () => {
@@ -2068,6 +2075,11 @@ function buildProgram() {
         // passed, so `!== undefined` in `resolveTodoConfig` already distinguishes it
         // from silence. An unrecognized mode is clamped to `notify`, not rejected.
         .option('--todo-follow <mode>', 'What to do when a run ends with unfinished steps: notify (default) | auto | off')
+        // A PAIR, and for the same reason `--todo-panel` needs one: `acceptance` is
+        // PERSISTED, so a lone `--no-todo-acceptance` would make commander default
+        // `opts.todoAcceptance` to `true` and overwrite a stored `false`.
+        .option('--todo-acceptance', 'Plan acceptance criteria with every todo list (the default)')
+        .option('--no-todo-acceptance', 'Plan steps only: no acceptance criteria, no verify phase')
         // BOTH FORMS, positive first, for the reason recorded five times above:
         // `retry.enabled` is PERSISTED, so a lone `--no-retry` would make commander
         // default `opts.retry` to `true` and silently overwrite a stored `false`.

package/dist/commands/agents-command.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `/agents` — open the subagent board (tui-subagent-panel §6.4).
+ *
+ * A SECOND DOOR, not a fallback. `Ctrl+B` is the fast path, but a key is undiscoverable
+ * unless the user reads `/help`, and `/agents` is what the palette advertises. Both
+ * entries share ONE guard (`state.team === null && lastTeamEntry(...) === null`) so the
+ * key and the command can never disagree about whether there is a board to show: an
+ * empty board would read as a broken feature, and the honest answer is a notice that
+ * says no dispatch has happened yet.
+ *
+ * The body lives in its own module for the reason `kit-command.ts` and
+ * `queue-command.ts` do: `builtins.ts` is already well past a thousand lines.
+ */
+import type { CommandRegistry } from './registry.js';
+export declare function registerAgentsCommand(registry: CommandRegistry): void;

package/dist/commands/agents-command.js

@@ -0,0 +1,27 @@
+/**
+ * `/agents` — open the subagent board (tui-subagent-panel §6.4).
+ *
+ * A SECOND DOOR, not a fallback. `Ctrl+B` is the fast path, but a key is undiscoverable
+ * unless the user reads `/help`, and `/agents` is what the palette advertises. Both
+ * entries share ONE guard (`state.team === null && lastTeamEntry(...) === null`) so the
+ * key and the command can never disagree about whether there is a board to show: an
+ * empty board would read as a broken feature, and the honest answer is a notice that
+ * says no dispatch has happened yet.
+ *
+ * The body lives in its own module for the reason `kit-command.ts` and
+ * `queue-command.ts` do: `builtins.ts` is already well past a thousand lines.
+ */
+import { lastTeamEntry } from '../ui/team-status.js';
+export function registerAgentsCommand(registry) {
+    registry.register({
+        name: 'agents',
+        description: 'Open the subagent board: every child, its facts and its timeline',
+        run: (ctx) => {
+            if (ctx.state.team === null && lastTeamEntry(ctx.state.entries) === null) {
+                ctx.notify('info', 'No subagent dispatch yet.');
+                return;
+            }
+            ctx.setOverlay('agents');
+        },
+    });
+}

package/dist/commands/builtins.js

@@ -14,6 +14,7 @@ import { computeCost, formatCost, formatDuration, formatTokens } from '../agent/
 import { mergePendingEntries } from '../agent/queued-messages.js';
 import { TODO_FOLLOW_LIMITS } from '../todo/limits.js';
 import { buildContinuationMessage } from '../todo/follow-through.js';
+import { planIsResolved } from '../todo/acceptance.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
 import { loadSession, resolveSessionPath, saveSession } from '../session/persist.js';
 import { applyRestoredSession } from '../session/startup-session.js';
@@ -23,7 +24,9 @@ import { getLogger } from '../logging/logger.js';
 import { resolveFastTier } from '../fast/resolve.js';
 import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
 import { registerQueueCommand } from './queue-command.js';
+import { registerPromptCommands } from '../prompts/command.js';
 import { registerKitCommand } from './kit-command.js';
+import { registerAgentsCommand } from './agents-command.js';
 import { perfCommand } from './perf.js';
 import { runCompactCommand } from '../compaction/command.js';
 import { runClearCommand } from './clear-command.js';
@@ -158,6 +161,102 @@ function runTeamModelCommand(ctx, subject) {
     ctx.persistConfig({ team: teamPatch });
     ctx.toast('success', `Subagent model: ${entry.name}${disambiguation} (${entry.provider}:${entry.model}).`);
 }
+/** Rows `/todo status` prints before it says how many it did not. */
+const ACCEPT_STATUS_ROWS = 8;
+/**
+ * `/todo acceptance on|off|reset`, and the bare form equal to `/todo status`'s
+ * acceptance section (todo-acceptance-criteria §6.14).
+ *
+ * EVERY MUTATING BRANCH IS "TWO CALLS PLUS PERSIST", the rule `/todo panel` and
+ * `/todo follow` already follow: `setTodoConfig` (or `setTodoAcceptanceEnabled`) is
+ * what the session sees, and `persistConfig` is what survives it. Only one of the two
+ * reports success while changing nothing.
+ */
+function runTodoAcceptance(ctx, value) {
+    const controller = ctx.controller;
+    if (!value || value === 'status') {
+        const lines = acceptanceStatusLines(controller.getTodoSnapshot()?.acceptance ?? null, controller.getTodoConfig().acceptance);
+        if (lines.length === 0) {
+            ctx.notify('info', 'No acceptance criteria. Todo planning: ' +
+                (controller.isTodoEnabled() ? 'on' : 'off') + '.');
+            return;
+        }
+        for (const line of lines)
+            ctx.notify('info', line);
+        return;
+    }
+    if (value === 'on' || value === 'off') {
+        const acceptance = value === 'on';
+        controller.setTodoAcceptanceEnabled(acceptance);
+        ctx.persistConfig({ todo: { acceptance } });
+        ctx.toast('success', `Acceptance criteria ${acceptance ? 'on' : 'off'}.`);
+        return;
+    }
+    if (value === 'reset') {
+        if (controller.isRunning()) {
+            ctx.notify('warn', 'Cannot reset the acceptance criteria while a run is in progress.');
+            return;
+        }
+        // THE COUNT COMES FROM THE STORE (a named writer, §6.2.3), never recomputed here,
+        // and `0` means the table was already fully unchecked - in which case a notice
+        // would announce that nothing happened.
+        const reopened = controller.reopenAcceptance();
+        if (reopened === 0) {
+            ctx.notify('info', 'No checked criteria to reset.');
+            return;
+        }
+        ctx.toast('info', `${reopened} ${reopened === 1 ? 'criterion is' : 'criteria are'} ` +
+            'unchecked again.');
+        return;
+    }
+    ctx.notify('warn', 'Usage: /todo acceptance [on|off|reset]');
+}
+/**
+ * The acceptance section of `/todo status`, as at most two notification bodies.
+ *
+ * RETURNS NOTHING WHEN THERE IS NOTHING TO SAY, which is what keeps the disabled
+ * path and the no-criteria path byte-identical to the pre-feature command (I-5).
+ * The list is bounded at eight rows by "unchecked and failed first, then the rest",
+ * with `... and N more` closing it: the full table lives in the transcript card, and
+ * a command that floods the transcript is not a status command.
+ */
+function acceptanceStatusLines(acceptance, enabled) {
+    if (!enabled || !acceptance || acceptance.total === 0)
+        return [];
+    const header = `Acceptance ${acceptance.checkedCount}/${acceptance.total} checked` +
+        (acceptance.failedCount > 0 ? ` (${acceptance.failedCount} failed)` : '');
+    const rows = acceptance.items
+        .map((item, index) => ({ item, index }))
+        .sort((left, right) => rank(left.item.status) - rank(right.item.status));
+    const shown = rows.slice(0, ACCEPT_STATUS_ROWS);
+    const lines = shown.map(({ item, index }) => `  ${String(index + 1).padStart(2)}. ${markerWord(item.status)} ${item.content}` +
+        (item.status === 'failed' && item.evidence.length > 0 ? `\n      ${item.evidence}` : ''));
+    if (rows.length > shown.length)
+        lines.push(`  ... and ${rows.length - shown.length} more`);
+    return [header, ...lines];
+}
+/**
+ * Failures first, then everything still open, then the settled verdicts: `/todo status`
+ * is read to find out what is WRONG, and the eight-row budget means the order decides
+ * what survives the cut.
+ */
+function rank(status) {
+    if (status === 'failed')
+        return 0;
+    if (status === 'in_progress' || status === 'pending')
+        return 1;
+    return 2;
+}
+/** ASCII markers: this module is inside the glyph scanner's scope. */
+function markerWord(status) {
+    if (status === 'passed')
+        return '[x]';
+    if (status === 'failed')
+        return '[!]';
+    if (status === 'in_progress')
+        return ' > ';
+    return '[ ]';
+}
 function formatFastStatus(controller) {
     const status = controller.getFastStatus();
     const cfg = controller.getFastConfig();
@@ -688,7 +787,8 @@ const COMMANDS = [
     },
     {
         name: 'todo',
-        description: 'Todo planning: status | on | off | panel on|off | follow <mode> | clear | continue',
+        description: 'Todo planning: status | on | off | panel on|off | follow <mode> | ' +
+            'acceptance [on|off|reset] | clear | continue',
         /**
          * `/todo on` CANNOT turn planning on in a session that started with
          * `--no-todo`, for the reason `/team on` above records at length: the tool
@@ -739,6 +839,16 @@ const COMMANDS = [
                     : '';
                 ctx.notify('info', `Todos: ${snapshot.doneCount}/${snapshot.total} done.${active} Panel: ${panel}. ` +
                     `Follow-through: ${follow}.`);
+                // THE ACCEPTANCE SECTION, appended and NOTHING ELSE (todo-acceptance-criteria
+                // §6.14): with no criteria the two calls above are byte-identical to the
+                // version without this feature.
+                for (const line of acceptanceStatusLines(snapshot.acceptance, todoCfg.acceptance)) {
+                    ctx.notify('info', line);
+                }
+                return;
+            }
+            if (verb === 'acceptance') {
+                runTodoAcceptance(ctx, value);
                 return;
             }
             if (verb === 'on' || verb === 'off') {
@@ -820,7 +930,10 @@ const COMMANDS = [
                     return;
                 }
                 const snapshot = controller.getTodoSnapshot();
-                if (!snapshot || snapshot.doneCount >= snapshot.total) {
+                // `planIsResolved`, NOT `doneCount >= total` (§6.14): in the verification
+                // phase every step is done and the command has to keep working, or the user's
+                // only manual route into the last stage is refused with "Nothing left".
+                if (!snapshot || planIsResolved(snapshot.items, snapshot.acceptance?.items ?? null)) {
                     ctx.notify('info', 'Nothing left to continue.');
                     return;
                 }
@@ -839,7 +952,8 @@ const COMMANDS = [
                 return;
             }
             ctx.notify('warn', `Unknown argument "${verb}" - use ` +
-                '/todo [status|on|off|panel on|off|follow <mode>|clear|continue].');
+                '/todo [status|on|off|panel on|off|follow <mode>|acceptance [on|off|reset]|' +
+                'clear|continue].');
         },
     },
     {
@@ -1017,6 +1131,11 @@ const COMMANDS = [
                     // `/resume` restores `messages`, so the belief that justifies the
                     // panel comes back — and the panel has to come back with it (§3.13).
                     todos: ctx.controller.getTodoSnapshot()?.items ?? [],
+                    // The verdicts travel with the plan, for the same reason: a resume that
+                    // restored the steps and dropped the conclusions would show a plan as
+                    // "not started" that the user had already watched being verified. Read
+                    // from the STORE, so a save taken while the capability is off keeps them.
+                    acceptance: ctx.controller.getAcceptanceItems(),
                 });
                 ctx.notify('info', `Saved session to ${path}`);
             }
@@ -1375,6 +1494,14 @@ export function registerBuiltinCommands(registry) {
     // The command BODY lives in its own module (builtins.ts is already 1.5k lines);
     // this line is the whole registration (agent-model-kits §4.9).
     registerKitCommand(registry);
+    // Same shape, one feature later (quick-prompt-library §4.3 / P1-3): the body is
+    // `prompts/command.ts` and its capabilities arrive on `CommandContext.prompts`.
+    // REGISTERED UNCONDITIONALLY, even with `prompts.enabled=false` - that is the only
+    // way the command can report that the feature is off (D-19 / AC-30).
+    registerPromptCommands(registry);
+    // The read-only subagent board (tui-subagent-panel §6.4). Same shape again: the
+    // body is `commands/agents-command.ts` and the registration is this one line.
+    registerAgentsCommand(registry);
 }
 /**
  * Every built-in command name INCLUDING aliases (`quit`), for documentation and
@@ -1384,7 +1511,7 @@ export function registerBuiltinCommands(registry) {
  * `registry.get(name)` instead, because that is the only check that stays
  * correct when commands are registered dynamically (§7.1 / P1-2).
  */
-export const BUILTIN_COMMAND_NAMES = ['queue', ...COMMANDS.flatMap((c) => [
+export const BUILTIN_COMMAND_NAMES = ['queue', 'prompts', 'agents', ...COMMANDS.flatMap((c) => [
         c.name,
         ...(c.aliases ?? []),
     ])].sort();