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

package/dist/scheduler/task-board.js

@@ -45,7 +45,8 @@ export class TaskBoardError extends Error {
 }
 const STATUS_ORDER = `CASE status WHEN 'claimed' THEN 0 WHEN 'blocked' THEN 1 WHEN 'review' THEN 2 WHEN 'open' THEN 3 WHEN 'done' THEN 4 ELSE 5 END`;
 const PRIORITY_ORDER = `CASE priority WHEN 'urgent' THEN 0 WHEN 'high' THEN 1 WHEN 'normal' THEN 2 ELSE 3 END`;
-const CODE_RE = /^\s*([MS])\s*-?\s*(\d+)\s*$/i;
+// Keep the second whitespace run inside the hyphen branch: without a hyphen, adjacent runs backtrack quadratically.
+const CODE_RE = /^\s*([MS])\s*(?:-\s*)?(\d+)\s*$/i;
 const length = (s) => [...s].length;
 const isFinished = (c) => c.status === "done" || c.status === "cancelled";
 const isPerson = (a) => a.kind === "person";
@@ -166,12 +167,26 @@ function toCard(r) {
         seenEntryId: Number(r.seen_entry_id ?? 0),
     };
 }
+/**
+ * #2352: a lead is a name, or none ("" and null alike). Whether it is one of the fleet's instances is the fleet's to
+ * check (the board keeps names, as for an assignee); a lead no longer in fleet.yaml reads as none.
+ */
+function checkLeadInstance(raw) {
+    const name = (raw ?? "").trim();
+    if (!name)
+        return null;
+    // eslint-disable-next-line no-control-regex
+    if (name.length > 256 || /[\s\u0000-\u001f\u007f]/.test(name))
+        throw new TaskBoardError("invalid", "a lead is an instance's name", "lead_not_instance");
+    return name;
+}
 function toProject(r) {
     return {
         id: Number(r.id),
         name: r.name,
         description: r.description,
         archived: Number(r.archived) === 1,
+        leadInstance: typeof r.lead_instance === "string" && r.lead_instance ? r.lead_instance : null,
         sort: Number(r.sort),
         createdAt: r.created_at,
     };
@@ -269,6 +284,17 @@ export class TaskBoard {
       CREATE INDEX IF NOT EXISTS idx_task_events_task ON task_events(task_id, id);
       CREATE TABLE IF NOT EXISTS task_counters (prefix TEXT PRIMARY KEY, next INTEGER NOT NULL);
     `);
+        // #2352: a project's lead instance, added in place (null: its waiting cards' buttons stay in General).
+        const projectCols = new Set(this.db.prepare("PRAGMA table_info(task_projects)").all().map((c) => c.name));
+        if (!projectCols.has("lead_instance")) {
+            try {
+                this.db.exec("ALTER TABLE task_projects ADD COLUMN lead_instance TEXT");
+            }
+            catch (err) {
+                if (!/duplicate column/i.test(String(err)))
+                    throw err;
+            }
+        }
         // Every open (the CLI opens this file for each command) only reads: the write lock is taken only when a counter
         // is missing or a row needs a number. (CREATE … IF NOT EXISTS of what exists takes no lock; an INSERT does.)
         if (this.db.prepare("SELECT COUNT(*) AS n FROM task_counters WHERE prefix IN ('M', 'S', 'R')").get().n < 3) {
@@ -330,8 +356,9 @@ export class TaskBoard {
             const name = this.checkProjectName(input.name, null);
             const description = checkText("the description", input.description ?? "", CARD_LIMITS.projectDescription);
             const { s } = this.db.prepare("SELECT COALESCE(MAX(sort), 0) + 1 AS s FROM task_projects").get();
-            const row = this.db.prepare("INSERT INTO task_projects (name, description, sort, created_at) VALUES (?, ?, ?, ?) RETURNING *")
-                .get(name, description, s, this.nowIso());
+            const lead = checkLeadInstance(input.leadInstance ?? null);
+            const row = this.db.prepare("INSERT INTO task_projects (name, description, sort, created_at, lead_instance) VALUES (?, ?, ?, ?, ?) RETURNING *")
+                .get(name, description, s, this.nowIso(), lead);
             this.projectsChanged = true;
             return toProject(row);
         });
@@ -346,8 +373,10 @@ export class TaskBoard {
                 project.description = checkText("the description", patch.description, CARD_LIMITS.projectDescription);
             if (patch.archived !== undefined)
                 project.archived = patch.archived;
-            this.db.prepare("UPDATE task_projects SET name = ?, description = ?, archived = ? WHERE id = ?")
-                .run(project.name, project.description, project.archived ? 1 : 0, project.id);
+            if (patch.leadInstance !== undefined)
+                project.leadInstance = checkLeadInstance(patch.leadInstance);
+            this.db.prepare("UPDATE task_projects SET name = ?, description = ?, archived = ?, lead_instance = ? WHERE id = ?")
+                .run(project.name, project.description, project.archived ? 1 : 0, project.leadInstance, project.id);
             this.projectsChanged = true;
             return project;
         });
@@ -733,6 +762,11 @@ export class TaskBoard {
      * (its own open cards, and the unassigned sub tasks of main tasks it coordinates, dependencies done) and what waits
      * on dependencies; comments it has not seen and work sent back; the main tasks it coordinates and how far along.
      */
+    /** Who holds a live card (open, in progress, blocked, waiting for the person): the instances, and any other name. */
+    liveAssignees() {
+        return this.db.prepare("SELECT DISTINCT assignee FROM tasks WHERE assignee IS NOT NULL AND status IN ('open', 'claimed', 'blocked', 'review') ORDER BY assignee").all()
+            .map((r) => r.assignee);
+    }
     myWork(name) {
         const mine = this.db.prepare(`SELECT * FROM tasks WHERE assignee = ? AND status IN ('open', 'claimed', 'blocked', 'review') ORDER BY ${STATUS_ORDER}, ${PRIORITY_ORDER}, sort`)
             .all(name).map(toCard);
@@ -766,6 +800,113 @@ export class TaskBoard {
             mains: coordinating.map((card) => ({ card, progress: this.progress(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).
+     */
+    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);
+        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 };
+        }).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). */
+    cardsByCode(codes) {
+        const out = [];
+        for (let i = 0; i < codes.length; i += 500) {
+            const chunk = codes.slice(i, i + 500);
+            out.push(...this.db.prepare(`SELECT * FROM tasks WHERE code IN (${chunk.map(() => "?").join(", ")})`).all(...chunk).map(toCard));
+        }
+        return out;
+    }
+    /**
+     * myWork() for many names in one read (the dashboard's Instances list, GET /ui/tasks/work): the live cards, every
+     * card's light row (sub tasks, dependencies) and the live cards' unseen entries, each read once — three statements
+     * however many names and cards (#2316 review: N myWork() calls cost tens of ms on the fleet's event loop). Same
+     * answers as myWork() name by name; tests/task-board-work-2316.test.ts pins both.
+     */
+    workOf(names) {
+        const out = new Map();
+        if (!names.length)
+            return out;
+        const live = this.db.prepare(`SELECT * FROM tasks WHERE status IN ('open', 'claimed', 'blocked', 'review') ORDER BY ${STATUS_ORDER}, ${PRIORITY_ORDER}, sort`).all().map(toCard);
+        const all = new Map();
+        const subs = new Map();
+        for (const r of this.db.prepare("SELECT id, code, status, depends_on, parent_id FROM tasks").all()) {
+            const light = { code: r.code ?? r.id.slice(0, 8), status: r.status, deps: parseJsonArray(r.depends_on, []), parent: r.parent_id ?? null };
+            all.set(r.id, light);
+            if (light.parent && light.status !== "cancelled") {
+                const p = subs.get(light.parent) ?? { total: 0, open: 0, claimed: 0, blocked: 0, review: 0, done: 0 };
+                p.total++;
+                p[light.status]++;
+                subs.set(light.parent, p);
+            }
+        }
+        // Unseen entries of the live cards: comments and rejections by anyone but the card's assignee, after what it saw.
+        const fresh = new Map();
+        for (const r of this.db.prepare(`SELECT e.* FROM task_entries e JOIN tasks t ON e.task_id = t.id
+       WHERE t.status IN ('open', 'claimed', 'blocked', 'review') AND e.id > t.seen_entry_id AND e.kind IN ('comment', 'reject') AND e.author IS NOT t.assignee ORDER BY e.id`).all()) {
+            const list = fresh.get(r.task_id) ?? [];
+            list.push({ id: Number(r.id), cardId: all.get(r.task_id)?.code ?? r.task_id.slice(0, 8), kind: r.kind, author: r.author,
+                authorKind: r.author_kind, text: r.text, at: r.at });
+            fresh.set(r.task_id, list);
+        }
+        /** unmetDeps(), on the light rows: own dependencies that exist and are not done, then the main task's not yet named. */
+        const unmet = (deps, parent) => {
+            const own = deps.filter((d) => { const dep = all.get(d); return !!dep && dep.status !== "done"; });
+            const main = parent ? all.get(parent) : undefined;
+            return main ? [...own, ...unmet(main.deps, main.parent).filter((d) => !own.includes(d))] : own;
+        };
+        const rank = { urgent: 0, high: 1, normal: 2 };
+        const byPriority = (a, b) => (rank[a.priority] ?? 3) - (rank[b.priority] ?? 3) || a.sort - b.sort;
+        const openUnassigned = live.filter((c) => c.assignee === null && c.status === "open");
+        for (const name of new Set(names)) {
+            const mine = live.filter((c) => c.assignee === name);
+            const coordinating = mine.filter((c) => c.kind === "main" && (subs.get(c.uuid)?.total ?? 0) > 0);
+            const work = mine.filter((c) => !coordinating.includes(c));
+            const theirs = new Set(coordinating.map((c) => c.uuid));
+            const unassigned = coordinating.length ? openUnassigned.filter((c) => c.parent !== null && theirs.has(c.parent)).sort(byPriority) : [];
+            const candidates = [...work.filter((c) => c.status === "open"), ...unassigned].map((card) => ({ card, waitsFor: unmet(card.deps, card.parent).map((d) => all.get(d).code) }));
+            const newComments = [];
+            const sentBack = [];
+            for (const card of mine) {
+                const entries = fresh.get(card.uuid) ?? [];
+                const reject = [...entries].reverse().find((e) => e.kind === "reject");
+                if (reject)
+                    sentBack.push({ card, entry: reject });
+                const comments = entries.filter((e) => e.kind === "comment");
+                if (comments.length)
+                    newComments.push({ card, entries: comments });
+            }
+            out.set(name, {
+                doing: work.filter((c) => c.status === "claimed"),
+                blocked: work.filter((c) => c.status === "blocked"),
+                review: work.filter((c) => c.status === "review"),
+                ready: candidates.filter((x) => !x.waitsFor.length).map((x) => x.card),
+                waiting: candidates.filter((x) => x.waitsFor.length),
+                newComments,
+                sentBack,
+                mains: coordinating.map((card) => ({ card, progress: { ...subs.get(card.uuid) } })),
+            });
+        }
+        return out;
+    }
+    /**
+     * 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) {
+        const between = (sql) => this.db.prepare(sql).all(since, until).map(toCard);
+        return {
+            waiting: this.waitingForPerson().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()
+                .map((r) => ({ projectId: r.project_id ?? null, assignee: r.assignee ?? null })),
+        };
+    }
     // ── Writing: the board ──────────────────────────────────
     createCards(actor, input) {
         if (input.cards.length === 0)
@@ -1683,6 +1824,9 @@ export class TaskBoard {
                     add(card, card.assignee, "cancelled", e.actor, why);
                     continue;
                 }
+                // Its dispatcher tells the person it waits for them (not the board).
+                if (d.to === "review" && !isPerson(e.actor) && requiresReview(card))
+                    add(card, dispatcherOf(), "to_confirm", e.actor);
                 if (d.auto) {
                     if (d.to === "review" && card.kind === "main" && wrapUpGap(card))
                         add(card, card.assignee, "wrap_up", e.actor);
@@ -1737,6 +1881,9 @@ export class TaskBoard {
                 return false;
             if (r === "decide")
                 return handedOut && card.status === "blocked";
+            // #2341 review: and still waiting for the person — its confirmation not switched off during the gather.
+            if (r === "to_confirm")
+                return handedOut && card.status === "review" && requiresReview(card);
             if (!own)
                 return false;
             if (r === "wrap_up")