@songsid/agend 2.3.0-beta.24 → 2.3.0-beta.26

package/dist/scheduler/task-board.d.ts

@@ -112,6 +112,11 @@ export interface Card {
     priority: CardPriority;
     size: CardSize | null;
     needsReview: boolean;
+    /**
+     * #2434: opened on the board (createCards), not the `task` tool's own plain task. Before #2434 a main task's default
+     * "needs review" marked it; an agent's main task no longer waits for review, so the board says so on its own.
+     */
+    onBoard: boolean;
     /** uuids of the cards to finish first (what the fleet's `task` tool has always stored). */
     deps: string[];
     goal: string;
@@ -358,9 +363,28 @@ export interface SearchHit {
         text: string;
     } | null;
 }
+/**
+ * #2434: who confirms a card in review. The person confirms the cards they handed out (#2426's rule for a blocked card,
+ * for review too); an agent's card is the agents' own business: its instance dispatcher confirms it, and one nobody
+ * handed out its assignee (or the instance that opened it). A person may still confirm any card.
+ */
+export declare const personConfirms: (card: Pick<Card, "dispatcher">) => boolean;
+/** Who that is, in words (an error, the card's text). */
+export declare function confirmerOf(card: Pick<Card, "dispatcher" | "assignee">): string;
 /** "m3", "M - 3" → "M-3"; null when it is not a card number. */
 export declare function cardCode(raw: string): string | null;
-/** A card waits for the person's confirmation when it is finished. */
+/**
+ * An instance dispatcher that is no longer in the fleet (deleted): `gone(name)`, asked of the fleet. Its cards have no one
+ * left to answer or confirm them but the person. Unknown (no `gone`): every dispatcher is there.
+ */
+export type GoneDispatcher = (name: string) => boolean;
+/**
+ * #2425: whether a card waits for the person — in review needing their confirmation, or blocked on a question the person
+ * owns; both only when they handed it out (#2434: an agent's card in review is its dispatcher's to confirm), or when the
+ * instance that handed it out was deleted since (`gone`: nobody else is left to answer it). The one rule for
+ * waitingForPerson's query, Needs you and a button's route.
+ */
+export declare function waitsForPerson(card: Pick<Card, "status" | "needsReview" | "dispatcher">, gone?: GoneDispatcher): boolean;
 export declare function requiresReview(card: Pick<Card, "needsReview">): boolean;
 /**
  * What a finished card still lacks for the person's confirmation: unchecked acceptance items, no result. A main task
@@ -478,7 +502,10 @@ export declare class TaskBoard {
         cards: Card[];
         total: number;
     };
-    /** On the board's terms: in a project, a sub task, one with sub tasks, or one that waits for the person. */
+    /**
+     * On the board's terms: opened on it (#2434), in a project, a sub task, one with sub tasks, or one that waits for
+     * review (every main task opened on the board before #2434 did).
+     */
     isOnBoard(card: Card): boolean;
     /**
      * An instance's work, for `task mine`: what it is doing, what is blocked or waits for the person, what it can start
@@ -488,11 +515,24 @@ export declare class TaskBoard {
     /** Who holds a live card (open, in progress, blocked, waiting for the person): the instances, and any other name. */
     liveAssignees(): string[];
     myWork(name: string): MyWork;
+    /** #2434: whether `actor` confirms `card` (finishes it from review): the person their cards, an agent's its dispatcher. */
+    confirms(card: Card, actor: Actor): boolean;
+    /** #2434: the cards an instance handed out that wait in review for its confirmation (its `task mine`). */
+    toConfirm(name: string): Card[];
     /**
-     * What waits for the person (step 3: Needs you): cards in review that need their confirmation, and blocked cards —
-     * oldest first, each with when it started waiting (its last move to that status).
+     * What waits for the person (step 3: Needs you, and the daily summary): cards in review that need their confirmation,
+     * and blocked cards whose question is theirs to answer — oldest first, each with when it started waiting (its last
+     * move to that status).
+     *
+     * A blocked card asks the person only when the person handed it out (dispatcher kind "person"). One an instance handed
+     * out is that instance's to decide (step 2's wakes: its question goes there, not here). One with no dispatcher is an
+     * instance's own "I'm waiting" — every card the `task` tool kept before the board, an agent's card for itself, a
+     * reviewer's "waiting on the author" — and is no question to the person: 2.3.0-beta.24 listed 28 such cards, weeks
+     * old, as "stuck, asking you" (#2425). Nothing is changed on the cards; they stay on the board as they are. One an
+     * instance handed out that was deleted since (`gone`) has nobody else to answer or confirm it: it falls back to the
+     * person.
      */
-    waitingForPerson(): Array<{
+    waitingForPerson(gone?: GoneDispatcher): Array<{
         card: Card;
         since: string;
     }>;
@@ -509,7 +549,7 @@ export declare class TaskBoard {
      * Step 3, the daily summary (task-board-summary.ts): what waits for the person now, what got done and what was
      * opened in [since, until) (not cancelled), and every live main task's project and assignee.
      */
-    summaryRead(since: string, until: string): {
+    summaryRead(since: string, until: string, gone?: GoneDispatcher): {
         waiting: Card[];
         done: Card[];
         created: Card[];
@@ -559,8 +599,8 @@ export declare class TaskBoard {
      */
     legacyClaim(actor: Actor, uuid: string, assignee: string): Card;
     /**
-     * `task done`: from open or claimed. A card that needs the person's confirmation goes to review instead, so no
-     * instance can finish one alone. On the board, an instance finishes as it would there: its own card, with a result
+     * `task done`: from open or claimed. A card that needs confirmation goes to review instead, so no instance finishes
+     * one it does not confirm alone; the one who confirms it finishes it, from review too (#2434). On the board, an instance finishes as it would there: its own card, with a result
      * (an open one is claimed first, under the same rules).
      */
     legacyComplete(actor: Actor, uuid: string, result?: string): Card;
@@ -615,8 +655,8 @@ export declare class TaskBoard {
     private applyMove;
     /**
      * A main task with sub tasks follows them: open until something starts, in progress while they run, and when they
-     * are all done, review (or done, for one that skips the person's confirmation). Only a person moves it from review
-     * to done. A blocked or cancelled main task is left alone, and so is one without sub tasks (it is moved by hand).
+     * are all done, review (or done, for one that needs no confirmation). Only whoever confirms it (#2434) moves it
+     * from review to done. A blocked or cancelled main task is left alone, and so is one without sub tasks (it is moved by hand).
      */
     /** What a main task's sub tasks make its status (its own, when it is blocked, cancelled or has none). */
     private derivedStatus;

package/dist/scheduler/task-board.js

@@ -97,6 +97,29 @@ function toDispatcher(input, actor) {
  */
 const openedForItself = (c) => c.assignee !== null && c.createdBy === c.assignee && c.dispatcher === null;
 const isDispatcher = (card, actor) => card.dispatcher?.kind === "instance" && !isPerson(actor) && card.dispatcher.name === actor.name;
+/**
+ * #2434: who confirms a card in review. The person confirms the cards they handed out (#2426's rule for a blocked card,
+ * for review too); an agent's card is the agents' own business: its instance dispatcher confirms it, and one nobody
+ * handed out its assignee (or the instance that opened it). A person may still confirm any card.
+ */
+export const personConfirms = (card) => card.dispatcher?.kind === "person";
+function confirms(card, actor) {
+    if (isPerson(actor))
+        return true;
+    if (personConfirms(card))
+        return false;
+    if (card.dispatcher?.kind === "instance")
+        return card.dispatcher.name === actor.name;
+    return card.assignee === actor.name || (card.assignee === null && card.createdBy === actor.name);
+}
+/** Who that is, in words (an error, the card's text). */
+export function confirmerOf(card) {
+    if (card.dispatcher?.kind === "person")
+        return "the person";
+    if (card.dispatcher?.kind === "instance")
+        return card.dispatcher.name;
+    return card.assignee ?? "its assignee";
+}
 function normalizeAssignee(raw) {
     const v = raw?.trim() ?? "";
     if (v === "" || v.toLowerCase() === "none")
@@ -110,7 +133,16 @@ export function cardCode(raw) {
     const m = CODE_RE.exec(raw);
     return m ? `${m[1].toUpperCase()}-${Number(m[2])}` : null;
 }
-/** A card waits for the person's confirmation when it is finished. */
+const orphaned = (card, gone) => !!gone && card.dispatcher?.kind === "instance" && gone(card.dispatcher.name);
+/**
+ * #2425: whether a card waits for the person — in review needing their confirmation, or blocked on a question the person
+ * owns; both only when they handed it out (#2434: an agent's card in review is its dispatcher's to confirm), or when the
+ * instance that handed it out was deleted since (`gone`: nobody else is left to answer it). The one rule for
+ * waitingForPerson's query, Needs you and a button's route.
+ */
+export function waitsForPerson(card, gone) {
+    return (personConfirms(card) || orphaned(card, gone)) && ((card.status === "review" && card.needsReview) || card.status === "blocked");
+}
 export function requiresReview(card) {
     return card.needsReview;
 }
@@ -148,6 +180,7 @@ function toCard(r) {
         priority: r.priority ?? "normal",
         size: r.size ?? null,
         needsReview: Number(r.needs_review) === 1,
+        onBoard: Number(r.on_board) === 1,
         deps: parseJsonArray(r.depends_on, []).filter((d) => typeof d === "string"),
         goal: r.description ?? "",
         scope: r.scope ?? "",
@@ -250,6 +283,7 @@ export class TaskBoard {
         add("seen_entry_id", "INTEGER NOT NULL DEFAULT 0");
         add("dispatcher", "TEXT");
         add("dispatcher_kind", "TEXT");
+        add("on_board", "INTEGER NOT NULL DEFAULT 0"); // #2434; a row before it: its needs_review says so
         this.db.exec(`
       CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_code ON tasks(code);
       CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
@@ -753,9 +787,12 @@ export class TaskBoard {
         const rows = this.db.prepare(`SELECT * ${from} ORDER BY CASE kind WHEN 'main' THEN 0 ELSE 1 END, ${STATUS_ORDER}, ${PRIORITY_ORDER}, sort LIMIT ?`).all(...params, limit);
         return { cards: rows.map(toCard), total: n };
     }
-    /** On the board's terms: in a project, a sub task, one with sub tasks, or one that waits for the person. */
+    /**
+     * On the board's terms: opened on it (#2434), in a project, a sub task, one with sub tasks, or one that waits for
+     * review (every main task opened on the board before #2434 did).
+     */
     isOnBoard(card) {
-        return card.projectId !== null || card.kind === "sub" || card.needsReview || this.activeSubs(card.uuid).length > 0;
+        return card.onBoard || card.projectId !== null || card.kind === "sub" || card.needsReview || this.activeSubs(card.uuid).length > 0;
     }
     /**
      * An instance's work, for `task mine`: what it is doing, what is blocked or waits for the person, what it can start
@@ -800,16 +837,39 @@ export class TaskBoard {
             mains: coordinating.map((card) => ({ card, progress: this.progress(card) })),
         };
     }
+    /** #2434: whether `actor` confirms `card` (finishes it from review): the person their cards, an agent's its dispatcher. */
+    confirms(card, actor) { return confirms(card, actor); }
+    /** #2434: the cards an instance handed out that wait in review for its confirmation (its `task mine`). */
+    toConfirm(name) {
+        return this.db.prepare("SELECT * FROM tasks WHERE status = 'review' AND needs_review = 1 AND (dispatcher_kind IS NULL OR dispatcher_kind != 'person') AND dispatcher = ? AND (assignee IS NULL OR assignee != ?) ORDER BY updated_at")
+            .all(name, name).map(toCard);
+    }
     /**
-     * What waits for the person (step 3: Needs you): cards in review that need their confirmation, and blocked cards —
-     * oldest first, each with when it started waiting (its last move to that status).
+     * What waits for the person (step 3: Needs you, and the daily summary): cards in review that need their confirmation,
+     * and blocked cards whose question is theirs to answer — oldest first, each with when it started waiting (its last
+     * move to that status).
+     *
+     * A blocked card asks the person only when the person handed it out (dispatcher kind "person"). One an instance handed
+     * out is that instance's to decide (step 2's wakes: its question goes there, not here). One with no dispatcher is an
+     * instance's own "I'm waiting" — every card the `task` tool kept before the board, an agent's card for itself, a
+     * reviewer's "waiting on the author" — and is no question to the person: 2.3.0-beta.24 listed 28 such cards, weeks
+     * old, as "stuck, asking you" (#2425). Nothing is changed on the cards; they stay on the board as they are. One an
+     * instance handed out that was deleted since (`gone`) has nobody else to answer or confirm it: it falls back to the
+     * person.
      */
-    waitingForPerson() {
-        const rows = this.db.prepare("SELECT * FROM tasks WHERE (status = 'review' AND needs_review = 1) OR status = 'blocked' ORDER BY updated_at").all().map(toCard);
+    waitingForPerson(gone) {
+        const waiting = "((status = 'review' AND needs_review = 1) OR status = 'blocked')";
+        const rows = [
+            ...this.db.prepare(`SELECT * FROM tasks WHERE dispatcher_kind = 'person' AND ${waiting}`).all().map(toCard),
+            ...(gone ? this.db.prepare(`SELECT * FROM tasks WHERE dispatcher IS NOT NULL AND (dispatcher_kind IS NULL OR dispatcher_kind != 'person') AND ${waiting}`).all()
+                .map(toCard).filter((card) => orphaned(card, gone)) : []),
+        ];
         const moved = this.db.prepare("SELECT at FROM task_events WHERE task_id = ? AND type = 'moved' AND json_extract(data, '$.to') = ? ORDER BY id DESC LIMIT 1");
         return rows.map((card) => {
             const at = moved.get(card.uuid, card.status)?.at;
-            return { card, since: at ?? card.submittedAt ?? card.updatedAt };
+            // Never updatedAt (#2425): a card edited every minute (a note, a heartbeat) would get a new `since` — and so a new
+            // Needs-you item id, posted again at the bottom as if it were new, once a minute.
+            return { card, since: at ?? card.submittedAt ?? card.createdAt };
         }).sort((a, b) => a.since.localeCompare(b.since));
     }
     /** Cards by their numbers, in one read (the ones that exist; #2341 review: the cards a summary line named). */
@@ -897,10 +957,10 @@ export class TaskBoard {
      * Step 3, the daily summary (task-board-summary.ts): what waits for the person now, what got done and what was
      * opened in [since, until) (not cancelled), and every live main task's project and assignee.
      */
-    summaryRead(since, until) {
+    summaryRead(since, until, gone) {
         const between = (sql) => this.db.prepare(sql).all(since, until).map(toCard);
         return {
-            waiting: this.waitingForPerson().map((w) => w.card),
+            waiting: this.waitingForPerson(gone).map((w) => w.card),
             done: between("SELECT * FROM tasks WHERE status = 'done' AND done_at >= ? AND done_at < ? ORDER BY sort"),
             created: between("SELECT * FROM tasks WHERE status != 'cancelled' AND created_at >= ? AND created_at < ? ORDER BY sort"),
             mains: this.db.prepare("SELECT project_id, assignee FROM tasks WHERE kind = 'main' AND status != 'cancelled'").all()
@@ -942,13 +1002,14 @@ export class TaskBoard {
                     const acceptance = checkAcceptance(spec.acceptance ?? []);
                     if (acceptance.length > CARD_LIMITS.acceptanceItems)
                         throw new TaskBoardError("too_long", `at most ${CARD_LIMITS.acceptanceItems} acceptance items`, "acceptance_max", [CARD_LIMITS.acceptanceItems]);
-                    const needsReview = spec.needsReview ?? kind === "main";
-                    if (!needsReview && kind === "main" && !isPerson(actor))
-                        throw new TaskBoardError("forbidden", "only a person can open a main task that skips their confirmation");
                     const now = this.nowIso();
                     const assignee = spec.assignee !== undefined ? normalizeAssignee(spec.assignee) : isPerson(actor) ? null : actor.name;
                     const opener = isPerson(actor) ? { kind: "person", name: actor.name }
                         : actor.kind === "instance" && assignee && assignee !== actor.name ? { kind: "instance", name: actor.name } : null;
+                    const dispatcher = spec.dispatcher !== undefined ? toDispatcher(spec.dispatcher, actor) : (parent?.dispatcher ?? opener);
+                    // #2434: a main task waits for the person's confirmation when the person handed it out; an agent's needs none
+                    // unless it asks for one (its dispatcher then confirms it).
+                    const needsReview = spec.needsReview ?? (kind === "main" && dispatcher?.kind === "person");
                     const card = {
                         uuid: randomUUID(),
                         code: this.nextCode(kind === "main" ? "M" : "S"),
@@ -958,10 +1019,11 @@ export class TaskBoard {
                         title,
                         status: "open",
                         assignee,
-                        dispatcher: spec.dispatcher !== undefined ? toDispatcher(spec.dispatcher, actor) : (parent?.dispatcher ?? opener),
+                        dispatcher,
                         priority: spec.priority ?? "normal",
                         size: spec.size ?? null,
                         needsReview,
+                        onBoard: true,
                         deps: this.checkDeps({ uuid: null, kind, parent: parent?.uuid ?? null }, (spec.dependsOn ?? []).map((d) => this.resolveRef(d, created))),
                         goal: checkText("the goal", spec.goal ?? "", CARD_LIMITS.goal),
                         scope: checkText("the scope", spec.scope ?? "", CARD_LIMITS.scope),
@@ -1048,11 +1110,24 @@ export class TaskBoard {
                 set("size", patch.size);
             if (patch.priority !== undefined)
                 set("priority", patch.priority);
-            if (patch.dispatcher !== undefined)
-                set("dispatcher", toDispatcher(patch.dispatcher, actor), "dispatcher", (d) => d?.name ?? null);
+            if (patch.dispatcher !== undefined) {
+                const next = toDispatcher(patch.dispatcher, actor);
+                // #2434: the person's card stays theirs — an instance re-dispatching it would take it out of their confirmation.
+                const moved = JSON.stringify(next) !== JSON.stringify(card.dispatcher);
+                if (ai && personConfirms(card) && moved) {
+                    throw new TaskBoardError("forbidden", `${card.code} was handed out by the person; only they hand it to someone else`);
+                }
+                // #2436 review: nor an agent's card that waits for its dispatcher's confirmation — dropping or replacing the
+                // dispatcher would let its assignee confirm it itself. Only that dispatcher (or a person) hands it on.
+                if (ai && moved && card.needsReview && card.dispatcher?.kind === "instance" && card.dispatcher.name !== actor.name) {
+                    throw new TaskBoardError("forbidden", `${card.code} waits for ${card.dispatcher.name}'s confirmation; only they hand it to someone else`);
+                }
+                set("dispatcher", next, "dispatcher", (d) => d?.name ?? null);
+            }
             if (patch.needsReview !== undefined) {
-                if (ai && card.needsReview && !patch.needsReview)
-                    throw new TaskBoardError("forbidden", "only a person can clear \"needs review\"");
+                if (ai && card.needsReview && !patch.needsReview && !confirms(card, actor)) {
+                    throw new TaskBoardError("forbidden", personConfirms(card) ? "only a person can clear \"needs review\"" : `only ${confirmerOf(card)} can clear "needs review" on ${card.code}`);
+                }
                 set("needsReview", patch.needsReview);
             }
             if (patch.dependsOn !== undefined) {
@@ -1220,7 +1295,7 @@ export class TaskBoard {
             const now = this.nowIso();
             const card = {
                 uuid: randomUUID(), code: this.nextCode("M"), kind: "main", projectId: null, parent: null, title: params.title, status: "open",
-                assignee: params.assignee ?? null, priority: params.priority ?? "normal", size: null, needsReview: false,
+                assignee: params.assignee ?? null, priority: params.priority ?? "normal", size: null, needsReview: false, onBoard: false,
                 // Opened for another instance: the opener handed it out (its blocked question goes to it).
                 dispatcher: actor.kind === "instance" && params.assignee && params.assignee !== actor.name ? { kind: "instance", name: actor.name } : null,
                 deps: this.checkDeps({ uuid: null, kind: "main", parent: null }, params.depends_on ?? []),
@@ -1273,8 +1348,8 @@ export class TaskBoard {
         });
     }
     /**
-     * `task done`: from open or claimed. A card that needs the person's confirmation goes to review instead, so no
-     * instance can finish one alone. On the board, an instance finishes as it would there: its own card, with a result
+     * `task done`: from open or claimed. A card that needs confirmation goes to review instead, so no instance finishes
+     * one it does not confirm alone; the one who confirms it finishes it, from review too (#2434). On the board, an instance finishes as it would there: its own card, with a result
      * (an open one is claimed first, under the same rules).
      */
     legacyComplete(actor, uuid, result) {
@@ -1282,8 +1357,10 @@ export class TaskBoard {
             const card = this.byUuid(uuid);
             if (!card)
                 throw new Error(`Task "${uuid}" not found`);
-            if (card.status !== "claimed" && card.status !== "open") {
-                throw new Error(`Task "${uuid}" is ${card.status}, cannot complete (must be open or claimed)`);
+            // #2434: a card in review is finished by whoever confirms it (an agent's card: its dispatcher).
+            const confirming = card.status === "review" && confirms(card, actor);
+            if (card.status !== "claimed" && card.status !== "open" && !confirming) {
+                throw new Error(`Task "${uuid}" is ${card.status}, cannot complete (must be open or claimed${card.status === "review" ? `; it waits for ${confirmerOf(card)}'s confirmation` : ""})`);
             }
             const open = this.children(card.uuid).filter((k) => !isFinished(k));
             if (open.length)
@@ -1292,7 +1369,7 @@ export class TaskBoard {
                 this.event(actor, card, "updated", { changes: { result: { from: card.result, to: result } } });
                 card.result = result;
             }
-            const to = requiresReview(card) && !isPerson(actor) ? "review" : "done";
+            const to = requiresReview(card) && !confirms(card, actor) ? "review" : "done";
             if (this.heldToBoardRules(card, actor)) {
                 if (card.status === "open") {
                     this.checkManualMove(card, actor, "claimed", "", { finishing: true });
@@ -1345,9 +1422,9 @@ export class TaskBoard {
                     if (derived)
                         this.checkDerivedMove(card, actor, to, "");
                     else {
-                        if (card.status === "review" && to === "done")
-                            throw new Error(`Task "${card.code}" is waiting for the person's confirmation`);
-                        if (to === "done" && requiresReview(card))
+                        if (card.status === "review" && to === "done" && !confirms(card, actor))
+                            throw new Error(`Task "${card.code}" is waiting for ${confirmerOf(card)}'s confirmation`);
+                        if (to === "done" && card.status !== "review" && requiresReview(card) && !confirms(card, actor))
                             to = "review";
                         if (held && to !== card.status)
                             this.checkManualMove(card, actor, to, "");
@@ -1414,7 +1491,13 @@ export class TaskBoard {
                         this.checkOneAtATime(card, actor);
                 }
                 else if (from === "review") {
-                    if (ai) {
+                    if (ai && !own && confirms(card, actor)) {
+                        // #2434: an agent's card sent back by the instance that confirms it, as the person sends theirs back.
+                        if (!reason)
+                            throw new TaskBoardError("invalid", "sending work back needs a reason", "sendback_reason");
+                        this.entry(card, "reject", actor, reason);
+                    }
+                    else if (ai) {
                         if (!own)
                             throw notOwner();
                         if (startsWork)
@@ -1458,14 +1541,24 @@ export class TaskBoard {
             }
             case "done": {
                 if (ai) {
-                    if (from === "review")
-                        throw new TaskBoardError("forbidden", `${card.code} is waiting for the person's confirmation: only they finish it`);
-                    if (from !== "claimed")
-                        throw new TaskBoardError("invalid", `only a card in progress can be done (${card.code} is ${from})`);
-                    if (!own)
-                        throw notOwner();
-                    if (requiresReview(card))
-                        throw new TaskBoardError("needs_review", `${card.code} needs the person's confirmation; move it to review`);
+                    if (from === "review") {
+                        if (!confirms(card, actor)) {
+                            throw new TaskBoardError("forbidden", personConfirms(card) ? `${card.code} is waiting for the person's confirmation: only they finish it`
+                                : `${card.code} is waiting for ${confirmerOf(card)}'s confirmation: only they finish it`);
+                        }
+                        if (reason)
+                            this.entry(card, "approve", actor, reason);
+                    }
+                    else {
+                        if (from !== "claimed")
+                            throw new TaskBoardError("invalid", `only a card in progress can be done (${card.code} is ${from})`);
+                        if (!own)
+                            throw notOwner();
+                        if (requiresReview(card) && !confirms(card, actor)) {
+                            throw new TaskBoardError("needs_review", personConfirms(card) ? `${card.code} needs the person's confirmation; move it to review`
+                                : `${card.code} needs ${confirmerOf(card)}'s confirmation; move it to review`);
+                        }
+                    }
                 }
                 else if (from === "review" && reason) {
                     this.entry(card, "approve", actor, reason);
@@ -1671,8 +1764,8 @@ export class TaskBoard {
     }
     /**
      * A main task with sub tasks follows them: open until something starts, in progress while they run, and when they
-     * are all done, review (or done, for one that skips the person's confirmation). Only a person moves it from review
-     * to done. A blocked or cancelled main task is left alone, and so is one without sub tasks (it is moved by hand).
+     * are all done, review (or done, for one that needs no confirmation). Only whoever confirms it (#2434) moves it
+     * from review to done. A blocked or cancelled main task is left alone, and so is one without sub tasks (it is moved by hand).
      */
     /** What a main task's sub tasks make its status (its own, when it is blocked, cancelled or has none). */
     derivedStatus(main) {
@@ -1705,7 +1798,7 @@ export class TaskBoard {
         this.save(main);
         this.event(actor, main, "moved", { from, to: next, auto: true });
         if (next === "review")
-            this.say("review_waiting", [main.code, main.title], `${main.code} "${main.title}": every sub task is done; it is waiting for the person's confirmation`);
+            this.say("review_waiting", [main.code, main.title], `${main.code} "${main.title}": every sub task is done; it is waiting for ${confirmerOf(main)}'s confirmation`);
         else if (from === "done" || from === "review")
             this.say("back_to", [main.code, next], `${main.code} has unfinished sub tasks again; it is back to ${next}`);
         if (next === "done")
@@ -1824,7 +1917,8 @@ export class TaskBoard {
                     add(card, card.assignee, "cancelled", e.actor, why);
                     continue;
                 }
-                // Its dispatcher tells the person it waits for them (not the board).
+                // An agent's card waits for its instance dispatcher to confirm it (#2434: its own to confirm, nobody to ask). A
+                // person's card has no instance dispatcher, so no notice: the person has it in Needs you.
                 if (d.to === "review" && !isPerson(e.actor) && requiresReview(card))
                     add(card, dispatcherOf(), "to_confirm", e.actor);
                 if (d.auto) {
@@ -1836,9 +1930,9 @@ export class TaskBoard {
                     add(card, card.assignee, "start", e.actor);
                 else if (d.from === "blocked" && d.to === "claimed")
                     add(card, card.assignee, "answered", e.actor, comments.get(card.uuid));
-                else if (d.from === "review" && (d.to === "claimed" || d.to === "open") && isPerson(e.actor))
+                else if (d.from === "review" && (d.to === "claimed" || d.to === "open"))
                     add(card, card.assignee, "sent_back", e.actor, d.reason);
-                else if (d.from === "review" && d.to === "done" && isPerson(e.actor)) {
+                else if (d.from === "review" && d.to === "done") {
                     add(card, card.assignee, "approved", e.actor, d.reason);
                     add(card, dispatcherOf(), "approved", e.actor, d.reason);
                 }
@@ -2071,8 +2165,8 @@ export class TaskBoard {
     }
     insert(card) {
         this.db.prepare(`INSERT INTO tasks (id, code, kind, project_id, parent_id, title, description, status, priority, assignee, dispatcher, dispatcher_kind, created_by, depends_on, result,
-        scope, acceptance, context, state, blocked_reason, size, needs_review, version, sort, created_at, updated_at, started_at, submitted_at, done_at, seen_entry_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(card.uuid, card.code, card.kind, card.projectId, card.parent, card.title, card.goal === "" ? null : card.goal, card.status, card.priority, card.assignee, card.dispatcher?.name ?? null, card.dispatcher?.kind ?? null, card.createdBy, card.deps.length ? JSON.stringify(card.deps) : null, card.result === "" ? null : card.result, card.scope, JSON.stringify(card.acceptance), card.context, card.state, card.blockedReason, card.size, card.needsReview ? 1 : 0, card.version, card.sort, card.createdAt, card.updatedAt, card.startedAt, card.submittedAt, card.doneAt, card.seenEntryId);
+        scope, acceptance, context, state, blocked_reason, size, needs_review, version, sort, created_at, updated_at, started_at, submitted_at, done_at, seen_entry_id, on_board)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(card.uuid, card.code, card.kind, card.projectId, card.parent, card.title, card.goal === "" ? null : card.goal, card.status, card.priority, card.assignee, card.dispatcher?.name ?? null, card.dispatcher?.kind ?? null, card.createdBy, card.deps.length ? JSON.stringify(card.deps) : null, card.result === "" ? null : card.result, card.scope, JSON.stringify(card.acceptance), card.context, card.state, card.blockedReason, card.size, card.needsReview ? 1 : 0, card.version, card.sort, card.createdAt, card.updatedAt, card.startedAt, card.submittedAt, card.doneAt, card.seenEntryId, card.onBoard ? 1 : 0);
     }
     /** Empty text is stored as NULL in the columns the `task` tool has always had (description, result, depends_on). */
     save(card) {