@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/todo/store.js

@@ -1,6 +1,6 @@
 /**
- * `TodoStore` — the session's todo list plus its CLI-local event stream
- * (todo-plan-execution §3.5).
+ * `TodoStore` — the session's todo list, its acceptance table, and its CLI-local
+ * event stream (todo-plan-execution §3.5; todo-acceptance-criteria §6.2.3).
  *
  * ASCII ONLY: `src/todo/**` is inside the glyph scanner's scope.
  *
@@ -9,30 +9,62 @@
  * is why `AgentController` can own this object as unconditionally as it owns
  * `TeamRuntime`.
  *
- * The list projects the current plan. Explicit clear/reset and a new TUI task
- * may remove that projection while the model still remembers the old plan.
- * Continuations preserve it; legacy callers retain completion/staleness rules.
+ * TWO TABLES, ONE WRITER, ONE COMMIT. `items` and `acceptance` are the plan's two
+ * halves: they are replaced together, cleared together, and refused together
+ * (I-4). Nothing here is a partial update, which is what makes I-9 ("the panel is
+ * never a contradiction of the model") provable rather than argued.
  *
- * Every write is a FULL REPLACEMENT and every clear is a FULL REMOVAL - there is
- * no partial update anywhere, which is what makes I-9 ("the panel is never a
- * contradiction of the model") provable rather than argued.
+ * `snapshot()` IS NOT A COMPUTATION. Every projection is rebuilt at the commit
+ * points (`write` / `restore` / `clear` / `reopenAll`, plus
+ * `refreshAcceptanceProjection` when `todo.acceptance` is flipped) and merely READ
+ * here, because `App` calls `snapshot()` on every event: re-deriving and
+ * re-stamping on read would give the reducer a new object every frame, invalidate
+ * `TodoCard`'s `React.memo` and the transcript's height cache, and undo the redraw
+ * savings `mapEntry` buys with object identity (P1-3).
  */
 import { getLogger } from '../logging/logger.js';
-import { TODO_LIMITS } from './limits.js';
+import { acceptanceSummary, normalizeAcceptance, planIsResolved } from './acceptance.js';
+import { ACCEPT_LIMITS, TODO_LIMITS } from './limits.js';
 import { normalizeTodos } from './normalize.js';
+/** The one model-readable refusal that is about the PLAN, not about the payload. */
+export const FRESH_ACCEPTANCE_REFUSAL = 'A plan needs acceptance criteria: how will you know the work is done? Send the ' +
+    'complete list again with an acceptance array - one checkable statement per line, ' +
+    'with the check you will run for it.';
+const NO_USABLE_ITEMS = 'No usable todo items: each needs a non-empty content string.';
 export class TodoStore {
     now;
+    acceptanceEnabled;
     items = [];
+    acceptance = [];
     updatedAt = 0;
     /** Consecutive `beginUserTurn()` calls since the last `write()`. */
     turnsSinceWrite = 0;
+    /**
+     * The acceptance projection. REBUILT AT COMMIT TIME ONLY — see the file header.
+     * `null` when there are no criteria, which is also what keeps the rail's second
+     * section, the card's second block and the status chip unrendered.
+     */
+    acceptanceSnapshot = null;
+    /**
+     * Criteria whose verdict has already been reported as restored. Without it the
+     * model would receive the SAME `Note:` on every turn, because it cannot know the
+     * server restored anything and keeps re-sending the row as `pending` (P2-4).
+     * Cleared by `clear()` / `restore()`; a criterion's key is removed when the criterion
+     * itself leaves the table (not when it stops being `pending`, which would delete the
+     * key in the same commit that added it - see `pruneRestoredNotes`).
+     */
+    restoredNotes = new Set();
     listeners = new Set();
     /**
      * @param now Injected clock. Defaults to `Date.now`; a test passes a counter
      *            so `TodoSnapshot.updatedAt` is not wall time (P2-4).
+     * @param acceptanceEnabled Live read of `todo.acceptance` (D-11). Read, never
+     *            snapshotted: `/todo acceptance off` must take effect mid-session,
+     *            because the tool array cannot change (C-1).
      */
-    constructor(now = Date.now) {
+    constructor(now = Date.now, acceptanceEnabled = () => true) {
         this.now = now;
+        this.acceptanceEnabled = acceptanceEnabled;
     }
     /** `null` means no list, which is what leaves the rail unmounted entirely. */
     snapshot() {
@@ -44,80 +76,105 @@ export class TodoStore {
             doneCount: this.items.filter((item) => item.status === 'completed').length,
             activeIndex: this.items.findIndex((item) => item.status === 'in_progress'),
             updatedAt: this.updatedAt,
+            acceptance: this.acceptanceSnapshot,
         };
     }
+    /** The acceptance table itself, for the transcript entry and the session file. */
+    acceptanceItems() {
+        return this.acceptance;
+    }
     isEmpty() {
         return this.items.length === 0;
     }
     /**
      * Commit a model payload.
      *
-     * ZERO SURVIVORS LEAVES THE PREVIOUS LIST UNTOUCHED (AC-9). A model sending
-     * nothing usable is a BUG, and destroying a working plan because of one
-     * malformed call is the worst available reaction; the caller turns the empty
-     * result into an error the model can act on. Contrast `restore()`, where an
-     * empty list is a FACT about a file and therefore means "clear".
+     * ZERO SURVIVORS LEAVES THE PREVIOUS PLAN UNTOUCHED (AC-9 / I-4), and so does an
+     * incomplete fresh plan: a model sending nothing usable is a BUG, and destroying
+     * a working plan because of one malformed call is the worst available reaction.
+     * The caller turns the refusal into something the model can act on. Contrast
+     * `restore()`, where an empty list is a FACT about a file and therefore means
+     * "clear".
      */
     write(raw) {
-        const result = normalizeTodos(raw, TODO_LIMITS.maxItems);
-        if (result.items.length === 0) {
-            this.emit({
-                type: 'rejected',
-                reason: 'No usable todo items: each needs a non-empty content string.',
-            });
-            return result;
+        // TWO ACCEPTED SHAPES, and the second is what every caller that predates the
+        // acceptance table sends: a bare array of steps. `todo_write` passes the whole
+        // params OBJECT (so a plan and its criteria arrive together), while a plain
+        // `store.write(todos)` still means "here is the list". Reading both keeps the
+        // one existing contract that a full replacement is expressed by the payload
+        // itself, and it means the acceptance table simply stays empty for the array
+        // form rather than being cleared by it.
+        const payload = (Array.isArray(raw)
+            ? { todos: raw }
+            : (raw && typeof raw === 'object' ? raw : {}));
+        const todoResult = normalizeTodos(payload.todos, TODO_LIMITS.maxItems);
+        // 1. A broken payload: the existing refusal, byte for byte.
+        if (todoResult.items.length === 0) {
+            this.emit({ type: 'rejected', reason: NO_USABLE_ITEMS });
+            return this.refusal(NO_USABLE_ITEMS, 'payload');
         }
-        this.items = result.items;
-        this.updatedAt = this.now();
-        this.turnsSinceWrite = 0;
-        const snapshot = this.snapshot();
-        // COUNTS ONLY, NEVER ITEM TEXT (D-19 / §3.14). It is user-task content, it
-        // is unbounded in aggregate, and the counts answer every question a log can
-        // answer here: did the list move, and was the payload repaired?
-        //
-        // SCOPE `'agent'`, NOT `'todo'`. §3.14 writes `'todo'`, but `LogScope` is a
-        // CLOSED UNION in `logging/logger.ts` and that file is not in the change
-        // plan; team mode faced the identical choice and files its CLI-local events
-        // under `'agent'` (`install.ts::attachTeamEvents`). Following that precedent
-        // keeps the diff focused and keeps a support reader filtering on one scope
-        // for everything a turn did. See spec §15 IF-1.
-        getLogger().debug('agent', 'todo_write', {
-            total: snapshot?.total ?? 0,
-            done: snapshot?.doneCount ?? 0,
-            active: snapshot?.activeIndex ?? -1,
-            repairs: result.repairs.length,
+        const enabled = this.acceptanceEnabled();
+        const accResult = normalizeAcceptance(payload.acceptance, this.acceptance, {
+            enabled,
+            restoredNotes: this.restoredNotes,
         });
-        if (snapshot)
-            this.emit({ type: 'updated', snapshot });
-        return result;
+        // 2. A FRESH plan must declare criteria - but ONLY while the capability is on.
+        //    `normalizeAcceptance` returns an empty table whenever it is off, so
+        //    without that precondition every fresh plan in a `todo.acceptance: false`
+        //    session would be refused: turning off a DISPLAY option would break the
+        //    tool itself, and no log line would say why (P0-3 / AC-11b).
+        const fresh = this.items.length === 0;
+        if (enabled && fresh && accResult.items.length < ACCEPT_LIMITS.minFreshCriteria) {
+            this.emit({ type: 'rejected', reason: FRESH_ACCEPTANCE_REFUSAL });
+            return this.refusal(FRESH_ACCEPTANCE_REFUSAL, 'policy');
+        }
+        // BOTH TABLES' REPAIR NOTES, or the acceptance half is repaired SILENTLY. A
+        // verdict dropped for having no evidence, a criterion restored by omission, a
+        // table truncated at the ceiling: each is a change the model did not ask for and
+        // cannot see, and this result text is the only channel that can tell it. Returning
+        // `todoResult.repairs` alone would make D-3's repair loop ("send the evidence next
+        // time") unreachable in practice.
+        const repairs = [...todoResult.repairs, ...accResult.repairs];
+        this.commit(todoResult.items, accResult.items, repairs);
+        return {
+            accepted: true,
+            items: this.items,
+            acceptance: this.acceptance,
+            repairs,
+        };
     }
     /**
-     * `/resume`. Runs through `normalizeTodos` — a session file is user-editable
+     * `/resume`. Runs through both normalizers — a session file is user-editable
      * input and gets a model payload's treatment.
      *
-     * AN EMPTY (OR ALL-DROPPED) ARRAY CLEARS; IT DOES NOT NO-OP (P0-2 / D-22).
+     * AN EMPTY (OR ALL-DROPPED) TODO ARRAY CLEARS; IT DOES NOT NO-OP (P0-2 / D-22).
      * `/resume` has just called `replaceMessages`, so the conversation the current
-     * list belonged to is gone; leaving it on screen is I-2 INVERTED — a panel
-     * that disagrees with the model, which §1.2 ranks below having no panel at
-     * all. The two entry points share normalization and differ only here, which is
-     * exactly the difference between "the model sent nothing" (a bug) and "the
-     * file has nothing" (a fact).
+     * plan belonged to is gone; leaving it on screen is I-2 INVERTED — a panel that
+     * disagrees with the model, which §1.2 ranks below having no panel at all. The
+     * acceptance table goes with it: no plan, no criteria.
+     *
+     * `enabled: true` is passed to the normalizer on purpose: the file is a fact
+     * about what this plan contained, and the current switch only governs RENDERING
+     * and PROMPTING. A user who turns the capability off and back on must not find
+     * that a resume quietly deleted the stored verdicts.
      */
-    restore(items) {
-        const result = normalizeTodos(items, TODO_LIMITS.maxItems);
-        if (result.items.length === 0) {
+    restore(items, acceptance = undefined) {
+        const todoResult = normalizeTodos(items, TODO_LIMITS.maxItems);
+        if (todoResult.items.length === 0) {
             this.clear('reset');
             return;
         }
-        this.items = result.items;
-        this.updatedAt = this.now();
-        this.turnsSinceWrite = 0;
-        const snapshot = this.snapshot();
-        if (snapshot)
-            this.emit({ type: 'updated', snapshot });
+        // `previous: []` and a fresh dedupe set: a resume is a brand new load, so the
+        // "a verdict is not undone by omission" rule has nothing to compare against.
+        this.restoredNotes.clear();
+        const accResult = normalizeAcceptance(acceptance, [], { enabled: true });
+        this.commit(todoResult.items, accResult.items, []);
     }
     clear(reason) {
         this.items = [];
+        this.acceptance = [];
+        this.acceptanceSnapshot = null;
+        this.restoredNotes.clear();
         this.updatedAt = this.now();
         this.turnsSinceWrite = 0;
         this.emit({ type: 'cleared', reason });
@@ -128,13 +185,14 @@ export class TodoStore {
      * Called from `AgentController.prompt()` and NOT from `steer()` — the same
      * asymmetry, for the same reason, that `askRounds = 0` already has: a steer is
      * a mid-turn interjection, not a new task. The stale counter inherits that
-     * asymmetry for free, which is the behaviour you want: a steer must not age
-     * out the plan it is steering.
+     * asymmetry for free, which is the behaviour you want: a steer must not age out
+     * the plan it is steering.
      *
-     * A new TUI task drops the old plan here, while a continuation preserves it.
-     * With no policy, legacy callers retain completed/stale-plan expiration.
-     * Clearing at `agent_end` would erase the final progress before the user can
-     * inspect it and remove the plan that automatic continuation still needs.
+     * "EVERY STEP IS COMPLETED" NO LONGER MEANS "THERE IS NOTHING LEFT" (G-4):
+     * the rule is `planIsResolved`, which also asks whether every criterion has a
+     * verdict. A plan that is done but unverified is not idle work, it is one step
+     * short - so it ages by `staleTurns` instead of vanishing the moment the model
+     * ticks its last step.
      */
     beginUserTurn(policy) {
         if (this.items.length === 0 || policy === 'continue')
@@ -143,20 +201,43 @@ export class TodoStore {
             this.clear('turn');
             return;
         }
-        if (this.items.every((item) => item.status === 'completed')) {
+        if (planIsResolved(this.items, this.acceptance)) {
             this.clear('turn');
             return;
         }
-        // ...but a partial list is not immortal (P1-7 / D-21). Without a bound, a
-        // plan abandoned mid-way holds a fifth of the terminal for the rest of the
-        // session, showing work nobody is doing - the "furniture when idle" R-g
-        // rules out. Self-healing, because the model's next write is a full
-        // replacement: the panel is ABSENT while the model still knows the plan,
-        // which is the safe direction (I-9).
+        // ...but a partial list is not immortal (P1-7 / D-21). Without a bound, a plan
+        // abandoned mid-way holds a fifth of the terminal for the rest of the session,
+        // showing work nobody is doing - the "furniture when idle" R-g rules out.
+        // Self-healing, because the model's next write is a full replacement: the
+        // panel is ABSENT while the model still knows the plan, which is the safe
+        // direction (I-9).
         this.turnsSinceWrite += 1;
         if (this.turnsSinceWrite > TODO_LIMITS.staleTurns)
             this.clear('stale');
     }
+    /**
+     * Send every verdict back to `pending` and clear the evidence (§6.2.3).
+     *
+     * THE NAMED WRITER `/todo acceptance reset` NEEDS, so the command layer never
+     * walks the table itself. It is not a second writer of the plan: `items` stays
+     * exactly as it is, no `cleared` event is emitted (`TodoClearReason` therefore
+     * does not change), and only the verdict fields move - the same rule as
+     * `reopen: true`, entered from the user's side instead of the model's (AC-6).
+     *
+     * IDEMPOTENT: with nothing to re-open it returns 0 and emits NOTHING, so an
+     * empty command cannot make the transcript card blink for no reason.
+     */
+    reopenAll() {
+        const reopenable = this.acceptance.filter((item) => item.status !== 'pending');
+        if (reopenable.length === 0)
+            return 0;
+        this.acceptance = this.deriveInProgress(this.acceptance.map((item) => (item.status === 'pending' ? item : { ...item, status: 'pending', evidence: '' })));
+        for (const item of this.acceptance)
+            this.restoredNotes.delete(item.content);
+        this.commitAcceptance();
+        this.emit({ type: 'updated', snapshot: this.snapshot() });
+        return reopenable.length;
+    }
     /**
      * Report a refusal that never reached `write()` (§3.3 steps 1 and 2).
      *
@@ -173,6 +254,123 @@ export class TodoStore {
             this.listeners.delete(listener);
         };
     }
+    /** A refusal that changed nothing, expressed as a result the tool can branch on. */
+    refusal(refusal, refusalKind) {
+        return {
+            accepted: false,
+            items: this.items,
+            acceptance: this.acceptance,
+            repairs: [],
+            refusal,
+            refusalKind,
+        };
+    }
+    /** Both tables, both projections, one timestamp, one event. */
+    commit(items, acceptance, repairs) {
+        this.items = items;
+        this.acceptance = this.deriveInProgress(acceptance);
+        this.updatedAt = this.now();
+        this.turnsSinceWrite = 0;
+        this.commitAcceptance();
+        this.pruneRestoredNotes();
+        const snapshot = this.snapshot();
+        // COUNTS ONLY, NEVER ITEM TEXT (D-19 / §3.14). It is user-task content, it is
+        // unbounded in aggregate, and the counts answer every question a log can
+        // answer here: did the plan move, and was the payload repaired?
+        //
+        // SCOPE `'agent'`, NOT `'todo'`: `LogScope` is a CLOSED UNION in
+        // `logging/logger.ts` and that file is not in the change plan; team mode faced
+        // the identical choice and files its CLI-local events under `'agent'`
+        // (`install.ts::attachTeamEvents`). See todo-plan-execution §15 IF-1.
+        getLogger().debug('agent', 'todo_write', {
+            total: snapshot?.total ?? 0,
+            done: snapshot?.doneCount ?? 0,
+            active: snapshot?.activeIndex ?? -1,
+            repairs: repairs.length,
+            accTotal: this.acceptance.length,
+            accChecked: this.acceptanceSnapshot?.checkedCount ?? 0,
+            accFailed: this.acceptanceSnapshot?.failedCount ?? 0,
+        });
+        if (snapshot)
+            this.emit({ type: 'updated', snapshot });
+    }
+    /**
+     * THE ONLY PRODUCER OF `in_progress` (P0-1 / AC-43).
+     *
+     * Normalization only ever DOWNGRADES that state; rendering and phase derivation
+     * only READ it. One state, one writer - otherwise the rail's anchor and the
+     * derived phase would each pick a different "criterion being checked".
+     *
+     * Forward only: criteria are promoted once EVERY step is completed, because a
+     * criterion cannot be under inspection while its steps are still running.
+     */
+    deriveInProgress(acceptance) {
+        const cleared = acceptance.some((item) => item.status === 'in_progress')
+            ? acceptance.map((item) => (item.status === 'in_progress' ? { ...item, status: 'pending' } : item))
+            : acceptance;
+        const allStepsDone = this.items.length > 0
+            && this.items.every((item) => item.status === 'completed');
+        if (!allStepsDone)
+            return cleared;
+        const firstPending = cleared.findIndex((item) => item.status === 'pending');
+        if (firstPending < 0)
+            return cleared;
+        const next = [...cleared];
+        next[firstPending] = { ...next[firstPending], status: 'in_progress' };
+        return next;
+    }
+    /**
+     * Re-project the acceptance table after `todo.acceptance` was flipped mid-session.
+     *
+     * THE SWITCH GOVERNS RENDERING, and the rail, the card and the status chip all read
+     * `snapshot().acceptance` rather than the flag - so without this, `/todo acceptance
+     * off` on a plan that already had criteria would leave the second section on screen
+     * until the model's next write, which is exactly the complaint P0-2 raised one path
+     * further out. The DATA is kept either way: turning the capability back on restores
+     * the same verdicts without a round trip through the model.
+     *
+     * Emits only when the projection's VISIBILITY actually changed, so a no-op flip can
+     * never make the transcript card blink.
+     */
+    refreshAcceptanceProjection() {
+        const shouldShow = this.acceptance.length > 0 && this.acceptanceEnabled();
+        if (shouldShow === (this.acceptanceSnapshot !== null))
+            return false;
+        this.commitAcceptance();
+        const snapshot = this.snapshot();
+        if (snapshot)
+            this.emit({ type: 'updated', snapshot });
+        return true;
+    }
+    /** Rebuild the acceptance projection. The ONLY place `acceptanceSummary` runs. */
+    commitAcceptance() {
+        // `acceptanceEnabled()` HERE TOO, not only on write: a resume rehydrates a file
+        // whose verdicts must not be lost, but a capability that is off must not draw
+        // them either. Data is a fact; the projection is what the user sees.
+        this.acceptanceSnapshot = this.acceptance.length > 0 && this.acceptanceEnabled()
+            ? acceptanceSummary(this.acceptance, this.now)
+            : null;
+    }
+    /**
+     * Forget a restoration note once its criterion has LEFT the table.
+     *
+     * `filtered on pending` would be the wrong rule and was the first version of this:
+     * the criterion that `noteOnce` just announced is restored WITH ITS VERDICT
+     * (`passed` / `failed`), so a pending filter deletes the key in the same commit that
+     * added it, the model re-sends the row as `pending` on the next turn, and the note is
+     * re-printed every turn for the life of the plan - the unbounded billing P2-4 exists
+     * to prevent. Keeping the key until the criterion is gone is also free: the set can
+     * never hold more than `ACCEPT_LIMITS.maxItems` entries.
+     */
+    pruneRestoredNotes() {
+        if (this.restoredNotes.size === 0)
+            return;
+        const present = new Set(this.acceptance.map((item) => item.content));
+        for (const content of [...this.restoredNotes]) {
+            if (!present.has(content))
+                this.restoredNotes.delete(content);
+        }
+    }
     /** Per-listener isolation: one bad subscriber cannot fail a tool call. */
     emit(event) {
         for (const listener of [...this.listeners]) {

package/dist/todo/todo-tool.d.ts

@@ -1,19 +1,22 @@
 /**
- * `todo_write` — the ONLY writer of `TodoStore` (todo-plan-execution §3.3 /
- * §4.1).
+ * `todo_write` — the ONLY writer of `TodoStore` (todo-plan-execution §3.3 / §4.1;
+ * todo-acceptance-criteria §6.4).
  *
  * ASCII ONLY: `src/todo/**` is inside the glyph scanner's scope.
  *
  * FULL-LIST REPLACEMENT, NO INCREMENTAL OPERATIONS (D-1). A delta protocol
  * (`todo_add` / `todo_complete`) lets the model's belief and the rendered panel
- * drift apart with nothing anywhere able to notice, and needs an id the model
- * must keep stable across calls - a field it will eventually get wrong. A full
- * replacement is idempotent, order-free and self-healing.
+ * drift apart with nothing anywhere able to notice, and needs an id the model must
+ * keep stable across calls - a field it will eventually get wrong. A full
+ * replacement is idempotent, order-free and self-healing. The acceptance table
+ * rides in the SAME call for exactly that reason: a second tool would be a second
+ * writer, with two refusal texts and a model free to update only half its plan.
  *
  * THE SCHEMA DECLARES SHAPE, NOT POLICY (C-8): no `enum`, no `maxItems`, no
- * `minItems`, and `activeForm` is not `required`. `ajv` is an OPTIONAL
- * dependency of core, so any of those would reject a payload where it happens to
- * be installed and repair the identical payload where it is not.
+ * `minItems`, and `acceptance` is not `required`. `ajv` is an OPTIONAL dependency
+ * of core, so any of those would reject a payload where it happens to be installed
+ * and repair the identical payload where it is not. Every bound lives in the
+ * `description` (what the model reads) and in `write()` (what is tested).
  *
  * PURE STATE: no filesystem, no network, no child process, no human wait. It
  * therefore must NOT be routed through `withPausedWatchdog` (C-9) -
@@ -23,10 +26,16 @@
  */
 import { type AgentTool } from '@aragon-agent/core';
 import type { TodoStore } from './store.js';
+import type { AcceptanceItem, TodoItem } from './types.js';
 export interface TodoToolDeps {
     store: TodoStore;
     /** Read LIVE, never cached: `/todo off` flips this; it cannot unregister (C-1). */
     isEnabled: () => boolean;
+    /**
+     * Read LIVE, never cached (D-11): `/todo acceptance off` must take effect in the
+     * session that is already running, because the tool array is immutable (C-1).
+     */
+    hasAcceptance: () => boolean;
 }
 /**
  * Turned off mid-session. A NON-ERROR result on purpose: the user turned a
@@ -36,3 +45,19 @@ export declare const TODO_OFF_REFUSAL = "Todo planning is off for this session.
 /** The structural half of R-c: a one-step list is not a plan. */
 export declare const TOO_SMALL_REFUSAL = "A one-step list is not a plan. Just do the work and summarize when you are done.";
 export declare function createTodoTool(deps: TodoToolDeps): AgentTool;
+/**
+ * The tool result — THE SINGLE STRONGEST LEVER ON R-b ("one at a time"), because
+ * unlike the system prompt it is re-read on every single call. There is
+ * deliberately NO RATE LIMIT to compete with it: a cap would fire exactly when the
+ * model is being most diligent and produce a refusal it cannot act on, and the
+ * costs a cap would have contained are already gone (§3.8 collapses N calls into
+ * ONE transcript entry, and the store is memory-only).
+ *
+ * FOUR PHASES, and the acceptance paragraph is inserted after the "In progress /
+ * Every item" paragraph and before any `Note:`. In `verify` and in the two `done`
+ * cases it also REPLACES that paragraph's closing sentence, because a plan that
+ * carries criteria has something more specific to say about being finished. With the
+ * capability off, or with no criteria, every branch below is byte-identical to the
+ * version without this feature (AC-28).
+ */
+export declare function buildResultText(items: readonly TodoItem[], acceptance: readonly AcceptanceItem[], repairs: readonly string[], acceptanceEnabled: boolean): string;