@wirecat/cli-core 0.511.0 → 0.513.0

package/dist/store/sqlite/work-tasks.js

@@ -1,11 +1,15 @@
 import { CliError } from "@wirecat/cli-base";
 import { TASK_TYPES, WORK_TASK_TYPES } from "../../domain/knowledge.js";
-import { TASK_STATES } from "../../tasks/index.js";
+import { checkedScore, isClosedState, legacyPriority, PRIORITY_LABELS, priorityBand, priorityLabel, TASK_STATES, } from "../../tasks/index.js";
 import { folded } from "./folded.js";
 import { authorActor } from "./memories.js";
+import { CORPORA, drainCorpus } from "./note-index.js";
 import { requiredThing } from "./notes.js";
+import { queryFilter } from "./query-filter.js";
+import { stemmerCache } from "./stems.js";
+import { BOARD_SCOPE, boardOrder, projectTaskColumns, withoutField } from "./task-board.js";
 import { closeSuggestionOf, SUGGESTION_COLUMNS } from "./task-close.js";
-import { inboxKey } from "./task-keys.js";
+import { INBOX_KEY_LENGTH, inboxKey } from "./task-keys.js";
 import { taskRelationsStoreOver } from "./task-relations.js";
 import { taskIdOf, taskRowOf, thingOf } from "./things.js";
 import { write } from "./transaction.js";
@@ -24,6 +28,14 @@ export const TASK_EVENT_KINDS = [
     "unlinked",
     "category",
     "close-suggestion",
+    "agent",
+    "claimed",
+    "released",
+    "next-check",
+    "resolution",
+    "verdict",
+    "close-certainty",
+    "tags",
 ];
 const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
 export const recordTaskEvent = (database, task, actor, kind, changes, at) => {
@@ -41,10 +53,11 @@ const textOf = (value, what, max) => {
 const claimOf = (row, at) => row.claimed_by != null && Number(row.claimed_until) >= at
     ? { claimedBy: String(row.claimed_by), claimedUntil: iso(row.claimed_until) }
     : { claimedBy: null, claimedUntil: null };
-const priorityOf = (value) => {
-    if (value !== null && !(Number.isInteger(value) && value >= 0 && value <= 4))
-        throw new CliError("validation_error", "a priority is 0 (urgent) to 4 (low)");
-    return value;
+/** What a write made on a stale copy is refused with: the revision the caller read is not the task's now. */
+export const checkRevision = (row, expected) => {
+    if (expected === undefined || Number(row.revision) === expected)
+        return;
+    throw new CliError("configuration_error", `task ${String(row.key)} changed since revision ${expected}; it is at ${String(row.revision)}: read it again`, { reason: "task.stale", revision: Number(row.revision) });
 };
 export const workTaskOperationsOver = (context) => {
     const { database, now } = context;
@@ -100,7 +113,10 @@ export const workTaskOperationsOver = (context) => {
             description: row.description == null ? null : String(row.description),
             type: row.type,
             status: row.status,
-            priority: row.priority == null ? null : Number(row.priority),
+            priority: row.priority_score == null ? null : Number(row.priority_score),
+            priorityLabel: priorityLabel(row.priority_score == null ? null : Number(row.priority_score)),
+            agent: row.agent == null ? null : String(row.agent),
+            revision: Number(row.revision),
             parent: row.parent_id == null ? null : reference(Number(row.parent_id)),
             source: row.source_locator == null ? null : String(row.source_locator),
             dueAt: iso(row.due_at),
@@ -120,6 +136,19 @@ export const workTaskOperationsOver = (context) => {
             updatedAt: iso(row.updated_at),
         };
     };
+    const stemmerFor = stemmerCache();
+    const touch = (task, at) => database.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?").run(at, task);
+    const boardWhere = (query, zone, at) => {
+        if (query === undefined)
+            return { sql: BOARD_SCOPE, params: [] };
+        const where = queryFilter(query, projectTaskColumns(at), {
+            command: "tasks list",
+            now: at,
+            ...(zone ? { zone } : {}),
+        });
+        return { sql: `${BOARD_SCOPE} AND (${where.sql})`, params: where.params };
+    };
+    const countOf = (where) => Number(database.prepare(`SELECT count(*) AS n FROM tasks t WHERE ${where.sql}`).get(...where.params)?.n ?? 0);
     const rowById = (id) => database.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
     const details = (id) => detailsOf(rowById(id));
     const edit = (task, fields, actor, created = false) => {
@@ -127,13 +156,13 @@ export const workTaskOperationsOver = (context) => {
         const at = now();
         const set = [];
         const values = [];
-        const change = (column, value, event) => {
+        const change = (column, value, event, key = column) => {
             if ((before[column] ?? null) === value)
                 return;
             set.push(`${column} = ?`);
             values.push(value);
             if (event)
-                recordTaskEvent(database, task, actor, event, { [column]: [before[column] ?? null, value] }, at);
+                recordTaskEvent(database, task, actor, event, { [key]: [before[column] ?? null, value] }, at);
         };
         if (fields.title !== undefined) {
             const title = textOf(fields.title, "a task's title", 300);
@@ -142,24 +171,37 @@ export const workTaskOperationsOver = (context) => {
         }
         if (fields.description !== undefined)
             change("description", fields.description === null ? null : textOf(fields.description, "a description", 20000), created ? undefined : "description");
-        if (fields.priority !== undefined)
-            change("priority", priorityOf(fields.priority), "priority");
+        if (fields.priority !== undefined) {
+            const score = fields.priority === null ? null : checkedScore(fields.priority);
+            change("priority_score", score, "priority", "priority");
+            change("priority", legacyPriority(score));
+        }
+        if (fields.agent !== undefined)
+            change("agent", fields.agent === null ? null : textOf(fields.agent, "an agent's name", 100), "agent");
         if (fields.parent !== undefined)
             change("parent_id", fields.parent === null ? null : parentOf(task, Number(before.project_id), fields.parent));
         if (fields.dueAt !== undefined)
             change("due_at", fields.dueAt === null ? null : fields.dueAt.getTime(), "due");
-        // Moved on every look, so no event: the history would be mostly check-ins.
         if (fields.nextCheckAt !== undefined)
-            change("next_check_at", fields.nextCheckAt === null ? null : fields.nextCheckAt.getTime());
+            change("next_check_at", fields.nextCheckAt === null ? null : fields.nextCheckAt.getTime(), "next-check");
         if (fields.status !== undefined) {
             if (!TASK_STATES.includes(fields.status))
                 throw new CliError("validation_error", `a task's status is one of ${TASK_STATES.join(", ")}`);
-            const closed = fields.status !== "open";
+            if ((fields.status === "todo" || fields.status === "in_progress") &&
+                String(database.prepare("SELECT key FROM projects WHERE id = ?").get(Number(before.project_id))?.key).length ===
+                    INBOX_KEY_LENGTH)
+                throw new CliError("validation_error", "a task from a message is open, done or dismissed; todo and in_progress are for a project task");
+            const closed = isClosedState(fields.status);
+            const reopened = !closed && isClosedState(String(before.status));
             if (before.status !== fields.status) {
                 change("status", fields.status, "status");
-                change("closed_at", closed ? at : null);
-                change("closed_by_type", closed ? actor.type : null);
-                change("closed_by_id", closed ? actor.id : null);
+                if (fields.status === "in_progress" && before.started_at == null)
+                    change("started_at", at);
+                if (closed || reopened) {
+                    change("closed_at", closed ? at : null);
+                    change("closed_by_type", closed ? actor.type : null);
+                    change("closed_by_id", closed ? actor.id : null);
+                }
                 if (closed) {
                     change("claimed_by", null);
                     change("claimed_until", null);
@@ -168,6 +210,11 @@ export const workTaskOperationsOver = (context) => {
                 }
                 else
                     change("close_certainty", null);
+                // Why it was closed no longer holds once it is open again.
+                if (reopened && fields.reason === undefined) {
+                    change("close_reason", null);
+                    change("close_reason_folded", null);
+                }
             }
         }
         if (fields.reason !== undefined) {
@@ -181,6 +228,67 @@ export const workTaskOperationsOver = (context) => {
             return;
         database.prepare(`UPDATE tasks SET ${set.join(", ")}, updated_at = ? WHERE id = ?`).run(...values, at, task);
     };
+    /** The column's tasks in board order, the moving one left out; no priority reads as 0, the bottom of low. */
+    const columnOf = (task, status) => database
+        .prepare(`SELECT t.id, t.key, coalesce(t.priority_score, 0) AS score FROM tasks t WHERE ${BOARD_SCOPE} ` +
+        `AND t.status = ? AND t.id <> ? ORDER BY ${boardOrder("priority", false)}`)
+        .all(status, task)
+        .map((row) => ({ id: Number(row.id), key: String(row.key), score: Number(row.score) }));
+    const moveTask = (task, row, move, actor) => {
+        if (move.before !== undefined && move.after !== undefined)
+            throw new CliError("validation_error", "give --before or --after, not both");
+        if (!database.prepare(`SELECT 1 FROM tasks t WHERE t.id = ? AND ${BOARD_SCOPE}`).get(task))
+            throw new CliError("validation_error", "only a project task moves on the board");
+        const status = move.status ?? row.status;
+        const column = columnOf(task, status);
+        const neighbour = move.before ?? move.after;
+        if (neighbour === undefined) {
+            if (column.length > 0 || move.status === undefined)
+                throw new CliError("validation_error", "say where it goes: --before <key> or --after <key>");
+            const from = priorityLabel(row.priority_score == null ? null : Number(row.priority_score));
+            edit(task, { status: move.status }, actor);
+            return { label: { from, to: from, changed: false }, renumbered: [] };
+        }
+        const target = required(neighbour);
+        const at = column.findIndex(({ id }) => id === target);
+        if (at === -1)
+            throw new CliError("validation_error", `${move.before ?? move.after} is not a ${status} task of a project; a task moves beside one in its column`);
+        const index = move.before === undefined ? at + 1 : at;
+        const above = column[index - 1];
+        const below = column[index];
+        const STEP = 1 / 64;
+        const score = above === undefined
+            ? Math.min(1, (below?.score ?? 0) + STEP)
+            : below === undefined
+                ? Math.max(0, above.score - STEP)
+                : (above.score + below.score) / 2;
+        const roomy = (above === undefined || score < above.score) && (below === undefined || score > below.score);
+        const from = priorityLabel(row.priority_score == null ? null : Number(row.priority_score));
+        const renumbered = [];
+        let given = score;
+        if (!roomy || (above !== undefined && below !== undefined && above.score - below.score < 1e-9)) {
+            const label = priorityLabel((above ?? below)?.score ?? 0);
+            const band = priorityBand(label);
+            const inBand = (one) => priorityLabel(one.score) === label;
+            const ordered = [...column.slice(0, index), { id: task, key: String(row.key), score }, ...column.slice(index)];
+            const spread = ordered.filter((one) => one.id === task || inBand(one));
+            const gap = (band.to - band.from) / (spread.length + 1);
+            spread.forEach((one, place) => {
+                const value = band.to - gap * (place + 1);
+                if (one.id === task) {
+                    given = value;
+                    return;
+                }
+                if (one.score === value)
+                    return;
+                edit(one.id, { priority: value }, actor);
+                renumbered.push(one.key);
+            });
+        }
+        edit(task, { priority: given, ...(move.status === undefined ? {} : { status: move.status }) }, actor);
+        const to = priorityLabel(given);
+        return { label: { from, to, changed: from !== to }, renumbered };
+    };
     return {
         ...taskRelationsStoreOver(context, (task, actor, kind, changes, at) => recordTaskEvent(database, task, actor, kind, changes, at)),
         create: (input, by) => {
@@ -207,16 +315,29 @@ export const workTaskOperationsOver = (context) => {
             });
             return details(made);
         },
-        edit: async (id, fields, by) => {
+        edit: async (id, fields, by, check = {}) => {
             const task = required(id);
-            write(database, () => edit(task, fields, authorActor(context, by).actor));
+            write(database, () => {
+                checkRevision(rowById(task), check.revision);
+                edit(task, fields, authorActor(context, by).actor);
+            });
             return details(task);
         },
-        assign: (id, { to, role }, by) => {
+        move: async (id, move, by, check = {}) => {
+            const task = required(id);
+            return write(database, () => {
+                const row = rowById(task);
+                checkRevision(row, check.revision);
+                const moved = moveTask(task, row, move, authorActor(context, by).actor);
+                return { ...moved, task: details(task) };
+            });
+        },
+        assign: (id, { to, role }, by, check = {}) => {
             if (!TASK_ROLES.includes(role))
                 throw new CliError("validation_error", `a role is one of ${TASK_ROLES.join(", ")}`);
             const task = required(id);
             write(database, () => {
+                checkRevision(rowById(task), check.revision);
                 const person = personOf(to);
                 const held = database
                     .prepare("SELECT 1 FROM task_assignments WHERE task_id = ? AND assignee_type = 'person' AND assignee_id = ? AND role = ?")
@@ -227,6 +348,7 @@ export const workTaskOperationsOver = (context) => {
                 database
                     .prepare("INSERT INTO task_assignments (task_id, assignee_type, assignee_id, role, created_at, updated_at) VALUES (?, 'person', ?, ?, ?, ?)")
                     .run(task, person, role, at, at);
+                touch(task, at);
                 const changes = { [role]: [null, `person:${person}`] };
                 recordTaskEvent(database, task, authorActor(context, by).actor, "assigned", changes, at);
             });
@@ -253,17 +375,20 @@ export const workTaskOperationsOver = (context) => {
                 .get(thing.id);
             return row ? `person:${String(row.id)}` : undefined;
         },
-        unassign: async (id, { to, role }, by) => {
+        unassign: async (id, { to, role }, by, check = {}) => {
             const task = required(id);
             write(database, () => {
+                checkRevision(rowById(task), check.revision);
                 const person = personOf(to);
                 const removed = database
                     .prepare("DELETE FROM task_assignments WHERE task_id = ? AND assignee_type = 'person' AND assignee_id = ? AND role = ?")
                     .run(task, person, role).changes;
                 if (removed === 0)
                     return;
+                const at = now();
+                touch(task, at);
                 const changes = { [role]: [`person:${person}`, null] };
-                recordTaskEvent(database, task, authorActor(context, by).actor, "unassigned", changes, now());
+                recordTaskEvent(database, task, authorActor(context, by).actor, "unassigned", changes, at);
             });
             return details(task);
         },
@@ -287,20 +412,26 @@ export const workTaskOperationsOver = (context) => {
                 .prepare("SELECT * FROM tasks t WHERE deleted_at IS NULL AND (? IS NULL OR project_id = ?) AND (? IS NULL OR type = ?) " +
                 "AND (? IS NULL OR status = ?) AND (? IS NULL OR EXISTS (SELECT 1 FROM task_assignments a " +
                 "WHERE a.task_id = t.id AND a.assignee_type = 'person' AND a.assignee_id = ?)) " +
-                `AND (${where?.sql || "1"}) ORDER BY coalesce(priority, 5), created_at, id LIMIT ?`)
+                `AND (${where?.sql || "1"}) ORDER BY priority_score IS NULL, priority_score DESC, created_at, id LIMIT ?`)
                 .all(projectId, projectId, type ?? null, type ?? null, status ?? null, status ?? null, person, person, ...(where?.params ?? []), Math.min(Math.max(limit, 1), 500))
                 .map(detailsOf);
         },
         claim: async (id, holder, until) => {
             const task = required(id);
             const at = now();
-            const won = write(database, () => database
-                .prepare("UPDATE tasks SET claimed_by = ?, claimed_until = ?, updated_at = ? " +
-                "WHERE id = ? AND status = 'open' AND (claimed_by IS NULL OR claimed_until < ? OR claimed_by = ?) RETURNING id")
-                .get(holder, until.getTime(), at, task, at, holder));
+            const won = write(database, () => {
+                const before = claimOf(rowById(task), at).claimedBy;
+                const claimed = database
+                    .prepare("UPDATE tasks SET claimed_by = ?, claimed_until = ?, updated_at = ? " +
+                    "WHERE id = ? AND status NOT IN ('done', 'dismissed') AND (claimed_by IS NULL OR claimed_until < ? OR claimed_by = ?) RETURNING id")
+                    .get(holder, until.getTime(), at, task, at, holder);
+                if (claimed)
+                    recordTaskEvent(database, task, null, "claimed", { claimed_by: [before, holder] }, at);
+                return claimed;
+            });
             if (!won) {
                 const row = rowById(task);
-                if (row.status !== "open")
+                if (isClosedState(String(row.status)))
                     throw new CliError("validation_error", `task ${String(row.key)} is ${String(row.status)}; only an open task is claimed`);
                 throw new CliError("validation_error", `${String(row.claimed_by)} holds task ${String(row.key)} until ${iso(row.claimed_until)}; ` +
                     "wait for it, or ask them to release it", { reason: "task.claimed", holder: String(row.claimed_by), until: iso(row.claimed_until) });
@@ -316,18 +447,91 @@ export const workTaskOperationsOver = (context) => {
                     throw new CliError("validation_error", `${claimedBy} holds task ${String(row.key)}; only they or the owner release it`, {
                         reason: "task.claimed",
                     });
+                const at = now();
                 database
                     .prepare("UPDATE tasks SET claimed_by = NULL, claimed_until = NULL, updated_at = ? WHERE id = ?")
-                    .run(now(), task);
+                    .run(at, task);
+                if (claimedBy !== null)
+                    recordTaskEvent(database, task, null, "released", { claimed_by: [claimedBy, null] }, at);
             });
             return details(task);
         },
+        board: async (query, { limit, offset = 0, sort = "priority", descending = false, zone }) => {
+            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500)
+                throw new CliError("validation_error", "a page of tasks holds 1–500");
+            drainCorpus(database, CORPORA.task, stemmerFor);
+            const where = boardWhere(query, zone, now());
+            const rows = database
+                .prepare(`SELECT t.* FROM tasks t WHERE ${where.sql} ORDER BY ${boardOrder(sort, descending)} LIMIT ? OFFSET ?`)
+                .all(...where.params, limit, offset);
+            return { items: rows.map(detailsOf), total: countOf(where) };
+        },
+        boardCounts: async (query, { zone } = {}) => {
+            drainCorpus(database, CORPORA.task, stemmerFor);
+            const at = now();
+            const without = (name) => boardWhere(withoutField(query, name), zone, at);
+            const grouped = (name, select, from, group) => {
+                const where = without(name);
+                return database
+                    .prepare(`SELECT ${select}, count(*) AS n FROM tasks t ${from} WHERE ${where.sql} GROUP BY ${group}`)
+                    .all(...where.params);
+            };
+            const project = grouped("project", "p.key, p.name", "JOIN projects p ON p.id = t.project_id", "p.id")
+                .map((row) => ({ value: String(row.key), name: String(row.name), count: Number(row.n) }))
+                .sort((a, b) => a.value.localeCompare(b.value));
+            const assigned = grouped("assignee", "a.assignee_id AS person, pe.name", "LEFT JOIN task_assignments a ON a.task_id = t.id AND a.assignee_type = 'person' AND a.role = 'assignee' " +
+                "LEFT JOIN persons pe ON pe.id = a.assignee_id", "a.assignee_id");
+            const assignee = assigned
+                .map((row) => ({
+                value: row.person == null ? "none" : `person:${row.person}`,
+                name: row.name == null ? null : String(row.name),
+                count: Number(row.n),
+            }))
+                .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+            const priorities = new Map();
+            for (const row of grouped("priority", "t.priority_score", "", "t.priority_score")) {
+                const label = priorityLabel(row.priority_score == null ? null : Number(row.priority_score)) ?? "none";
+                priorities.set(label, (priorities.get(label) ?? 0) + Number(row.n));
+            }
+            const states = new Map(grouped("state", "t.status", "", "t.status").map((row) => [row.status, Number(row.n)]));
+            return {
+                total: countOf(boardWhere(query, zone, at)),
+                project,
+                assignee,
+                priority: [...[...PRIORITY_LABELS].reverse(), "none"].map((value) => ({
+                    value,
+                    count: priorities.get(value) ?? 0,
+                })),
+                state: TASK_STATES.map((value) => ({ value, count: states.get(value) ?? 0 })),
+            };
+        },
+        taskPeople: async () => database
+            .prepare("SELECT p.id, p.name, p.owner, count(DISTINCT t.id) AS n FROM persons p " +
+            "LEFT JOIN task_assignments a ON a.assignee_type = 'person' AND a.assignee_id = p.id " +
+            "LEFT JOIN tasks t ON t.id = a.task_id AND t.deleted_at IS NULL " +
+            "WHERE p.owner = 1 OR t.id IS NOT NULL GROUP BY p.id ORDER BY p.owner DESC, p.name COLLATE NOCASE, p.id")
+            .all()
+            .map((row) => ({
+            person: `person:${row.id}`,
+            name: row.name == null ? null : String(row.name),
+            owner: Number(row.owner) === 1,
+            tasks: Number(row.n),
+        })),
         events: async (id) => database
-            .prepare("SELECT actor_type, actor_id, kind, changes, created_at FROM task_events WHERE task_id = ? ORDER BY id")
+            .prepare("SELECT e.actor_type, e.actor_id, e.kind, e.changes, e.created_at, " +
+            "CASE e.actor_type WHEN 'person' THEN p.name WHEN 'bot' THEN b.name END AS actor_name FROM task_events e " +
+            "LEFT JOIN persons p ON e.actor_type = 'person' AND p.id = e.actor_id " +
+            "LEFT JOIN bots b ON e.actor_type = 'bot' AND b.id = e.actor_id WHERE e.task_id = ? ORDER BY e.id")
             .all(required(id))
             .map((row) => ({
             kind: row.kind,
-            actor: row.actor_type == null ? null : { type: row.actor_type, id: Number(row.actor_id) },
+            actor: row.actor_type == null
+                ? null
+                : {
+                    type: row.actor_type,
+                    id: Number(row.actor_id),
+                    name: row.actor_name == null ? null : String(row.actor_name),
+                },
             changes: row.changes == null ? null : JSON.parse(String(row.changes)),
             at: iso(row.created_at),
         })),
@@ -338,6 +542,6 @@ export const workTasksOver = (context) => {
     return {
         ...operations,
         create: async (input, by) => operations.create(input, by),
-        assign: async (id, assignment, by) => operations.assign(id, assignment, by),
+        assign: async (id, assignment, by, check) => operations.assign(id, assignment, by, check),
     };
 };

package/dist/tasks/index.d.ts

@@ -1,3 +1,4 @@
-export { type ClosedState, closeTask, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, type Task, type TaskKind, type TaskOrigin, type TaskState, type TaskVerdict, } from "./model.js";
+export { CLOSED_STATES, type ClosedState, closeTask, isClosedState, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, type Task, type TaskKind, type TaskOrigin, type TaskState, type TaskVerdict, } from "./model.js";
+export { checkedScore, LEGACY_PRIORITY_SCORES, legacyPriority, PRIORITY_LABELS, type PriorityLabel, priorityBand, priorityLabel, priorityOf, } from "./priority.js";
 export { type CloseOptions, createTaskService, type GroupStats, type NewTask, type TaskService, type TaskServiceOptions, } from "./service.js";
 export { matches, type TaskFilter, type TaskStore } from "./store.js";

package/dist/tasks/index.js

@@ -1,3 +1,4 @@
-export { closeTask, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, } from "./model.js";
+export { CLOSED_STATES, closeTask, isClosedState, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, } from "./model.js";
+export { checkedScore, LEGACY_PRIORITY_SCORES, legacyPriority, PRIORITY_LABELS, priorityBand, priorityLabel, priorityOf, } from "./priority.js";
 export { createTaskService, } from "./service.js";
 export { matches } from "./store.js";

package/dist/tasks/model.d.ts

@@ -1,12 +1,15 @@
 export declare const TASK_KINDS: readonly ["question", "request", "mention", "promise"];
-export declare const TASK_STATES: readonly ["open", "done", "dismissed"];
+/** `todo` and `in_progress` are steps of a project task's work; a task from a message is only ever open or closed. */
+export declare const TASK_STATES: readonly ["open", "todo", "in_progress", "done", "dismissed"];
+export declare const CLOSED_STATES: readonly ["done", "dismissed"];
 export declare const TASK_ORIGINS: readonly ["rule", "agent", "owner"];
 export declare const TASK_VERDICTS: readonly ["useful", "not_useful"];
 export type TaskKind = (typeof TASK_KINDS)[number];
 export type TaskState = (typeof TASK_STATES)[number];
 export type TaskOrigin = (typeof TASK_ORIGINS)[number];
 export type TaskVerdict = (typeof TASK_VERDICTS)[number];
-export type ClosedState = Exclude<TaskState, "open">;
+export type ClosedState = (typeof CLOSED_STATES)[number];
+export declare const isClosedState: (state: string) => state is ClosedState;
 /**
  * A task points at what it is about and never holds its text: `source` is a locator the host
  * resolves (`msg:…` for a message), so a deleted message leaves nothing behind here.

package/dist/tasks/model.js

@@ -1,10 +1,13 @@
 import { CliError } from "@wirecat/cli-base";
 export const TASK_KINDS = ["question", "request", "mention", "promise"];
-export const TASK_STATES = ["open", "done", "dismissed"];
+/** `todo` and `in_progress` are steps of a project task's work; a task from a message is only ever open or closed. */
+export const TASK_STATES = ["open", "todo", "in_progress", "done", "dismissed"];
+export const CLOSED_STATES = ["done", "dismissed"];
 export const TASK_ORIGINS = ["rule", "agent", "owner"];
 export const TASK_VERDICTS = ["useful", "not_useful"];
+export const isClosedState = (state) => CLOSED_STATES.includes(state);
 export function closeTask(task, state, by, at, reason) {
-    if (task.state !== "open")
+    if (isClosedState(task.state))
         throw new CliError("validation_error", `task ${task.id} is already ${task.state}`, { reason: "task.closed" });
     const { claimedBy: _by, claimedUntil: _until, ...unclaimed } = task;
     return { ...unclaimed, state, closedAt: at, closedBy: by, ...(reason === undefined ? {} : { reason }) };

package/dist/tasks/priority.d.ts

@@ -0,0 +1,18 @@
+/** Quarters of [0, 1], lowest first; a person reads the label, a board column is ordered by the number. */
+export declare const PRIORITY_LABELS: readonly ["low", "medium", "high", "critical"];
+export type PriorityLabel = (typeof PRIORITY_LABELS)[number];
+/** The scores of the old 0 (urgent) … 4 (low), as store version 41 converted them. */
+export declare const LEGACY_PRIORITY_SCORES: readonly [0.875, 0.625, 0.375, 0.1875, 0.0625];
+export declare const priorityLabel: (score: number | null) => PriorityLabel | null;
+export declare const priorityBand: (label: PriorityLabel) => {
+    from: number;
+    to: number;
+};
+/** The 0–4 integer a build before store version 41 reads: critical 0 … low 3, the bottom of low 4. */
+export declare const legacyPriority: (score: number | null) => number | null;
+export declare const checkedScore: (score: number) => number;
+/**
+ * A priority as typed: a label, or 0 (urgent) … 4 (low) as before, which keeps the meaning it had.
+ * `none` clears it.
+ */
+export declare const priorityOf: (value: string) => number | null;

package/dist/tasks/priority.js

@@ -0,0 +1,37 @@
+import { CliError } from "@wirecat/cli-base";
+/** Quarters of [0, 1], lowest first; a person reads the label, a board column is ordered by the number. */
+export const PRIORITY_LABELS = ["low", "medium", "high", "critical"];
+/** The number a label is given: the middle of its quarter, so a move leaves room on either side. */
+const MIDDLE = { low: 0.125, medium: 0.375, high: 0.625, critical: 0.875 };
+/** The scores of the old 0 (urgent) … 4 (low), as store version 41 converted them. */
+export const LEGACY_PRIORITY_SCORES = [0.875, 0.625, 0.375, 0.1875, 0.0625];
+export const priorityLabel = (score) => score === null ? null : PRIORITY_LABELS[Math.min(3, Math.max(0, Math.floor(score * 4)))];
+export const priorityBand = (label) => {
+    const at = PRIORITY_LABELS.indexOf(label);
+    return { from: at / 4, to: (at + 1) / 4 };
+};
+/** The 0–4 integer a build before store version 41 reads: critical 0 … low 3, the bottom of low 4. */
+export const legacyPriority = (score) => score === null
+    ? null
+    : score < 0.125
+        ? 4
+        : 3 - PRIORITY_LABELS.indexOf(priorityLabel(score));
+export const checkedScore = (score) => {
+    if (!Number.isFinite(score) || score < 0 || score > 1)
+        throw new CliError("validation_error", "a priority score is 0 to 1");
+    return score;
+};
+/**
+ * A priority as typed: a label, or 0 (urgent) … 4 (low) as before, which keeps the meaning it had.
+ * `none` clears it.
+ */
+export const priorityOf = (value) => {
+    const word = value.trim().toLowerCase();
+    if (word === "none")
+        return null;
+    if (PRIORITY_LABELS.includes(word))
+        return MIDDLE[word];
+    if (/^[0-4]$/.test(word))
+        return LEGACY_PRIORITY_SCORES[Number(word)];
+    throw new CliError("validation_error", `a priority is ${PRIORITY_LABELS.join(", ")} or none; 0 (urgent) … 4 (low) still work as critical, high, medium, low, low`);
+};

package/dist/tasks/service.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { closeTask } from "./model.js";
+import { closeTask, isClosedState } from "./model.js";
 export function createTaskService({ store, now = () => new Date(), newId = () => crypto.randomUUID(), }) {
     async function find(id) {
         const task = await store.get(id);
@@ -36,7 +36,7 @@ export function createTaskService({ store, now = () => new Date(), newId = () =>
             for (const task of await store.list(filter))
                 byGroup.set(task.group, [...(byGroup.get(task.group) ?? []), task]);
             return [...byGroup].map(([group, tasks]) => {
-                const open = tasks.filter((task) => task.state === "open");
+                const open = tasks.filter((task) => !isClosedState(task.state));
                 const closeMs = tasks.flatMap((task) => task.closedAt ? [task.closedAt.getTime() - task.createdAt.getTime()] : []);
                 const oldestOpenAt = open.map((task) => task.createdAt).sort((a, b) => a.getTime() - b.getTime())[0];
                 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.511.0",
+  "version": "0.513.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",