@wirecat/cli-core 0.511.0 → 0.513.0

package/dist/entities/task-results.d.ts

@@ -7,8 +7,11 @@ export declare const taskCard: v.StrictObjectSchema<{
     readonly title: v.StringSchema<undefined>;
     readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
-    readonly status: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+    readonly status: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
     readonly priority: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly priority_label: v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>;
+    readonly agent: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly revision: v.NumberSchema<undefined>;
     readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
     readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -69,7 +72,7 @@ export declare const taskCreated: v.StrictObjectSchema<{
     readonly account: v.StringSchema<undefined>;
     readonly group: v.StringSchema<undefined>;
     readonly kind: v.PicklistSchema<readonly ["question", "request", "mention", "promise"], undefined>;
-    readonly state: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+    readonly state: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
     readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly origin: v.PicklistSchema<readonly ["rule", "agent", "owner"], undefined>;
     readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
@@ -108,8 +111,11 @@ export declare const taskCreated: v.StrictObjectSchema<{
         readonly title: v.StringSchema<undefined>;
         readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
-        readonly status: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
         readonly priority: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly priority_label: v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>;
+        readonly agent: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly revision: v.NumberSchema<undefined>;
         readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -171,7 +177,7 @@ export declare const taskClosed: v.StrictObjectSchema<{
     readonly account: v.StringSchema<undefined>;
     readonly group: v.StringSchema<undefined>;
     readonly kind: v.PicklistSchema<readonly ["question", "request", "mention", "promise"], undefined>;
-    readonly state: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+    readonly state: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
     readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly origin: v.PicklistSchema<readonly ["rule", "agent", "owner"], undefined>;
     readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
@@ -210,8 +216,11 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
     readonly title: v.StringSchema<undefined>;
     readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
-    readonly status: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+    readonly status: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
     readonly priority: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly priority_label: v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>;
+    readonly agent: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly revision: v.NumberSchema<undefined>;
     readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
     readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -340,8 +349,11 @@ export declare const taskMerge: v.StrictObjectSchema<{
         readonly title: v.StringSchema<undefined>;
         readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
-        readonly status: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
         readonly priority: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly priority_label: v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>;
+        readonly agent: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly revision: v.NumberSchema<undefined>;
         readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
@@ -435,8 +447,11 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
         readonly title: v.StringSchema<undefined>;
         readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
-        readonly status: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
         readonly priority: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly priority_label: v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>;
+        readonly agent: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly revision: v.NumberSchema<undefined>;
         readonly parent: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
         readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly due_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;

package/dist/entities/task-results.js

@@ -1,7 +1,7 @@
 import * as v from "valibot";
 import { TASK_TYPES } from "../domain/knowledge.js";
 import { LINK_KINDS, LINK_SOURCES } from "../store/sqlite/link-kinds.js";
-import { TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS } from "../tasks/index.js";
+import { PRIORITY_LABELS, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS } from "../tasks/index.js";
 import { count, id, reference, text, time } from "./fields.js";
 import { closeSuggestion } from "./task.js";
 import { taskPair } from "./task-pair.js";
@@ -30,6 +30,9 @@ export const taskCard = v.strictObject({
     type: v.picklist(TASK_TYPES),
     status: v.picklist(TASK_STATES),
     priority: v.nullable(v.number()),
+    priority_label: v.nullable(v.picklist(PRIORITY_LABELS)),
+    agent: v.nullable(text),
+    revision: v.number(),
     parent: v.nullable(reference),
     source: v.nullable(text),
     due_at: nullableTime,

package/dist/entities/task.d.ts

@@ -16,7 +16,7 @@ export declare const task: v.StrictObjectSchema<{
     readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly description: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly kind: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
-    readonly state: v.PicklistSchema<readonly ["open", "done", "dismissed"], undefined>;
+    readonly state: v.PicklistSchema<readonly ["open", "todo", "in_progress", "done", "dismissed"], undefined>;
     readonly origin: v.OptionalSchema<v.PicklistSchema<readonly ["rule", "agent", "owner"], undefined>, undefined>;
     readonly project: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly account: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -24,7 +24,24 @@ export declare const task: v.StrictObjectSchema<{
     readonly chat: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
     /** The message it came from. */
     readonly source_message: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
+    /** 0 to 1, higher first; `priority_label` reads it as low, medium, high or critical. */
     readonly priority: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    readonly priority_label: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<readonly ["low", "medium", "high", "critical"], undefined>, undefined>, undefined>;
+    /** The agent working on it, apart from its assignees and its claim. */
+    readonly agent: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /** Give it back with `--revision` to refuse a write made on a stale copy. */
+    readonly revision: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly assignments: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly role: v.PicklistSchema<["assignee", "reviewer", "watcher"], undefined>;
+    }, undefined>, undefined>, undefined>;
+    /** Open work whose blocked-by tasks are all done. */
+    readonly ready: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    /** The blocked-by tasks not done yet: open (any open state), dismissed, or unavailable. */
+    readonly blocked_by: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly task: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly state: v.PicklistSchema<["open", "dismissed", "unavailable"], undefined>;
+    }, undefined>, undefined>, undefined>;
     readonly parent: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
     readonly due_at: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>, undefined>;
     readonly closed_at: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>, undefined>;

package/dist/entities/task.js

@@ -1,6 +1,6 @@
 import * as v from "valibot";
 import { TASK_TYPES } from "../domain/knowledge.js";
-import { TASK_ORIGINS, TASK_STATES } from "../tasks/index.js";
+import { PRIORITY_LABELS, TASK_ORIGINS, TASK_STATES } from "../tasks/index.js";
 import { id, reference, text, time } from "./fields.js";
 export const closeSuggestion = v.strictObject({
     as: v.picklist(["done", "dismissed"]),
@@ -27,7 +27,18 @@ export const task = v.strictObject({
     chat: v.optional(v.nullable(reference)),
     /** The message it came from. */
     source_message: v.optional(v.nullable(reference)),
+    /** 0 to 1, higher first; `priority_label` reads it as low, medium, high or critical. */
     priority: v.optional(v.nullable(v.number())),
+    priority_label: v.optional(v.nullable(v.picklist(PRIORITY_LABELS))),
+    /** The agent working on it, apart from its assignees and its claim. */
+    agent: v.optional(v.nullable(text)),
+    /** Give it back with `--revision` to refuse a write made on a stale copy. */
+    revision: v.optional(v.number()),
+    assignments: v.optional(v.array(v.strictObject({ to: reference, role: v.picklist(["assignee", "reviewer", "watcher"]) }))),
+    /** Open work whose blocked-by tasks are all done. */
+    ready: v.optional(v.boolean()),
+    /** The blocked-by tasks not done yet: open (any open state), dismissed, or unavailable. */
+    blocked_by: v.optional(v.array(v.strictObject({ task: reference, state: v.picklist(["open", "dismissed", "unavailable"]) }))),
     parent: v.optional(v.nullable(reference)),
     due_at: v.optional(v.nullable(time)),
     closed_at: v.optional(v.nullable(time)),

package/dist/errors/reasons.js

@@ -120,6 +120,7 @@ const OTHERS = [
     validation("task.category-unknown", "the category is not in the task category list"),
     validation("task.claimed", "someone else holds the task"),
     validation("task.closed", "the task is already closed"),
+    ["task.stale", "configuration_error", "the task changed since it was read; read it again"],
     validation("task.dependency-cycle", "the task would depend on itself"),
     validation("task.duplicate-candidates", "open tasks may be the same job: attach to one, or add it as new"),
     validation("task.certainty-required", "an agent closes a task with its certainty, 0 to 1"),

package/dist/services/task-rules.js

@@ -1,5 +1,5 @@
 import { formatLocator } from "../domain/locator.js";
-import { createTaskService } from "../tasks/index.js";
+import { createTaskService, isClosedState } from "../tasks/index.js";
 import { questions } from "./questions.js";
 import { categorize } from "./task-categories.js";
 export const taskAccount = ({ provider, account }) => `${provider}:${account}`;
@@ -57,7 +57,7 @@ export const applyTaskRules = async (review, { store, account, now, categories,
     };
     const close = async (message, kind, answer) => {
         for (const task of await store.findBySource(owner, sourceOf(message))) {
-            if (task.kind !== kind || task.state !== "open")
+            if (task.kind !== kind || isClosedState(task.state))
                 continue;
             result.closed += 1;
             if (dryRun)

package/dist/services/tasks.d.ts

@@ -200,7 +200,7 @@ export interface TasksService {
 export declare const CLAIM_LEASE_MS: number;
 export declare const PREVIEW = 200;
 export declare const taskTypeOf: (typed: string) => "mention" | "promise" | "question" | "request";
-export declare const taskStateOf: (typed: string) => "dismissed" | "done" | "open";
+export declare const taskStateOf: (typed: string) => "dismissed" | "done" | "in_progress" | "open" | "todo";
 export declare const closedStateOf: (typed: string) => "dismissed" | "done";
 export declare const taskLinkKindOf: (typed: string) => "blocked-by" | "created-from" | "discovered-from" | "duplicate-of" | "evidence" | "follow-up-of" | "related-to";
 export declare const taskTypesOf: (typed: string) => TaskKind[];

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, PRIORITY_LABELS, type PriorityLabel, priorityLabel, priorityOf, TASK_STATES, type TaskState, } 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, RevisionCheck, TaskAssignment, TaskDetails, TaskEvent, TaskFields, TaskMove, TaskMoved, 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, PRIORITY_LABELS, priorityLabel, priorityOf, 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/manifest.js

@@ -54,6 +54,7 @@ export const MANIFEST = [
     { name: "20261029224107_version-38-folded-triggers", version: 38, minCompatible: 34 },
     { name: "20261030114008_version-39-email-locations", version: 39, minCompatible: 34 },
     { name: "20261030225520_version-40-note-trigrams", version: 40, minCompatible: 34 },
+    { name: "20261031230945_version-41-task-fields", version: 41, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -847,5 +847,17 @@ export const GENERATED = [
             "CREATE TRIGGER document_trigrams_bd BEFORE DELETE ON documents BEGIN\n  DELETE FROM document_trigrams WHERE rowid = old.id;\nEND;",
             "-- The trigrams hold JS-normalized text, which SQL cannot produce: fillTrigrams fills the rows stored before this\n-- version, up to `watermark`, and a search reads the rest of them by their text meanwhile.\nINSERT INTO search_index_state (name, watermark, filled_through, terms_through, normalizer_version)\n  SELECT 'note_trigrams', coalesce(max(id), 0), 0, 0, 1 FROM notes\n  UNION ALL SELECT 'document_trigrams', coalesce(max(id), 0), 0, 0, 1 FROM documents;"
         ]
+    },
+    {
+        "name": "20261031230945_version-41-task-fields",
+        "statements": [
+            "ALTER TABLE `tasks` ADD `priority_score` real;",
+            "ALTER TABLE `tasks` ADD `agent` text;",
+            "ALTER TABLE `tasks` ADD `revision` integer DEFAULT 1 NOT NULL;",
+            "-- 0 urgent … 4 low land inside the critical, high, medium and low quarters, with room on either side for moves.\nUPDATE tasks SET priority_score = CASE priority WHEN 0 THEN 0.875 WHEN 1 THEN 0.625 WHEN 2 THEN 0.375 WHEN 3 THEN 0.1875 WHEN 4 THEN 0.0625 END WHERE priority IS NOT NULL;",
+            "-- A build before version 41 writes only `priority`; these keep the score in step with what it wrote.\nCREATE TRIGGER tasks_priority_score_ai AFTER INSERT ON tasks WHEN new.priority IS NOT NULL AND new.priority_score IS NULL BEGIN\n  UPDATE tasks SET priority_score = CASE new.priority WHEN 0 THEN 0.875 WHEN 1 THEN 0.625 WHEN 2 THEN 0.375 WHEN 3 THEN 0.1875 WHEN 4 THEN 0.0625 END WHERE id = new.id;\nEND;",
+            "CREATE TRIGGER tasks_priority_score_au AFTER UPDATE OF priority ON tasks WHEN new.priority IS NOT old.priority AND new.priority_score IS old.priority_score BEGIN\n  UPDATE tasks SET priority_score = CASE new.priority WHEN 0 THEN 0.875 WHEN 1 THEN 0.625 WHEN 2 THEN 0.375 WHEN 3 THEN 0.1875 WHEN 4 THEN 0.0625 END WHERE id = new.id;\nEND;",
+            "-- Every build's write bumps it, older ones too, so a stale copy is caught whoever wrote last.\nCREATE TRIGGER tasks_revision_au AFTER UPDATE ON tasks WHEN new.revision IS old.revision BEGIN\n  UPDATE tasks SET revision = old.revision + 1 WHERE id = new.id;\nEND;"
+        ]
     }
 ];

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/schema.d.ts

@@ -12683,6 +12683,54 @@ export declare const tasks: import("drizzle-orm/sqlite-core").SQLiteTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}>;
+        priorityScore: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "tasks";
+            dataType: "number double";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        agent: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "tasks";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        revision: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "tasks";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: 'sqlite';
     isAlias: false;

package/dist/store/sqlite/schema.js

@@ -1266,6 +1266,9 @@ export const tasks = sqliteTable("tasks", {
     closeSuggestedCertainty: real("close_suggested_certainty"),
     closeSuggestedReason: text("close_suggested_reason"),
     closeSuggestedAt: integer("close_suggested_at"),
+    priorityScore: real("priority_score"),
+    agent: text("agent"),
+    revision: integer("revision").notNull().default(1),
 }, (table) => [
     unique().on(table.projectId, table.number),
     index("tasks_by_title_folded").on(table.titleFolded),

package/dist/store/sqlite/tags.d.ts

@@ -73,10 +73,9 @@ export declare const canonicalTagNamed: (database: CacheDatabase, name: string)
 export declare const createTag: (context: StoreContext, name: string, kind: TagKind, by: "owner" | "agent", options?: TagCreationOptions) => TagRow;
 /** The tag of that name, made as a plain tag when no tag or topic holds the name yet. */
 export declare const ensureTag: (context: StoreContext, name: string) => TagRow;
-/** The tags it did not have before, in the order given; a tag the owner adds becomes the owner's. */
 export declare const addTags: (context: StoreContext, thing: Thing, tags: string[], source?: TaggingSource, author?: Actor) => string[];
 /** An explicit removal withdraws the effective label, restricted to the requested origin when supplied. */
-export declare const removeTags: ({ database }: StoreContext, thing: Thing, tags: string[], source?: "manual" | "auto") => string[];
+export declare const removeTags: (context: StoreContext, thing: Thing, tags: string[], source?: "manual" | "auto") => string[];
 export interface Label {
     tag: string;
     /** `file` when only a note's file states it; the owner's own label otherwise. */

package/dist/store/sqlite/tags.js

@@ -111,13 +111,23 @@ export const ensureTag = (context, name) => {
     return canonicalTagNamed(context.database, name) ?? createTag(context, name, "tag", "owner");
 };
 /** The tags it did not have before, in the order given; a tag the owner adds becomes the owner's. */
+/** A task's tag change is part of its history, and of its revision. */
+const taskTagsChanged = (context, thing, changes, author) => {
+    if (thing.type !== "task" || [...(changes.added ?? []), ...(changes.removed ?? [])].length === 0)
+        return;
+    const at = context.now();
+    context.database.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?").run(at, thing.id);
+    context.database
+        .prepare("INSERT INTO task_events (task_id, actor_type, actor_id, kind, changes, created_at) VALUES (?, ?, ?, 'tags', ?, ?)")
+        .run(thing.id, author?.type ?? null, author?.id ?? null, JSON.stringify({ tags: [changes.removed ?? [], changes.added ?? []] }), at);
+};
 export const addTags = (context, thing, tags, source = "owner", author) => {
     const { database, now } = context;
     const insert = database.prepare("INSERT INTO taggings (tag_id, taggable_type, taggable_id, main, source, author_type, author_id, created_at, updated_at) " +
         "VALUES (?, ?, ?, 0, ?, ?, ?, ?, ?) ON CONFLICT (tag_id, taggable_type, taggable_id) DO NOTHING");
     const claim = database.prepare("UPDATE taggings SET source = 'owner', updated_at = ? WHERE tag_id = ? AND taggable_type = ? AND taggable_id = ? AND source <> 'owner'");
     const at = now();
-    return tags.filter((name) => {
+    const fresh = tags.filter((name) => {
         const tag = ensureTag(context, name);
         const held = database
             .prepare("SELECT source,author_type,author_id FROM taggings WHERE tag_id IN (SELECT ? UNION ALL SELECT source_id FROM tag_redirects WHERE survivor_id=?) AND taggable_type=? AND taggable_id=?")
@@ -129,11 +139,14 @@ export const addTags = (context, thing, tags, source = "owner", author) => {
             claim.run(at, tag.id, thing.type, thing.id);
         return added && held.length === 0;
     });
+    taskTagsChanged(context, thing, { added: fresh }, author);
+    return fresh;
 };
 /** An explicit removal withdraws the effective label, restricted to the requested origin when supplied. */
-export const removeTags = ({ database }, thing, tags, source) => {
+export const removeTags = (context, thing, tags, source) => {
+    const { database } = context;
     const remove = database.prepare("DELETE FROM taggings WHERE tag_id=? AND taggable_type=? AND taggable_id=?");
-    return tags.filter((name) => {
+    const removed = tags.filter((name) => {
         const tag = canonicalTagNamed(database, name);
         if (!tag)
             return false;
@@ -171,6 +184,8 @@ export const removeTags = ({ database }, thing, tags, source) => {
         }
         return changed;
     });
+    taskTagsChanged(context, thing, { removed });
+    return removed;
 };
 /** A thing's tags by name, with whether only a file states each. */
 /** A tagging of something still there: a deleted document keeps its tags but is not counted or listed by them. */

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;