@songsid/agend 2.3.2-beta.9 → 2.3.2

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

@@ -157,6 +157,10 @@ export interface ProjectStats {
 /** A card as the dashboard draws it: references by card number. */
 export interface CardView {
     id: string;
+    /** #2080: in review needing the person's confirmation, or blocked on a question theirs (waitsForPerson): Waiting for you. */
+    waitsForPerson: boolean;
+    /** #2080: the instance that confirms it in review (its dispatcher, else its assignee); null when the person does. */
+    confirmer: string | null;
     uuid: string;
     kind: CardKind;
     projectId: number | null;
@@ -224,7 +228,7 @@ export interface CardEvent {
  * a main task went to the person by itself before its owner wrapped it up (wrap_up); or someone else cancelled it — a
  * main task's cancel takes its unfinished sub tasks down with it, and their assignees hear (cancelled).
  */
-export type WakeReason = "assigned" | "start" | "sent_back" | "answered" | "comment" | "ready" | "decide" | "to_confirm" | "approved" | "wrap_up" | "cancelled";
+export type WakeReason = "assigned" | "start" | "sent_back" | "answered" | "comment" | "ready" | "decide" | "to_confirm" | "confirm_own" | "approved" | "wrap_up" | "cancelled";
 /** One card's news for one instance from one committed write. Never sent to a page (it carries titles and text). */
 export interface Wake {
     instance: string;
@@ -371,6 +375,11 @@ export interface SearchHit {
 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;
+/**
+ * #2080: the instance that confirms a card in review (`confirms`' rule), or null when it is the person's — handed out by
+ * them, or by an instance deleted since (`gone`), or nobody's at all.
+ */
+export declare function confirmingInstance(card: Pick<Card, "dispatcher" | "assignee" | "createdBy">, gone?: GoneDispatcher): string | null;
 /** "m3", "M - 3" → "M-3"; null when it is not a card number. */
 export declare function cardCode(raw: string): string | null;
 /**
@@ -462,10 +471,11 @@ export declare class TaskBoard {
     /**
      * Each project's numbers (by id; "none" for No project) over all its cards, finished ones included: main tasks,
      * work units (a main task's sub tasks, or one unit for a main task without them; a done main task counts all its
-     * units done), cards waiting for the person and blocked, and the last change. One pass over the table.
+     * units done), cards waiting for the person and blocked, and the last change. One pass over the table. #2080: waiting
+     * counts only the cards in review the person confirms (waitsForPerson, `gone` as for Needs you), never an agent's.
      */
-    projectStats(): Record<string, ProjectStats>;
-    view(card: Card, scope?: ReadScope): CardView;
+    projectStats(gone?: GoneDispatcher): Record<string, ProjectStats>;
+    view(card: Card, scope?: ReadScope, gone?: GoneDispatcher): CardView;
     /** ` AND <column> NOT IN (…)` for a scope's left-out authors, with its values (empty when none). */
     private notBy;
     /**
@@ -474,8 +484,13 @@ export declare class TaskBoard {
      * queries per card: a board read stays a handful of statements however many cards it has (it runs on the fleet's
      * event loop). Same answers as progress(), unmetDeps() and newComments() card by card.
      */
-    views(cards: Card[], scope?: ReadScope): CardView[];
-    detail(ref: string, scope?: ReadScope): CardDetail;
+    views(cards: Card[], scope?: ReadScope, gone?: GoneDispatcher): CardView[];
+    detail(ref: string, scope?: ReadScope, gone?: GoneDispatcher): CardDetail;
+    /**
+     * #2757 review: the instance dispatchers on the board that `gone` says are gone, as one string — what a cached read
+     * that names waitsForPerson / confirmer must also be keyed by (a dispatcher deleted changes them, the revision not).
+     */
+    goneDispatchers(gone?: GoneDispatcher): string;
     /** The latest `limit` entries of a card, oldest first. */
     entries(uuid: string, kinds: EntryKind[], limit?: number): Entry[];
     /** Comments and rejections by others that the assignee has not acted on yet. */
@@ -615,6 +630,13 @@ export declare class TaskBoard {
         result?: string;
         priority?: CardPriority;
     }): Card;
+    /**
+     * #2080: review for an instance's own confirmation is done. An instance moving a card to review that it confirms itself
+     * (nobody else handed it out, or it handed it to itself) would wait for nobody but itself — and sat there unnoticed,
+     * in the person's Waiting for you too: it finishes instead (the checks for review are the ones for done). A person's
+     * move, and a card someone else confirms, stay as asked.
+     */
+    private ownReview;
     /**
      * Cards moved by hand: sub tasks, and main tasks that have no sub tasks. `comment` is the move's own comment (a
      * dispatcher's answer); `finishing`: a claim on the way to done (the `task` tool's done of an open card).

package/dist/scheduler/task-board.js

@@ -120,6 +120,17 @@ export function confirmerOf(card) {
         return card.dispatcher.name;
     return card.assignee ?? "its assignee";
 }
+/**
+ * #2080: the instance that confirms a card in review (`confirms`' rule), or null when it is the person's — handed out by
+ * them, or by an instance deleted since (`gone`), or nobody's at all.
+ */
+export function confirmingInstance(card, gone) {
+    if (personConfirms(card) || orphaned(card, gone))
+        return null;
+    if (card.dispatcher?.kind === "instance")
+        return card.dispatcher.name;
+    return card.assignee ?? (card.createdBy || null);
+}
 function normalizeAssignee(raw) {
     const v = raw?.trim() ?? "";
     if (v === "" || v.toLowerCase() === "none")
@@ -518,10 +529,11 @@ export class TaskBoard {
     /**
      * Each project's numbers (by id; "none" for No project) over all its cards, finished ones included: main tasks,
      * work units (a main task's sub tasks, or one unit for a main task without them; a done main task counts all its
-     * units done), cards waiting for the person and blocked, and the last change. One pass over the table.
+     * units done), cards waiting for the person and blocked, and the last change. One pass over the table. #2080: waiting
+     * counts only the cards in review the person confirms (waitsForPerson, `gone` as for Needs you), never an agent's.
      */
-    projectStats() {
-        const rows = this.db.prepare("SELECT id, kind, status, project_id, parent_id, updated_at FROM tasks").all();
+    projectStats(gone) {
+        const rows = this.db.prepare("SELECT id, kind, status, project_id, parent_id, updated_at, needs_review, dispatcher, dispatcher_kind FROM tasks").all();
         const subs = new Map();
         for (const r of rows) {
             if (r.kind !== "sub" || !r.parent_id || r.status === "cancelled")
@@ -540,7 +552,8 @@ export class TaskBoard {
             const status = r.status;
             if (status === "cancelled")
                 continue;
-            if (status === "review")
+            if (status === "review" && waitsForPerson({ status, needsReview: Number(r.needs_review) === 1,
+                dispatcher: r.dispatcher ? { kind: r.dispatcher_kind === "person" ? "person" : "instance", name: r.dispatcher } : null }, gone))
                 st.waiting++;
             if (status === "blocked")
                 st.blocked++;
@@ -565,8 +578,8 @@ export class TaskBoard {
             st.percent = st.units.total ? Math.round((st.units.done / st.units.total) * 100) : 0;
         return out;
     }
-    view(card, scope = {}) {
-        return this.views([card], scope)[0];
+    view(card, scope = {}, gone) {
+        return this.views([card], scope, gone)[0];
     }
     /** ` AND <column> NOT IN (…)` for a scope's left-out authors, with its values (empty when none). */
     notBy(scope, column) {
@@ -579,7 +592,7 @@ export class TaskBoard {
      * queries per card: a board read stays a handful of statements however many cards it has (it runs on the fleet's
      * event loop). Same answers as progress(), unmetDeps() and newComments() card by card.
      */
-    views(cards, scope = {}) {
+    views(cards, scope = {}, gone) {
         if (!cards.length)
             return [];
         const all = new Map();
@@ -618,6 +631,8 @@ export class TaskBoard {
             const c = comments.get(card.uuid);
             return {
                 id: card.code,
+                waitsForPerson: waitsForPerson(card, gone),
+                confirmer: confirmingInstance(card, gone),
                 uuid: card.uuid,
                 kind: card.kind,
                 projectId: card.projectId,
@@ -653,18 +668,28 @@ export class TaskBoard {
             };
         });
     }
-    detail(ref, scope = {}) {
+    detail(ref, scope = {}, gone) {
         const card = this.getCard(ref);
         const parent = card.parent ? this.byUuid(card.parent) : undefined;
         return {
-            card: this.view(card, scope),
+            card: this.view(card, scope, gone),
             parent: parent ? { id: parent.code, title: parent.title, status: parent.status } : null,
-            children: this.views(this.children(card.uuid), scope),
+            children: this.views(this.children(card.uuid), scope, gone),
             comments: this.entries(card.uuid, ["comment", "reject", "approve"], 200),
             logs: this.entries(card.uuid, ["log"], 200),
             history: this.events(card.uuid, 200).filter((e) => e.type !== "reordered"),
         };
     }
+    /**
+     * #2757 review: the instance dispatchers on the board that `gone` says are gone, as one string — what a cached read
+     * that names waitsForPerson / confirmer must also be keyed by (a dispatcher deleted changes them, the revision not).
+     */
+    goneDispatchers(gone) {
+        if (!gone)
+            return "";
+        const rows = this.db.prepare("SELECT DISTINCT dispatcher FROM tasks WHERE dispatcher IS NOT NULL AND (dispatcher_kind IS NULL OR dispatcher_kind != 'person')").all();
+        return rows.map((r) => r.dispatcher).filter((n) => gone(n)).sort().join("\u0000");
+    }
     /** The latest `limit` entries of a card, oldest first. */
     entries(uuid, kinds, limit = 20) {
         const rows = this.db.prepare(`SELECT * FROM task_entries WHERE task_id = ? AND kind IN (${kinds.map(() => "?").join(", ")}) ORDER BY id DESC LIMIT ?`)
@@ -1249,7 +1274,7 @@ export class TaskBoard {
                 this.checkDerivedMove(card, actor, to, reason, { comment });
             else
                 this.checkManualMove(card, actor, to, reason, { comment });
-            this.applyMove(card, actor, to, reason, comment);
+            this.applyMove(card, actor, this.ownReview(card, actor, to, reason), reason, comment);
             return { card, from, ...this.spoken() };
         });
     }
@@ -1429,6 +1454,8 @@ export class TaskBoard {
                         if (held && to !== card.status)
                             this.checkManualMove(card, actor, to, "");
                     }
+                    // #2757 review: a derived main task too; a card off the board (not held) keeps the tool's old, unchecked finish.
+                    to = this.ownReview(card, actor, to, "", held);
                 }
                 if (to !== card.status) {
                     this.applyMove(card, actor, to, "");
@@ -1447,6 +1474,21 @@ export class TaskBoard {
         });
     }
     // ── Rules ───────────────────────────────────────────────
+    /**
+     * #2080: review for an instance's own confirmation is done. An instance moving a card to review that it confirms itself
+     * (nobody else handed it out, or it handed it to itself) would wait for nobody but itself — and sat there unnoticed,
+     * in the person's Waiting for you too: it finishes instead (the checks for review are the ones for done). A person's
+     * move, and a card someone else confirms, stay as asked.
+     */
+    ownReview(card, actor, to, reason = "", check = true) {
+        if (to !== "review" || isPerson(actor) || card.status === "review" || !confirms(card, actor))
+            return to;
+        // #2757 review: finished as done is, whichever way it came (a derived main task's review checks less).
+        if (check)
+            this.checkFinish(card, true, reason);
+        this.say("own_review", [card.code], `${card.code} waits for nobody else's confirmation (you confirm it): done, not review`);
+        return "done";
+    }
     /**
      * Cards moved by hand: sub tasks, and main tasks that have no sub tasks. `comment` is the move's own comment (a
      * dispatcher's answer); `finishing`: a claim on the way to done (the `task` tool's done of an open card).
@@ -1628,6 +1670,13 @@ export class TaskBoard {
             return;
         }
         if (ai) {
+            // #2080: a main task in review by itself (its sub tasks done) is finished by the instance that confirms it.
+            if (from === "review" && to === "done" && confirms(card, actor)) {
+                if (reason)
+                    this.entry(card, "approve", actor, reason);
+                this.checkFinish(card, ai, reason);
+                return;
+            }
             if (from === "claimed" && to === "review") {
                 if (!own)
                     throw notOwner();
@@ -1921,6 +1970,10 @@ export class TaskBoard {
                 // 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);
+                // #2080: a card its own assignee confirms, in review by itself (its sub tasks done) or by someone else's move:
+                // nobody else will confirm it, so its assignee is told it is theirs.
+                if (d.to === "review" && card.assignee && confirmingInstance(card) === card.assignee)
+                    add(card, card.assignee, "confirm_own", e.actor);
                 if (d.auto) {
                     if (d.to === "review" && card.kind === "main" && wrapUpGap(card))
                         add(card, card.assignee, "wrap_up", e.actor);
@@ -1980,6 +2033,8 @@ export class TaskBoard {
                 return handedOut && card.status === "review" && requiresReview(card);
             if (!own)
                 return false;
+            if (r === "confirm_own")
+                return card.status === "review" && confirmingInstance(card) === wake.instance;
             if (r === "wrap_up")
                 return card.status === "review" && wrapUpGap(card) !== null;
             if (r === "assigned")