@wirecat/cli-core 0.511.0 → 0.513.0

package/dist/store/sqlite/task-board.js

@@ -0,0 +1,192 @@
+import { CliError } from "@wirecat/cli-base";
+import { OPERATORS_BY_TYPE, walkQuery, } from "@wirecat/cli-base/query";
+import { TASK_TYPES } from "../../domain/knowledge.js";
+import { taskWordsOf } from "../../search/task-similarity.js";
+import { PRIORITY_LABELS, priorityBand, TASK_STATES } from "../../tasks/index.js";
+import { INBOX_KEY_LENGTH } from "./task-keys.js";
+export const TASK_SORTS = ["priority", "due", "created", "updated", "key", "state"];
+const field = (name, type, example, more = {}) => ({
+    name,
+    type,
+    operators: OPERATORS_BY_TYPE[type],
+    example,
+    ...more,
+});
+/** The query language of the owner's project tasks, every project at once; `text` takes the bare words. */
+export const PROJECT_TASK_FIELDS = [
+    field("state", "enum", "state:todo", { values: TASK_STATES }),
+    field("kind", "enum", "kind:bug", { values: TASK_TYPES }),
+    field("project", "kw", "project:HRB", {
+        relation: "a project by its key or project:<id>; project:* is every project, and lists project tasks only",
+    }),
+    field("assignee", "kw", 'assignee:"person:12"', {
+        relation: "who does it: any, none, or a person (person:12 in quotes, or the bare 12)",
+    }),
+    field("priority", "kw", "priority:high", {
+        operators: ["term", "range", "wildcard"],
+        relation: "low, medium, high, critical or none; a range of labels or of the 0–1 number: priority:[high TO critical]",
+    }),
+    field("agent", "kw", "agent:hermes", { relation: "the agent working on it, by name; none or any" }),
+    field("due", "time", "due:[today TO 2026-12-31]", { relation: "the due date; NOT due:* has none" }),
+    field("overdue", "bool", "overdue:true", { relation: "open work whose due date has passed" }),
+    field("closed", "time", "closed:>=14d", { relation: "when it was done or dismissed" }),
+    field("ready", "bool", "ready:true", { relation: "open work whose blocked-by tasks are all done" }),
+    field("text", "txt", "text:invoice", { relation: "words of the title and description; a bare word means this" }),
+];
+const OPEN = "t.status NOT IN ('done', 'dismissed')";
+const OWNER_PROJECTS = `SELECT id FROM projects WHERE deleted_at IS NULL AND length(key) <> ${INBOX_KEY_LENGTH}`;
+const ASSIGNED = "SELECT 1 FROM task_assignments a WHERE a.task_id = t.id AND a.assignee_type = 'person' AND a.role = 'assignee'";
+/** A `blocked-by` task that is not done holds the task back; so does one deleted or out of reach. */
+export const UNFINISHED_BLOCKER = "SELECT 1 FROM links l LEFT JOIN tasks b ON b.id = l.to_id LEFT JOIN projects bp ON bp.id = b.project_id " +
+    "WHERE l.from_type = 'task' AND l.to_type = 'task' AND l.kind = 'blocked-by' AND l.from_id = t.id AND l.confirmed = 1 " +
+    "AND l.anchor IS NULL AND (b.id IS NULL OR b.deleted_at IS NOT NULL OR bp.deleted_at IS NOT NULL OR b.status <> 'done')";
+/** Every word a prefix, all of them required; a quoted phrase as one. `undefined` when nothing in it is a word. */
+const wordsMatch = (node) => {
+    const words = taskWordsOf(node.value.replaceAll("*", " "))
+        .split(/\s+/)
+        .filter((word) => /[\p{L}\p{N}]/u.test(word));
+    if (words.length === 0)
+        return undefined;
+    const quoted = (text) => `"${text.replaceAll('"', '""')}"`;
+    return `normalized_text : (${node.operator === "phrase" ? quoted(words.join(" ")) : words.map((word) => `${quoted(word)}*`).join(" AND ")})`;
+};
+const projectWhere = (node) => {
+    if (node.operator === "wildcard" && node.value === "*")
+        return { sql: "1", params: [] };
+    const id = /^project:(\d+)$/.exec(node.value.trim())?.[1];
+    if (id !== undefined)
+        return { sql: "t.project_id = ?", params: [Number(id)] };
+    const key = node.value.trim().toUpperCase();
+    return {
+        sql: `t.project_id IN (SELECT id FROM projects WHERE key ${node.operator === "wildcard" ? "GLOB" : "="} ?)`,
+        params: [key],
+    };
+};
+const assigneeWhere = (node) => {
+    const value = node.value.trim().toLowerCase();
+    if (value === "any" || (node.operator === "wildcard" && value === "*"))
+        return { sql: `EXISTS (${ASSIGNED})`, params: [] };
+    if (value === "none")
+        return { sql: `NOT EXISTS (${ASSIGNED})`, params: [] };
+    const id = /^(?:person:)?(\d+)$/.exec(value)?.[1];
+    if (id === undefined)
+        throw new CliError("validation_error", `assignee: takes any, none or "person:<id>", not "${node.value}"`);
+    return { sql: `EXISTS (${ASSIGNED} AND a.assignee_id = ?)`, params: [Number(id)] };
+};
+const bound = (value, side, node) => {
+    const word = value.trim().toLowerCase();
+    if (word === "*")
+        return undefined;
+    if (PRIORITY_LABELS.includes(word))
+        return priorityBand(word)[side];
+    const number = Number(word);
+    if (word === "" || !Number.isFinite(number) || number < 0 || number > 1)
+        throw new CliError("validation_error", `priority: takes ${PRIORITY_LABELS.join(", ")}, none, or 0 to 1, not "${node.value}"`);
+    return number;
+};
+/** A label is its quarter; critical takes 1 itself. */
+const priorityWhere = (node) => {
+    const score = "t.priority_score";
+    if (node.operator === "wildcard") {
+        if (node.value === "*")
+            return { sql: `${score} IS NOT NULL`, params: [] };
+        throw new CliError("validation_error", "priority: takes a label, none, or a range");
+    }
+    if (node.operator !== "range") {
+        const word = node.value.trim().toLowerCase();
+        if (word === "none")
+            return { sql: `${score} IS NULL`, params: [] };
+        if (!PRIORITY_LABELS.includes(word))
+            throw new CliError("validation_error", `priority: takes ${PRIORITY_LABELS.join(", ")} or none; a number goes in a range`);
+        const { from, to } = priorityBand(word);
+        return { sql: `${score} >= ? AND ${score} ${to === 1 ? "<=" : "<"} ?`, params: [from, to] };
+    }
+    const lower = bound(node.value, "from", node);
+    const upperWord = (node.upper ?? "*").trim().toLowerCase();
+    const upper = bound(upperWord, "to", node);
+    const labelUpper = PRIORITY_LABELS.includes(upperWord);
+    const parts = [`${score} IS NOT NULL`];
+    const params = [];
+    if (lower !== undefined) {
+        parts.push(`${score} ${node.lower_inclusive === false ? ">" : ">="} ?`);
+        params.push(lower);
+    }
+    if (upper !== undefined) {
+        parts.push(`${score} ${labelUpper ? (upper === 1 ? "<=" : "<") : node.upper_inclusive === false ? "<" : "<="} ?`);
+        params.push(upper);
+    }
+    return { sql: parts.join(" AND "), params };
+};
+const agentWhere = (node) => {
+    const value = node.value.trim().toLowerCase();
+    if (value === "none")
+        return { sql: "t.agent IS NULL", params: [] };
+    if (value === "any" || (node.operator === "wildcard" && value === "*"))
+        return { sql: "t.agent IS NOT NULL", params: [] };
+    return node.operator === "wildcard"
+        ? { sql: "lower(t.agent) GLOB ?", params: [value] }
+        : { sql: "lower(t.agent) = ?", params: [value] };
+};
+const truth = (node, sql) => ({
+    sql: node.value.toLowerCase() === "true" ? sql : `NOT (${sql})`,
+    params: [],
+});
+/** `now` is when overdue is measured; one value per answer, so the list and its counts agree. */
+export const projectTaskColumns = (now) => ({
+    state: { type: "enum", sql: "t.status" },
+    kind: { type: "enum", sql: "t.type" },
+    project: { where: projectWhere },
+    assignee: { where: assigneeWhere },
+    priority: { where: priorityWhere },
+    agent: { where: agentWhere },
+    due: { type: "time", sql: "t.due_at" },
+    closed: { type: "time", sql: "t.closed_at" },
+    overdue: { where: (node) => truth(node, `${OPEN} AND t.due_at IS NOT NULL AND t.due_at < ${Number(now)}`) },
+    ready: { where: (node) => truth(node, `${OPEN} AND NOT EXISTS (${UNFINISHED_BLOCKER})`) },
+    text: {
+        where: (node) => {
+            const match = wordsMatch(node);
+            const byKey = { sql: "t.key = ?", params: [node.value.trim().toUpperCase()] };
+            if (match === undefined)
+                return byKey;
+            return {
+                sql: `(t.id IN (SELECT rowid FROM task_words WHERE task_words MATCH ?) OR ${byKey.sql})`,
+                params: [match, ...byKey.params],
+            };
+        },
+    },
+});
+/** Live tasks of the owner's projects; an account's inbox is listed by its account, never here. */
+export const BOARD_SCOPE = `t.deleted_at IS NULL AND t.project_id IN (${OWNER_PROJECTS})`;
+const STATE_ORDER = `CASE t.status ${TASK_STATES.map((state, at) => `WHEN '${state}' THEN ${at}`).join(" ")} END`;
+/** The chosen order first, then priority, age and id, so a page boundary never splits a tie. */
+export const boardOrder = (sort, descending) => {
+    const direction = descending ? "DESC" : "ASC";
+    const first = {
+        priority: ["t.priority_score IS NULL", `t.priority_score ${descending ? "ASC" : "DESC"}`],
+        due: ["t.due_at IS NULL", `t.due_at ${direction}`],
+        created: [`t.created_at ${direction}`],
+        updated: [`t.updated_at ${direction}`],
+        key: [`(SELECT key FROM projects WHERE id = t.project_id) ${direction}`, `t.number ${direction}`],
+        state: [`${STATE_ORDER} ${direction}`],
+    }[sort];
+    return [...first, "t.priority_score IS NULL", "t.priority_score DESC", "t.created_at", "t.id"].join(", ");
+};
+/** The query without its required terms on `name`: a picker counts the choices its own filter hides. */
+export const withoutField = (query, name) => {
+    if (query === undefined)
+        return undefined;
+    const strip = (node) => {
+        if (walkQuery(node).every((leaf) => leaf.field === name))
+            return undefined;
+        if (node.kind === "predicate" || node.clauses.some((clause) => clause.occur === "should"))
+            return node;
+        const clauses = node.clauses.flatMap((clause) => {
+            const kept = strip(clause.node);
+            return kept === undefined ? [] : [{ ...clause, node: kept }];
+        });
+        return clauses.length === 0 ? undefined : { ...node, clauses };
+    };
+    const root = strip(query.root);
+    return root === undefined ? undefined : { ...query, root };
+};

package/dist/store/sqlite/task-candidates.js

@@ -173,7 +173,7 @@ export const taskSimilarityOver = (context) => {
             drainCorpus(database, CORPORA.task, stemmerFor);
             const stemmer = stemmerFor(storeStemmers(database) ?? DEFAULT_STEMMERS);
             const since = now() - RECENTLY_CLOSED_MS;
-            const live = "t.project_id = ? AND t.deleted_at IS NULL AND t.id <> ? AND (t.status = 'open' OR t.closed_at >= ?)";
+            const live = "t.project_id = ? AND t.deleted_at IS NULL AND t.id <> ? AND (t.status NOT IN ('done', 'dismissed') OR t.closed_at >= ?)";
             const scope = [side.project, side.row ?? -1, since];
             const found = new Map();
             const add = (id, by) => found.set(id, (found.get(id) ?? new Set()).add(by));

package/dist/store/sqlite/task-category-settings.js

@@ -11,7 +11,7 @@ export const storeTaskCategories = (database) => savedTaskCategories(database) ?
 export const unlistedTaskCategories = (database, list) => {
     const listed = new Set(list.map(({ name }) => name));
     return database
-        .prepare("SELECT category, COUNT(*) AS total, SUM(status = 'open') AS open FROM tasks " +
+        .prepare("SELECT category, COUNT(*) AS total, SUM(status NOT IN ('done', 'dismissed')) AS open FROM tasks " +
         "WHERE category IS NOT NULL AND deleted_at IS NULL GROUP BY category ORDER BY category")
         .all()
         .map((row) => ({ name: String(row.category), open: Number(row.open), total: Number(row.total) }))

package/dist/store/sqlite/task-close-store.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { isClosedState } from "../../tasks/index.js";
 import { authorActor } from "./memories.js";
 import { CLEAR_SUGGESTION, certaintyOf, closeSuggestionOf, saveAgentClose, storeAgentClose, } from "./task-close.js";
 import { DEFAULT_FIRST_PASS_PER_CHAT, savedFirstPassPerChat, saveFirstPassPerChat } from "./task-first-pass.js";
@@ -24,7 +25,7 @@ export const taskCloseOver = (context) => {
         closeSuggestion: async (id) => closeSuggestionOf(database, liveRow(id)),
         suggestClose: async (id, suggestion, by) => write(database, () => {
             const row = liveRow(id);
-            if (row.status !== "open")
+            if (isClosedState(String(row.status)))
                 throw new CliError("validation_error", `task ${String(row.key)} is already ${String(row.status)}`, {
                     reason: "task.closed",
                 });
@@ -51,9 +52,10 @@ export const taskCloseOver = (context) => {
         }),
         recordCloseCertainty: async (id, certainty) => write(database, () => {
             const row = liveRow(id);
-            database
-                .prepare("UPDATE tasks SET close_certainty = ? WHERE id = ?")
-                .run(certaintyOf(certainty), Number(row.id));
+            const value = certaintyOf(certainty);
+            database.prepare("UPDATE tasks SET close_certainty = ? WHERE id = ?").run(value, Number(row.id));
+            if ((row.close_certainty ?? null) !== value)
+                recordTaskEvent(database, Number(row.id), null, "close-certainty", { close_certainty: [row.close_certainty ?? null, value] }, now());
         }),
     };
 };

package/dist/store/sqlite/task-pairs.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { isClosedState } from "../../tasks/index.js";
 import { folded } from "./folded.js";
 import { linkKind } from "./link-kinds.js";
 import { authorActor } from "./memories.js";
@@ -134,7 +135,7 @@ export const taskPairsOver = (context, similarity) => {
     };
     const followUp = async (row, candidates, by) => write(database, () => {
         for (const one of candidates) {
-            if (one.status === "open" || one.band === "different")
+            if (!isClosedState(one.status) || one.band === "different")
                 continue;
             const closed = required(one.key);
             if (mergedInto(closed))
@@ -157,7 +158,7 @@ export const taskPairsOver = (context, similarity) => {
             const alike = (await similarity.similar({ task: String(row.key) }, { limit: 40 })).filter((one) => one.band !== "different");
             if (!linked)
                 await followUp(row, alike, { bot: "rule" });
-            const found = linked ? alike : alike.filter((one) => one.status === "open");
+            const found = linked ? alike : alike.filter((one) => !isClosedState(one.status));
             if (found.length === 0)
                 return 0;
             return write(database, () => {
@@ -216,7 +217,7 @@ export const taskPairsOver = (context, similarity) => {
             const a = required(dup);
             const b = required(into);
             sameInbox(a, b);
-            if (a.status !== "open")
+            if (isClosedState(String(a.status)))
                 throw new CliError("validation_error", `task ${String(a.key)} is already ${String(a.status)}; a merge closes an open task — reopen it with tasks unmerge if a merge closed it`, { reason: "task.closed" });
             const onward = mergedInto(b);
             if (onward)

package/dist/store/sqlite/task-relations.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { isClosedState } from "../../tasks/index.js";
 import { authorActor } from "./memories.js";
 import { taskIdOf, taskRowOf } from "./things.js";
 import { read, write } from "./transaction.js";
@@ -138,7 +139,7 @@ export const taskRelationsStoreOver = (context, record) => {
                         ? "dismissed"
                         : "open",
             }));
-            return { ready: liveTask(database, rowId).status === "open" && blockers.length === 0, blockers };
+            return { ready: !isClosedState(String(liveTask(database, rowId).status)) && blockers.length === 0, blockers };
         }),
         readyTasks: async (project, options = {}) => read(database, () => {
             const limit = options.limit ?? 50;
@@ -154,7 +155,7 @@ export const taskRelationsStoreOver = (context, record) => {
             if (!row)
                 throw new CliError("not_found", "the owner project is unavailable");
             const rows = database
-                .prepare("SELECT coalesce(t.package_id,t.key) AS id,t.key,substr(t.title,1,300) AS title FROM tasks t WHERE t.project_id=? AND t.status='open' AND t.deleted_at IS NULL AND NOT EXISTS (SELECT 1 FROM links l LEFT JOIN tasks b ON b.id=l.to_id LEFT JOIN projects p ON p.id=b.project_id WHERE l.from_type='task' AND l.to_type='task' AND l.kind='blocked-by' AND l.from_id=t.id AND l.confirmed=1 AND l.anchor IS NULL AND (b.id IS NULL OR b.deleted_at IS NOT NULL OR p.deleted_at IS NOT NULL OR b.status!='done')) ORDER BY coalesce(t.priority,5),t.number,t.id LIMIT ?")
+                .prepare("SELECT coalesce(t.package_id,t.key) AS id,t.key,substr(t.title,1,300) AS title FROM tasks t WHERE t.project_id=? AND t.status NOT IN ('done','dismissed') AND t.deleted_at IS NULL AND NOT EXISTS (SELECT 1 FROM links l LEFT JOIN tasks b ON b.id=l.to_id LEFT JOIN projects p ON p.id=b.project_id WHERE l.from_type='task' AND l.to_type='task' AND l.kind='blocked-by' AND l.from_id=t.id AND l.confirmed=1 AND l.anchor IS NULL AND (b.id IS NULL OR b.deleted_at IS NOT NULL OR p.deleted_at IS NOT NULL OR b.status!='done')) ORDER BY t.priority_score IS NULL,t.priority_score DESC,t.number,t.id LIMIT ?")
                 .all(Number(row.id), limit + 1);
             return {
                 items: rows

package/dist/store/sqlite/tasks.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { matches, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, } from "../../tasks/index.js";
+import { isClosedState, matches, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, } from "../../tasks/index.js";
 import { taskCategoriesReader } from "../shared-config.js";
 import { actorOfOrigin, originOfActor } from "./actors.js";
 import { folded } from "./folded.js";
@@ -176,11 +176,12 @@ export const taskStoreOver = (context) => {
                 database
                     .prepare("UPDATE tasks SET status = ?, close_reason = ?, close_reason_folded = ?, due_at = ?, closed_at = ?, " +
                     "closed_by_type = ?, closed_by_id = ?, updated_at = ?, " +
-                    "claimed_by = CASE WHEN ? = 'open' THEN claimed_by END, claimed_until = CASE WHEN ? = 'open' THEN claimed_until END, " +
-                    "close_certainty = CASE WHEN ? = 'open' THEN NULL ELSE close_certainty END " +
+                    "claimed_by = CASE WHEN ? NOT IN ('done', 'dismissed') THEN claimed_by END, " +
+                    "claimed_until = CASE WHEN ? NOT IN ('done', 'dismissed') THEN claimed_until END, " +
+                    "close_certainty = CASE WHEN ? NOT IN ('done', 'dismissed') THEN NULL ELSE close_certainty END " +
                     "WHERE id = ?")
                     .run(task.state, task.reason ?? null, folded(task.reason), time(task.dueAt), time(task.closedAt), closedBy?.type ?? null, closedBy?.id ?? null, at, task.state, task.state, task.state, row);
-                if (task.state !== "open")
+                if (isClosedState(task.state))
                     database.prepare(`UPDATE tasks SET ${CLEAR_SUGGESTION} WHERE id = ?`).run(row);
                 if (before.status !== task.state)
                     recordTaskEvent(database, row, closedBy ?? null, "status", { status: [before.status, task.state] }, at);
@@ -196,7 +197,10 @@ export const taskStoreOver = (context) => {
             const row = required(id);
             const at = now();
             write(database, () => {
+                const before = database.prepare("SELECT resolution FROM tasks WHERE id = ?").get(row)?.resolution ?? null;
                 database.prepare("UPDATE tasks SET resolution = ?, updated_at = ? WHERE id = ?").run(text, at, row);
+                if (before !== text)
+                    recordTaskEvent(database, row, null, "resolution", { resolution: [before, text] }, at);
                 if (!by)
                     return;
                 database
@@ -213,7 +217,14 @@ export const taskStoreOver = (context) => {
         judge: async (id, verdict) => {
             if (verdict !== null && !TASK_VERDICTS.includes(verdict))
                 throw new CliError("validation_error", `a verdict is one of ${TASK_VERDICTS.join(", ")}`);
-            database.prepare("UPDATE tasks SET verdict = ?, updated_at = ? WHERE id = ?").run(verdict, now(), required(id));
+            const row = required(id);
+            write(database, () => {
+                const at = now();
+                const before = database.prepare("SELECT verdict FROM tasks WHERE id = ?").get(row)?.verdict ?? null;
+                database.prepare("UPDATE tasks SET verdict = ?, updated_at = ? WHERE id = ?").run(verdict, at, row);
+                if (before !== verdict)
+                    recordTaskEvent(database, row, null, "verdict", { verdict: [before, verdict] }, at);
+            });
         },
     };
 };

package/dist/store/sqlite/work-tasks.d.ts

@@ -1,22 +1,26 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import { TASK_TYPES, WORK_TASK_TYPES } from "../../domain/knowledge.js";
-import { type TaskState, type TaskVerdict } from "../../tasks/index.js";
+import { type PriorityLabel, type TaskState, type TaskVerdict } from "../../tasks/index.js";
 import type { CacheDatabase } from "../driver.js";
 import type { Actor } from "./actors.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
-import type { Where } from "./query-filter.js";
+import { type Where } from "./query-filter.js";
+import { type TaskSort } from "./task-board.js";
 import { type CloseSuggestion } from "./task-close.js";
 import { type TaskRelationsStore } from "./task-relations.js";
 export declare const TASK_ROLES: readonly ["assignee", "reviewer", "watcher"];
-export declare const TASK_EVENT_KINDS: readonly ["created", "title", "description", "status", "assigned", "unassigned", "due", "priority", "moved", "linked", "unlinked", "category", "close-suggestion"];
+export declare const TASK_EVENT_KINDS: readonly ["created", "title", "description", "status", "assigned", "unassigned", "due", "priority", "moved", "linked", "unlinked", "category", "close-suggestion", "agent", "claimed", "released", "next-check", "resolution", "verdict", "close-certainty", "tags"];
 export type WorkTaskType = (typeof WORK_TASK_TYPES)[number];
 export type TaskType = (typeof TASK_TYPES)[number];
 export type TaskRole = (typeof TASK_ROLES)[number];
 export interface TaskFields {
     title?: string;
     description?: string | null;
-    /** 0 urgent … 4 low. */
+    /** 0 to 1, higher first: `priorityOf` reads a label or the old 0–4. */
     priority?: number | null;
+    /** The agent working on it, by name; `null` clears it. */
+    agent?: string | null;
     /** A task reference (`task:<id>`) or id in the same project; `null` makes it top-level. */
     parent?: string | null;
     dueAt?: Date | null;
@@ -48,7 +52,12 @@ export interface TaskDetails {
     description: string | null;
     type: TaskType;
     status: TaskState;
+    /** 0 to 1, higher first. */
     priority: number | null;
+    priorityLabel: PriorityLabel | null;
+    agent: string | null;
+    /** Bumped by every write; give it back to refuse a write made on a stale copy. */
+    revision: number;
     parent: string | null;
     /** What a task found in a message points at; null for a task made here. */
     source: string | null;
@@ -69,18 +78,79 @@ export interface TaskDetails {
     createdAt: string;
     updatedAt: string;
 }
+export interface RevisionCheck {
+    /** The revision the caller read; a write on any other is refused (`task.stale`). */
+    revision?: number;
+}
+export interface TaskMove {
+    status?: TaskState;
+    before?: string;
+    after?: string;
+}
+export interface TaskMoved {
+    task: TaskDetails;
+    /** The labels before and after, which differ when the move crossed a band edge. */
+    label: {
+        from: PriorityLabel | null;
+        to: PriorityLabel | null;
+        changed: boolean;
+    };
+    /** Other tasks of the column given a new priority to make room, by key. */
+    renumbered: string[];
+}
+export interface BoardOptions {
+    limit: number;
+    offset?: number;
+    sort?: TaskSort;
+    descending?: boolean;
+    /** The zone `due:today` and bare dates are read in. */
+    zone?: string;
+}
+/** How many tasks match, and how many hold each value: the board's pickers show these beside their choices. */
+export interface BoardCounts {
+    total: number;
+    project: {
+        value: string;
+        name: string;
+        count: number;
+    }[];
+    /** `person:<id>`, or `none` for the tasks nobody is assigned. */
+    assignee: {
+        value: string;
+        name: string | null;
+        count: number;
+    }[];
+    /** By label; `none` for the tasks with no priority. */
+    priority: {
+        value: PriorityLabel | "none";
+        count: number;
+    }[];
+    state: {
+        value: TaskState;
+        count: number;
+    }[];
+}
 export interface TaskEvent {
     kind: (typeof TASK_EVENT_KINDS)[number];
-    actor: Actor | null;
+    /** `name`: the person's or the bot's, as the store holds it now. */
+    actor: (Actor & {
+        name: string | null;
+    }) | null;
     changes: Record<string, [unknown, unknown]> | null;
     at: string;
 }
 /** Tasks beyond the package's four message kinds, and the fields the package does not know, on any task. */
 export interface WorkTasks extends TaskRelationsStore {
     create(input: NewWorkTask, by: Author): Promise<TaskDetails>;
-    edit(id: string, fields: TaskFields, by: Author): Promise<TaskDetails>;
-    assign(id: string, assignment: TaskAssignment, by: Author): Promise<TaskDetails>;
-    unassign(id: string, assignment: TaskAssignment, by: Author): Promise<TaskDetails>;
+    edit(id: string, fields: TaskFields, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
+    assign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
+    unassign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
+    /**
+     * Puts a project task just before or after another in a board column, by giving it a priority between its new
+     * neighbours; `status` moves it to that column in the same write. When the neighbours leave no room, that
+     * priority band of the column is spread out again, and each task given a new number is named.
+     */
+    move(id: string, move: TaskMove, by: Author, check?: RevisionCheck): Promise<TaskMoved>;
     /** `person:<id>` of whoever sent the task's source message; `undefined` for the owner, a note or an unknown sender. */
     sourceSender(id: string): Promise<string | undefined>;
     details(id: string): Promise<TaskDetails>;
@@ -100,6 +170,20 @@ export interface WorkTasks extends TaskRelationsStore {
         limit?: number;
     }): Promise<TaskDetails[]>;
     events(id: string): Promise<TaskEvent[]>;
+    /** The owner's project tasks, every project at once, narrowed by a query over `PROJECT_TASK_FIELDS`. */
+    board(query: QueryAst | undefined, options: BoardOptions): Promise<{
+        items: TaskDetails[];
+        total: number;
+    }>;
+    /** The owner and everyone who holds a role on a live task, by name: who the board offers to assign. */
+    taskPeople(): Promise<{
+        person: string;
+        name: string | null;
+        owner: boolean;
+        tasks: number;
+    }[]>;
+    /** Each count leaves out the query's own terms on that field, so a chosen project does not hide the others. */
+    boardCounts(query: QueryAst | undefined, options?: Pick<BoardOptions, "zone">): Promise<BoardCounts>;
     /**
      * Takes an open task for `holder` until `until`, unless someone else holds it now — a lapsed claim holds nothing,
      * and the holder's own claim is extended.
@@ -109,10 +193,13 @@ export interface WorkTasks extends TaskRelationsStore {
     /** Gives a task back; only its holder or the owner may. */
     release(id: string, holder: string): Promise<TaskDetails>;
 }
+type Row = Record<string, unknown>;
 export declare const recordTaskEvent: (database: CacheDatabase, task: number, actor: Actor | null, kind: TaskEvent["kind"], changes: TaskEvent["changes"], at: number) => void;
+/** What a write made on a stale copy is refused with: the revision the caller read is not the task's now. */
+export declare const checkRevision: (row: Row, expected: number | undefined) => void;
 type WorkTaskOperations = Omit<WorkTasks, "create" | "assign"> & {
     create(input: NewWorkTask, by: Author): TaskDetails;
-    assign(id: string, assignment: TaskAssignment, by: Author): TaskDetails;
+    assign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): TaskDetails;
 };
 export declare const workTaskOperationsOver: (context: StoreContext) => WorkTaskOperations;
 export declare const workTasksOver: (context: StoreContext) => WorkTasks;