@wirecat/cli-core 0.511.0 → 0.512.0

package/dist/services/tasks.js

@@ -5,7 +5,7 @@ import { formatReference } from "../domain/references.js";
 import { task as taskEntity } from "../entities/task.js";
 import { certaintyOf, TASK_RELATION_KINDS, } from "../store/index.js";
 import { queryFilter } from "../store/store.js";
-import { createTaskService, TASK_KINDS, TASK_STATES, } from "../tasks/index.js";
+import { createTaskService, isClosedState, TASK_KINDS, TASK_STATES, } from "../tasks/index.js";
 import { storedChatId } from "./message-resolution.js";
 import { categorize, taskCategoryOf } from "./task-categories.js";
 import { taskAccount } from "./task-rules.js";
@@ -163,7 +163,7 @@ export const tasksService = (deps, categories) => {
     const planOf = async (store, id, plan, by) => {
         if (plan.category !== undefined)
             plan = { ...plan, category: await categoryOf(store, plan.category) };
-        const open = (await store.tasks.details(id)).status === "open";
+        const open = !isClosedState((await store.tasks.details(id)).status);
         if (!open && (plan.dueAt != null || plan.nextCheckAt != null))
             throw new CliError("validation_error", "a closed task takes no due date or next check; it stays closed");
         const { assignees, ...fields } = plan;
@@ -199,7 +199,9 @@ export const tasksService = (deps, categories) => {
      * A message linked to a task is read by the comparison, so the task may now look like another one: the pairs go to
      * the review list, never to a merge, and the link stands whatever they score. A closed task is not checked.
      */
-    const reviewAfterLink = async (store, id) => (await store.tasks.get(id))?.state === "open" ? store.tasks.reviewDuplicates(id, { linked: true }) : 0;
+    const reviewAfterLink = async (store, id) => !isClosedState((await store.tasks.get(id))?.state ?? "done")
+        ? store.tasks.reviewDuplicates(id, { linked: true })
+        : 0;
     return {
         list: ({ query, limit, offset, previews }) => inStore(async (store, account) => {
             const groups = new Map();
@@ -358,7 +360,7 @@ export const tasksService = (deps, categories) => {
         },
         close: (id, { as, reason, by, agent, certainty, suggestOnly }) => inStore(async (store, account) => {
             const existing = await owned(store, account, id);
-            const suggested = existing.state === "open" ? await store.tasks.closeSuggestion(id) : null;
+            const suggested = !isClosedState(existing.state) ? await store.tasks.closeSuggestion(id) : null;
             const state = as ?? (by === "owner" ? suggested?.as : undefined);
             if (state === undefined)
                 throw new CliError("validation_error", "say how the task is closed: --as done, or --as dismissed");
@@ -368,7 +370,7 @@ export const tasksService = (deps, categories) => {
                 const { closeCertainty, closeSuggestion } = await store.tasks.details(task.id);
                 return { ...(await taskView(store, account, task)), closeCertainty, closeSuggestion };
             };
-            if (by === "agent" && existing.state === "open") {
+            if (by === "agent" && !isClosedState(existing.state)) {
                 if (certainty === undefined)
                     throw new CliError("validation_error", "an agent closes a task with its certainty, 0 to 1: how sure it is the task needs nothing more", { reason: "task.certainty-required" });
                 const { allowed, min } = await store.tasks.agentClose();

package/dist/store/index.d.ts

@@ -5,6 +5,7 @@ export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } fro
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
 export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFinding, MeetingFindingsInput, MeetingFindingsReceipt, MeetingTaskFinding, } from "../meetings/index.js";
+export { CLOSED_STATES, isClosedState, TASK_STATES } from "../tasks/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
 export type { DocumentTransferOptions, DocumentTransferPreview, DocumentTransferReceipt, } from "./document-transfer/index.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
@@ -54,6 +55,8 @@ export { fillSearchIndex, resetSearchIndex, type SearchIndexFill, type SearchInd
 export type { SyncStateSave } from "./sqlite/sync.js";
 export type { TagCreationOptions, TagCreationReview } from "./sqlite/tag-creation.js";
 export type { TagKind, TagRow } from "./sqlite/tags.js";
+export type { TaskSort } from "./sqlite/task-board.js";
+export { PROJECT_TASK_FIELDS, TASK_SORTS } from "./sqlite/task-board.js";
 export type { SimilarSubject, SimilarTask, TaskDraft } from "./sqlite/task-candidates.js";
 export { type AgentCloseSettings, type CloseSuggestion, certaintyOf } from "./sqlite/task-close.js";
 export type { TaskPair, TaskPairDecision, TaskPairSide } from "./sqlite/task-pairs.js";
@@ -62,6 +65,6 @@ export type { TaskRelation, TaskRelationKind, TaskRelationsStore } from "./sqlit
 export { TASK_RELATION_KINDS } from "./sqlite/task-relations.js";
 export type { StoreTaskStore } from "./sqlite/tasks.js";
 export type { TagPreflight, VocabularyAlias, VocabularyAliasReceipt, VocabularyAudit, VocabularyAuditOptions, VocabularyCatalog, VocabularyEntry, VocabularyKind, VocabularyOptions, VocabularyResolution, VocabularyStore, VocabularyTarget, } from "./sqlite/vocabulary.js";
-export type { NewWorkTask, TaskAssignment, TaskDetails, TaskEvent, TaskFields, TaskRole, TaskType, WorkTaskType, } from "./sqlite/work-tasks.js";
+export type { BoardCounts, BoardOptions, NewWorkTask, TaskAssignment, TaskDetails, TaskEvent, TaskFields, TaskRole, TaskType, WorkTaskType, } from "./sqlite/work-tasks.js";
 export { TASK_EVENT_KINDS, TASK_ROLES } from "./sqlite/work-tasks.js";
 export { type AccountAccounts, type AccountAttachments, type AccountCounters, type AccountKey, type AccountMentions, type AccountMessageFilter, type AccountMessages, type AccountPeople, type AccountsStore, type AccountVectors, type AttachmentsStore, type AttachmentTextEntry, type AttachmentView, type ChatStats, type ChatsStore, type ConversationsStore, type CountersStore, type DeletionScope, type Delta, type FileAttachment, type IdentityRef, type IngestedVia, type LinkedIdentity, type LinkOptions, MENTION_QUERY, MENTION_STATUSES, type MentionsStore, type MessageFilter, type MessageStore, type MessagesStore, OTHER_SOURCES, openStore, type PeopleStore, type PersonFacts, type PersonRecord, type QueriesStore, type Range, type RankedEvidence, type RankedStoreFound, type RankedStoreRow, type RankingEvidenceItem, type RankingEvidenceRequest, type RankingRequest, type RosterStore, type SearchCommand, type SearchesStore, type SearchIndexStore, type SearchRecord, type StoredAccount, type StoredChatFilter, type StoredHit, type StoredSearch, type StoredTag, type StoreOptions, type SyncStore, type TagFilter, type TagsStore, type TagTarget, type TaskTagTarget, type TextOrigin, type VectorsStore, } from "./store.js";

package/dist/store/index.js

@@ -1,6 +1,7 @@
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
+export { CLOSED_STATES, isClosedState, TASK_STATES } from "../tasks/index.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
@@ -22,6 +23,7 @@ export { ORGANIZATION_KINDS, PROJECT_TYPES, SCOPES } from "./sqlite/knowledge.js
 export { NOTE_FIELDS, } from "./sqlite/note-search.js";
 export { PROPOSAL_STATUSES } from "./sqlite/proposed-actions.js";
 export { fillSearchIndex, resetSearchIndex, searchIndexState, } from "./sqlite/search-index.js";
+export { PROJECT_TASK_FIELDS, TASK_SORTS } from "./sqlite/task-board.js";
 export { certaintyOf } from "./sqlite/task-close.js";
 export { TASK_PAIR_DECISIONS } from "./sqlite/task-pairs.js";
 export { TASK_RELATION_KINDS } from "./sqlite/task-relations.js";

package/dist/store/sqlite/knowledge.js

@@ -5,6 +5,7 @@ import { formatReference, parseReference } from "../../domain/references.js";
 import { normalizeTag } from "../../domain/tags.js";
 import { normalizeVocabularyName } from "../../domain/vocabulary.js";
 import { formatMeetingReference } from "../../meetings/index.js";
+import { isClosedState } from "../../tasks/index.js";
 import { fold } from "../normalize.js";
 import { ulid } from "../ulid.js";
 import { ownerPerson } from "./actors.js";
@@ -267,7 +268,7 @@ export const knowledgeStoreOver = (context) => {
         const row = taskRowOf(database, id);
         const open = row !== undefined &&
             taskAccountOf(database, row) === taskAccount(key) &&
-            database.prepare("SELECT status FROM tasks WHERE id = ?").get(row)?.status === "open";
+            !isClosedState(String(database.prepare("SELECT status FROM tasks WHERE id = ?").get(row)?.status ?? "done"));
         if (!open)
             throw new CliError("validation_error", "a reminder requires an open task in this account");
         return row;
@@ -622,7 +623,7 @@ export const knowledgeStoreOver = (context) => {
                 throw new CliError("validation_error", "lease takes 1000–3600000 milliseconds");
             const accountId = account(key), at = now();
             const rows = database
-                .prepare("SELECT r.id FROM reminders r JOIN tasks t ON t.id = r.task_id WHERE r.account_id=? AND r.due_at<=? AND t.status = 'open' " +
+                .prepare("SELECT r.id FROM reminders r JOIN tasks t ON t.id = r.task_id WHERE r.account_id=? AND r.due_at<=? AND t.status NOT IN ('done','dismissed') " +
                 "AND (r.state='pending' OR (r.state='leased' AND r.lease_until<=?)) ORDER BY r.due_at, r.id LIMIT ?")
                 .all(accountId, at, at, limit);
             const claimed = [];

package/dist/store/sqlite/person-preparation.js

@@ -52,7 +52,7 @@ export const personPreparation = ({ database }, uid, { accounts, limit }) => {
         const tasks = database
             .prepare(`SELECT t.id,t.title,t.due_at,t.project_id,t.source_locator,t.created_at,group_concat(DISTINCT ta.role) AS role
         FROM task_assignments ta JOIN tasks t ON t.id=ta.task_id JOIN main.projects p ON p.id=t.project_id
-        WHERE ta.assignee_type='person' AND ta.assignee_id=? AND t.deleted_at IS NULL AND t.status='open'
+        WHERE ta.assignee_type='person' AND ta.assignee_id=? AND t.deleted_at IS NULL AND t.status NOT IN ('done','dismissed')
         AND p.deleted_at IS NULL AND (p.account_id IS NULL OR p.account_id IN (SELECT a.id FROM accounts a
           JOIN json_each(?) k ON a.provider=json_extract(k.value,'$.provider')
           AND a.external_id=json_extract(k.value,'$.account')))

package/dist/store/sqlite/task-board.d.ts

@@ -0,0 +1,16 @@
+import { type FieldSpec, type QueryAst } from "@wirecat/cli-base/query";
+import type { ColumnMap } from "./query-filter.js";
+export declare const TASK_SORTS: readonly ["priority", "due", "created", "updated", "key", "state"];
+export type TaskSort = (typeof TASK_SORTS)[number];
+/** The query language of the owner's project tasks, every project at once; `text` takes the bare words. */
+export declare const PROJECT_TASK_FIELDS: readonly FieldSpec[];
+/** A `blocked-by` task that is not done holds the task back; so does one deleted or out of reach. */
+export declare const UNFINISHED_BLOCKER: string;
+/** `now` is when overdue is measured; one value per answer, so the list and its counts agree. */
+export declare const projectTaskColumns: (now: number) => ColumnMap;
+/** Live tasks of the owner's projects; an account's inbox is listed by its account, never here. */
+export declare const BOARD_SCOPE = "t.deleted_at IS NULL AND t.project_id IN (SELECT id FROM projects WHERE deleted_at IS NULL AND length(key) <> 10)";
+/** The chosen order first, then priority, age and id, so a page boundary never splits a tie. */
+export declare const boardOrder: (sort: TaskSort, descending: boolean) => string;
+/** The query without its required terms on `name`: a picker counts the choices its own filter hides. */
+export declare const withoutField: (query: QueryAst | undefined, name: string) => QueryAst | undefined;

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

@@ -0,0 +1,133 @@
+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 { 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", "num", "priority:[0 TO 1]", { relation: "0 urgent … 4 low; NOT priority:* has none" }),
+    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 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: { type: "num", sql: "t.priority" },
+    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: [`coalesce(t.priority, 5) ${direction}`],
+        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, "coalesce(t.priority, 5)", "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",
                 });

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 coalesce(t.priority,5),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);

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

@@ -1,10 +1,12 @@
+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 { 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"];
@@ -69,9 +71,43 @@ export interface TaskDetails {
     createdAt: string;
     updatedAt: 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;
+    }[];
+    priority: {
+        value: number | null;
+        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;
 }
@@ -100,6 +136,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.