@wirecat/cli-core 0.512.0 → 0.514.0

package/CHANGELOG.md

@@ -7,6 +7,52 @@ shape of this file.
 
 ## Unreleased
 
+## 0.514.0 — 01.11.2026
+
+### Fixed
+
+- **A failed run's record masks a WhatsApp id as `[id]`**: `<number>[:device]@s.whatsapp.net`, a
+  group's `<number>-<number>@g.us`, `@c.us`, `@broadcast`, `@newsletter` and an `@lid` of any length. Before, such an
+  id was masked only when it looked like an email, and a 16-digit `@lid` or a `@newsletter` id stayed in the record.
+- **The parity check requires `projects` and `projects evidence` in max and tg**, which ship them in max-cli 0.94.0
+  and tg-cli 0.110.0 (tg-cli#798, max-cli#886); wa stays planned.
+
+## 0.513.0 — 01.11.2026
+
+### Added
+
+- **`tasks.board(query, { limit, offset, sort, descending, zone })` and `tasks.boardCounts(query)`** list the owner's
+  project tasks across every project (an account's inbox is left out) with a Lucene query over `PROJECT_TASK_FIELDS`:
+  `state`, `kind`, `project` (`project:*` for all), `assignee` (`any`, `none`, `"person:12"`), `priority`,
+  `due` and `closed` with ranges, `overdue`, `ready`, and `text`, the words of the title and description
+  (prefixes; a task key too). The board sorts by `TASK_SORTS` and returns the total; the counts give how many tasks
+  hold each project, assignee, priority and state, each without the query's own terms on that field.
+- **Store version 41: a decimal priority, an agent and a revision on every task** (`minCompatible` stays 34).
+  `tasks.priority_score` holds 0 to 1, higher first; `priorityLabel` reads it as low, medium, high or critical by
+  quarters. The old 0 (urgent) … 4 (low) became 0.875, 0.625, 0.375, 0.1875 and 0.0625, and the integer `priority`
+  column is still written from the score, so an older build reads a familiar number; when an older build writes the
+  integer, a trigger moves the score with it. `tasks.agent` names the agent working on a task, apart from its
+  assignees and its claim. `tasks.revision` is bumped by a trigger on every update, by any build.
+- **`tasks.move(id, { status, before | after }, by)`** puts a project task beside another in its board column by giving
+  it a priority between its neighbours; the answer says when the label changed, and which tasks were spread out again
+  when the neighbours left no room. Into an empty column it needs no neighbour.
+- **A stale write is refused**: `edit`, `assign`, `unassign` and `move` take `{ revision }` and refuse another with
+  `configuration_error`, reason `task.stale`, and the task's current revision. `assign` and `unassign` now bump the
+  task's revision too.
+- **Every task write is in `task_events`**, in the same transaction: new kinds `agent`, `claimed`, `released`,
+  `next-check` (a follow-up time used to leave no event), `resolution`, `verdict`, `close-certainty` and `tags` (a
+  tag added to or removed from a task). The event id only grows, so it orders changes.
+- **`priority:` and `agent:` query fields** on the board: `priority:high`, `priority:none`, `priority:[medium TO
+  critical]`, `priority:[0.6 TO 1]`; `agent:hermes`, `agent:none`.
+- **The `task` entity** may carry `priority_label`, `agent`, `revision`, `assignments`, `ready` and `blocked_by`, as a
+  project task list gives them.
+
+### Changed — may break callers
+
+- **A task's `priority` is a number from 0 to 1, higher first**, in `TaskDetails`, `TaskFields` and the task card
+  (`priority_label` beside it); it was 0 (urgent) … 4 (low). Lists order by it highest first. `tasks update
+  --priority` takes low, medium, high, critical or none, and still reads 0–4 as before.
+
 ## 0.512.0 — 01.11.2026
 
 ### Added

package/dist/cli/messenger/tasks-command.js

@@ -8,6 +8,7 @@ import { aheadOf, momentOf } from "../../services/moment.js";
 import { unlistedNote } from "../../services/task-categories.js";
 import { ARRIVAL_WINDOW, applyTaskRulesToChats } from "../../services/task-rules.js";
 import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
+import { PRIORITY_LABELS, priorityOf } from "../../tasks/index.js";
 import { actorOf, holderOf as holderIn } from "../author.js";
 import { environmentOf } from "../context.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE, ownerOnlyOption } from "../effects.js";
@@ -35,6 +36,8 @@ const suggestionLine = ({ as, by, certainty, reason }) => `close suggested: ${as
 const card = (task) => [
     `${task.key}  ${task.status}  ${task.type}  ${task.category ?? "—"}  ${task.title}`,
     `due ${when(task.dueAt)}  next check ${when(task.nextCheckAt)}  source ${task.source ?? "—"}`,
+    ...(task.priorityLabel === null ? [] : [`priority ${task.priorityLabel}`]),
+    ...(task.agent === null ? [] : [`agent ${task.agent}`]),
     ...(task.claimedBy === null ? [] : [`claimed by ${task.claimedBy} until ${when(task.claimedUntil)}`]),
     ...task.assignments.filter((one) => one.role === "assignee").map((one) => `assignee ${one.to}`),
     ...(task.closeSuggestion === null ? [] : [suggestionLine(task.closeSuggestion)]),
@@ -205,11 +208,7 @@ export const tasksCommand = (messenger) => {
         .description("update a task's text, schedule, category, assignees, priority or parent; nothing reaches the messenger")
         .argument("<task>", "the task's id or key, as tasks list shows it")
         .option("--category <name>", `${categoryHelp}; a change is kept in the task's history`)
-        .option("--priority <n>", "priority from 0 (urgent) through 4 (low)", (value) => {
-        if (!/^[0-4]$/.test(value))
-            throw new CliError("validation_error", "--priority takes 0 through 4");
-        return Number(value);
-    })
+        .option("--priority <n>", `${PRIORITY_LABELS.join(", ")} or none; 0 (urgent) … 4 (low) still read as before`, priorityOf)
         .option("--parent <id>", "parent task in the same project; none clears it"), "send Alex the API token").action(async function (id) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tasks.update");

package/dist/entities/index.d.ts

@@ -4765,6 +4765,18 @@ export declare const ENTITIES: {
         readonly chat: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
         readonly source_message: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
         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>;
+        readonly agent: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        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>;
+        readonly ready: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        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>;
@@ -4822,6 +4834,9 @@ export declare const ENTITIES: {
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -4923,6 +4938,9 @@ export declare const ENTITIES: {
             readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -5025,6 +5043,9 @@ export declare const ENTITIES: {
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -5155,6 +5176,9 @@ export declare const ENTITIES: {
             readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -5250,6 +5274,9 @@ export declare const ENTITIES: {
             readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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.d.ts

@@ -9,6 +9,9 @@ export declare const taskCard: v.StrictObjectSchema<{
     readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -110,6 +113,9 @@ export declare const taskCreated: v.StrictObjectSchema<{
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -212,6 +218,9 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
     readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -342,6 +351,9 @@ export declare const taskMerge: v.StrictObjectSchema<{
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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>;
@@ -437,6 +449,9 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], 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

@@ -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/runs/error-detail.js

@@ -117,6 +117,8 @@ export const endpointTemplate = (raw) => {
 /** A phone number as people type it with its country code, and one written as digits only without the "+". */
 export const INTERNATIONAL_PHONE = /\+\d[\d\s()-]{6,}\d/.source;
 export const BARE_PHONE = /(^|[^\w-])\d{11,15}\b/.source;
+/** A WhatsApp jid: `<number>[:device]@s.whatsapp.net`, a group's `<number>-<time>@g.us`, an `@lid` of any length. */
+const MESSENGER_ID = /\b\d+(?:-\d+)?(?::\d+)?@(?:s\.whatsapp\.net|g\.us|c\.us|lid|broadcast|newsletter)\b/g;
 /**
  * An error's sentence with what could be somebody's words or a secret taken out: anything in quotes, an email, a
  * phone number, a secret `withoutSecrets` finds, a bot token, a bearer or a long opaque string, a URL's query, the
@@ -128,6 +130,7 @@ export const redactText = (text) => {
     let out = home && home !== "/" ? text.split(home).join("~") : text;
     out = withoutSecrets(out.replace(/"[^"\n]*"|“[^”\n]*”|«[^»\n]*»/g, '"[redacted]"'))
         .replace(/\b(bearer|basic|token|key|password|secret)(\s*[:=]\s*|\s+)[^\s'"]+/gi, "$1$2[redacted]")
+        .replace(MESSENGER_ID, "[id]")
         .replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, "[email]")
         .replace(new RegExp(INTERNATIONAL_PHONE, "g"), "[number]")
         .replace(new RegExp(BARE_PHONE, "g"), "$1[number]")

package/dist/store/index.d.ts

@@ -5,7 +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 { 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";
@@ -65,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 { BoardCounts, BoardOptions, 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,7 +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 { 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";

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/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.js

@@ -2,7 +2,7 @@ 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 { 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 = {}) => ({
@@ -22,7 +22,11 @@ export const PROJECT_TASK_FIELDS = [
     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("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" }),
@@ -69,6 +73,60 @@ const assigneeWhere = (node) => {
         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: [],
@@ -79,7 +137,8 @@ export const projectTaskColumns = (now) => ({
     kind: { type: "enum", sql: "t.type" },
     project: { where: projectWhere },
     assignee: { where: assigneeWhere },
-    priority: { type: "num", sql: "t.priority" },
+    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)}`) },
@@ -104,14 +163,14 @@ const STATE_ORDER = `CASE t.status ${TASK_STATES.map((state, at) => `WHEN '${sta
 export const boardOrder = (sort, descending) => {
     const direction = descending ? "DESC" : "ASC";
     const first = {
-        priority: [`coalesce(t.priority, 5) ${direction}`],
+        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, "coalesce(t.priority, 5)", "t.created_at", "t.id"].join(", ");
+    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) => {

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

@@ -52,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-relations.js

@@ -155,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 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 ?")
+                .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

@@ -197,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
@@ -214,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,6 +1,6 @@
 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";
@@ -10,15 +10,17 @@ 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;
@@ -50,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;
@@ -71,6 +78,26 @@ 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;
@@ -93,8 +120,9 @@ export interface BoardCounts {
         name: string | null;
         count: number;
     }[];
+    /** By label; `none` for the tasks with no priority. */
     priority: {
-        value: number | null;
+        value: PriorityLabel | "none";
         count: number;
     }[];
     state: {
@@ -114,9 +142,15 @@ export interface TaskEvent {
 /** 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>;
@@ -159,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;

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

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { TASK_TYPES, WORK_TASK_TYPES } from "../../domain/knowledge.js";
-import { isClosedState, TASK_STATES } from "../../tasks/index.js";
+import { checkedScore, isClosedState, legacyPriority, PRIORITY_LABELS, priorityBand, priorityLabel, TASK_STATES, } from "../../tasks/index.js";
 import { folded } from "./folded.js";
 import { authorActor } from "./memories.js";
 import { CORPORA, drainCorpus } from "./note-index.js";
@@ -28,6 +28,14 @@ export const TASK_EVENT_KINDS = [
     "unlinked",
     "category",
     "close-suggestion",
+    "agent",
+    "claimed",
+    "released",
+    "next-check",
+    "resolution",
+    "verdict",
+    "close-certainty",
+    "tags",
 ];
 const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
 export const recordTaskEvent = (database, task, actor, kind, changes, at) => {
@@ -45,10 +53,11 @@ const textOf = (value, what, max) => {
 const claimOf = (row, at) => row.claimed_by != null && Number(row.claimed_until) >= at
     ? { claimedBy: String(row.claimed_by), claimedUntil: iso(row.claimed_until) }
     : { claimedBy: null, claimedUntil: null };
-const priorityOf = (value) => {
-    if (value !== null && !(Number.isInteger(value) && value >= 0 && value <= 4))
-        throw new CliError("validation_error", "a priority is 0 (urgent) to 4 (low)");
-    return value;
+/** What a write made on a stale copy is refused with: the revision the caller read is not the task's now. */
+export const checkRevision = (row, expected) => {
+    if (expected === undefined || Number(row.revision) === expected)
+        return;
+    throw new CliError("configuration_error", `task ${String(row.key)} changed since revision ${expected}; it is at ${String(row.revision)}: read it again`, { reason: "task.stale", revision: Number(row.revision) });
 };
 export const workTaskOperationsOver = (context) => {
     const { database, now } = context;
@@ -104,7 +113,10 @@ export const workTaskOperationsOver = (context) => {
             description: row.description == null ? null : String(row.description),
             type: row.type,
             status: row.status,
-            priority: row.priority == null ? null : Number(row.priority),
+            priority: row.priority_score == null ? null : Number(row.priority_score),
+            priorityLabel: priorityLabel(row.priority_score == null ? null : Number(row.priority_score)),
+            agent: row.agent == null ? null : String(row.agent),
+            revision: Number(row.revision),
             parent: row.parent_id == null ? null : reference(Number(row.parent_id)),
             source: row.source_locator == null ? null : String(row.source_locator),
             dueAt: iso(row.due_at),
@@ -125,6 +137,7 @@ export const workTaskOperationsOver = (context) => {
         };
     };
     const stemmerFor = stemmerCache();
+    const touch = (task, at) => database.prepare("UPDATE tasks SET updated_at = ? WHERE id = ?").run(at, task);
     const boardWhere = (query, zone, at) => {
         if (query === undefined)
             return { sql: BOARD_SCOPE, params: [] };
@@ -143,13 +156,13 @@ export const workTaskOperationsOver = (context) => {
         const at = now();
         const set = [];
         const values = [];
-        const change = (column, value, event) => {
+        const change = (column, value, event, key = column) => {
             if ((before[column] ?? null) === value)
                 return;
             set.push(`${column} = ?`);
             values.push(value);
             if (event)
-                recordTaskEvent(database, task, actor, event, { [column]: [before[column] ?? null, value] }, at);
+                recordTaskEvent(database, task, actor, event, { [key]: [before[column] ?? null, value] }, at);
         };
         if (fields.title !== undefined) {
             const title = textOf(fields.title, "a task's title", 300);
@@ -158,15 +171,19 @@ export const workTaskOperationsOver = (context) => {
         }
         if (fields.description !== undefined)
             change("description", fields.description === null ? null : textOf(fields.description, "a description", 20000), created ? undefined : "description");
-        if (fields.priority !== undefined)
-            change("priority", priorityOf(fields.priority), "priority");
+        if (fields.priority !== undefined) {
+            const score = fields.priority === null ? null : checkedScore(fields.priority);
+            change("priority_score", score, "priority", "priority");
+            change("priority", legacyPriority(score));
+        }
+        if (fields.agent !== undefined)
+            change("agent", fields.agent === null ? null : textOf(fields.agent, "an agent's name", 100), "agent");
         if (fields.parent !== undefined)
             change("parent_id", fields.parent === null ? null : parentOf(task, Number(before.project_id), fields.parent));
         if (fields.dueAt !== undefined)
             change("due_at", fields.dueAt === null ? null : fields.dueAt.getTime(), "due");
-        // Moved on every look, so no event: the history would be mostly check-ins.
         if (fields.nextCheckAt !== undefined)
-            change("next_check_at", fields.nextCheckAt === null ? null : fields.nextCheckAt.getTime());
+            change("next_check_at", fields.nextCheckAt === null ? null : fields.nextCheckAt.getTime(), "next-check");
         if (fields.status !== undefined) {
             if (!TASK_STATES.includes(fields.status))
                 throw new CliError("validation_error", `a task's status is one of ${TASK_STATES.join(", ")}`);
@@ -211,6 +228,67 @@ export const workTaskOperationsOver = (context) => {
             return;
         database.prepare(`UPDATE tasks SET ${set.join(", ")}, updated_at = ? WHERE id = ?`).run(...values, at, task);
     };
+    /** The column's tasks in board order, the moving one left out; no priority reads as 0, the bottom of low. */
+    const columnOf = (task, status) => database
+        .prepare(`SELECT t.id, t.key, coalesce(t.priority_score, 0) AS score FROM tasks t WHERE ${BOARD_SCOPE} ` +
+        `AND t.status = ? AND t.id <> ? ORDER BY ${boardOrder("priority", false)}`)
+        .all(status, task)
+        .map((row) => ({ id: Number(row.id), key: String(row.key), score: Number(row.score) }));
+    const moveTask = (task, row, move, actor) => {
+        if (move.before !== undefined && move.after !== undefined)
+            throw new CliError("validation_error", "give --before or --after, not both");
+        if (!database.prepare(`SELECT 1 FROM tasks t WHERE t.id = ? AND ${BOARD_SCOPE}`).get(task))
+            throw new CliError("validation_error", "only a project task moves on the board");
+        const status = move.status ?? row.status;
+        const column = columnOf(task, status);
+        const neighbour = move.before ?? move.after;
+        if (neighbour === undefined) {
+            if (column.length > 0 || move.status === undefined)
+                throw new CliError("validation_error", "say where it goes: --before <key> or --after <key>");
+            const from = priorityLabel(row.priority_score == null ? null : Number(row.priority_score));
+            edit(task, { status: move.status }, actor);
+            return { label: { from, to: from, changed: false }, renumbered: [] };
+        }
+        const target = required(neighbour);
+        const at = column.findIndex(({ id }) => id === target);
+        if (at === -1)
+            throw new CliError("validation_error", `${move.before ?? move.after} is not a ${status} task of a project; a task moves beside one in its column`);
+        const index = move.before === undefined ? at + 1 : at;
+        const above = column[index - 1];
+        const below = column[index];
+        const STEP = 1 / 64;
+        const score = above === undefined
+            ? Math.min(1, (below?.score ?? 0) + STEP)
+            : below === undefined
+                ? Math.max(0, above.score - STEP)
+                : (above.score + below.score) / 2;
+        const roomy = (above === undefined || score < above.score) && (below === undefined || score > below.score);
+        const from = priorityLabel(row.priority_score == null ? null : Number(row.priority_score));
+        const renumbered = [];
+        let given = score;
+        if (!roomy || (above !== undefined && below !== undefined && above.score - below.score < 1e-9)) {
+            const label = priorityLabel((above ?? below)?.score ?? 0);
+            const band = priorityBand(label);
+            const inBand = (one) => priorityLabel(one.score) === label;
+            const ordered = [...column.slice(0, index), { id: task, key: String(row.key), score }, ...column.slice(index)];
+            const spread = ordered.filter((one) => one.id === task || inBand(one));
+            const gap = (band.to - band.from) / (spread.length + 1);
+            spread.forEach((one, place) => {
+                const value = band.to - gap * (place + 1);
+                if (one.id === task) {
+                    given = value;
+                    return;
+                }
+                if (one.score === value)
+                    return;
+                edit(one.id, { priority: value }, actor);
+                renumbered.push(one.key);
+            });
+        }
+        edit(task, { priority: given, ...(move.status === undefined ? {} : { status: move.status }) }, actor);
+        const to = priorityLabel(given);
+        return { label: { from, to, changed: from !== to }, renumbered };
+    };
     return {
         ...taskRelationsStoreOver(context, (task, actor, kind, changes, at) => recordTaskEvent(database, task, actor, kind, changes, at)),
         create: (input, by) => {
@@ -237,16 +315,29 @@ export const workTaskOperationsOver = (context) => {
             });
             return details(made);
         },
-        edit: async (id, fields, by) => {
+        edit: async (id, fields, by, check = {}) => {
             const task = required(id);
-            write(database, () => edit(task, fields, authorActor(context, by).actor));
+            write(database, () => {
+                checkRevision(rowById(task), check.revision);
+                edit(task, fields, authorActor(context, by).actor);
+            });
             return details(task);
         },
-        assign: (id, { to, role }, by) => {
+        move: async (id, move, by, check = {}) => {
+            const task = required(id);
+            return write(database, () => {
+                const row = rowById(task);
+                checkRevision(row, check.revision);
+                const moved = moveTask(task, row, move, authorActor(context, by).actor);
+                return { ...moved, task: details(task) };
+            });
+        },
+        assign: (id, { to, role }, by, check = {}) => {
             if (!TASK_ROLES.includes(role))
                 throw new CliError("validation_error", `a role is one of ${TASK_ROLES.join(", ")}`);
             const task = required(id);
             write(database, () => {
+                checkRevision(rowById(task), check.revision);
                 const person = personOf(to);
                 const held = database
                     .prepare("SELECT 1 FROM task_assignments WHERE task_id = ? AND assignee_type = 'person' AND assignee_id = ? AND role = ?")
@@ -257,6 +348,7 @@ export const workTaskOperationsOver = (context) => {
                 database
                     .prepare("INSERT INTO task_assignments (task_id, assignee_type, assignee_id, role, created_at, updated_at) VALUES (?, 'person', ?, ?, ?, ?)")
                     .run(task, person, role, at, at);
+                touch(task, at);
                 const changes = { [role]: [null, `person:${person}`] };
                 recordTaskEvent(database, task, authorActor(context, by).actor, "assigned", changes, at);
             });
@@ -283,17 +375,20 @@ export const workTaskOperationsOver = (context) => {
                 .get(thing.id);
             return row ? `person:${String(row.id)}` : undefined;
         },
-        unassign: async (id, { to, role }, by) => {
+        unassign: async (id, { to, role }, by, check = {}) => {
             const task = required(id);
             write(database, () => {
+                checkRevision(rowById(task), check.revision);
                 const person = personOf(to);
                 const removed = database
                     .prepare("DELETE FROM task_assignments WHERE task_id = ? AND assignee_type = 'person' AND assignee_id = ? AND role = ?")
                     .run(task, person, role).changes;
                 if (removed === 0)
                     return;
+                const at = now();
+                touch(task, at);
                 const changes = { [role]: [`person:${person}`, null] };
-                recordTaskEvent(database, task, authorActor(context, by).actor, "unassigned", changes, now());
+                recordTaskEvent(database, task, authorActor(context, by).actor, "unassigned", changes, at);
             });
             return details(task);
         },
@@ -317,17 +412,23 @@ export const workTaskOperationsOver = (context) => {
                 .prepare("SELECT * FROM tasks t WHERE deleted_at IS NULL AND (? IS NULL OR project_id = ?) AND (? IS NULL OR type = ?) " +
                 "AND (? IS NULL OR status = ?) AND (? IS NULL OR EXISTS (SELECT 1 FROM task_assignments a " +
                 "WHERE a.task_id = t.id AND a.assignee_type = 'person' AND a.assignee_id = ?)) " +
-                `AND (${where?.sql || "1"}) ORDER BY coalesce(priority, 5), created_at, id LIMIT ?`)
+                `AND (${where?.sql || "1"}) ORDER BY priority_score IS NULL, priority_score DESC, created_at, id LIMIT ?`)
                 .all(projectId, projectId, type ?? null, type ?? null, status ?? null, status ?? null, person, person, ...(where?.params ?? []), Math.min(Math.max(limit, 1), 500))
                 .map(detailsOf);
         },
         claim: async (id, holder, until) => {
             const task = required(id);
             const at = now();
-            const won = write(database, () => database
-                .prepare("UPDATE tasks SET claimed_by = ?, claimed_until = ?, updated_at = ? " +
-                "WHERE id = ? AND status NOT IN ('done', 'dismissed') AND (claimed_by IS NULL OR claimed_until < ? OR claimed_by = ?) RETURNING id")
-                .get(holder, until.getTime(), at, task, at, holder));
+            const won = write(database, () => {
+                const before = claimOf(rowById(task), at).claimedBy;
+                const claimed = database
+                    .prepare("UPDATE tasks SET claimed_by = ?, claimed_until = ?, updated_at = ? " +
+                    "WHERE id = ? AND status NOT IN ('done', 'dismissed') AND (claimed_by IS NULL OR claimed_until < ? OR claimed_by = ?) RETURNING id")
+                    .get(holder, until.getTime(), at, task, at, holder);
+                if (claimed)
+                    recordTaskEvent(database, task, null, "claimed", { claimed_by: [before, holder] }, at);
+                return claimed;
+            });
             if (!won) {
                 const row = rowById(task);
                 if (isClosedState(String(row.status)))
@@ -346,9 +447,12 @@ export const workTaskOperationsOver = (context) => {
                     throw new CliError("validation_error", `${claimedBy} holds task ${String(row.key)}; only they or the owner release it`, {
                         reason: "task.claimed",
                     });
+                const at = now();
                 database
                     .prepare("UPDATE tasks SET claimed_by = NULL, claimed_until = NULL, updated_at = ? WHERE id = ?")
-                    .run(now(), task);
+                    .run(at, task);
+                if (claimedBy !== null)
+                    recordTaskEvent(database, task, null, "released", { claimed_by: [claimedBy, null] }, at);
             });
             return details(task);
         },
@@ -384,13 +488,20 @@ export const workTaskOperationsOver = (context) => {
                 count: Number(row.n),
             }))
                 .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
-            const priorities = new Map(grouped("priority", "t.priority", "", "t.priority").map((row) => [row.priority, Number(row.n)]));
+            const priorities = new Map();
+            for (const row of grouped("priority", "t.priority_score", "", "t.priority_score")) {
+                const label = priorityLabel(row.priority_score == null ? null : Number(row.priority_score)) ?? "none";
+                priorities.set(label, (priorities.get(label) ?? 0) + Number(row.n));
+            }
             const states = new Map(grouped("state", "t.status", "", "t.status").map((row) => [row.status, Number(row.n)]));
             return {
                 total: countOf(boardWhere(query, zone, at)),
                 project,
                 assignee,
-                priority: [0, 1, 2, 3, 4, null].map((value) => ({ value, count: priorities.get(value) ?? 0 })),
+                priority: [...[...PRIORITY_LABELS].reverse(), "none"].map((value) => ({
+                    value,
+                    count: priorities.get(value) ?? 0,
+                })),
                 state: TASK_STATES.map((value) => ({ value, count: states.get(value) ?? 0 })),
             };
         },
@@ -431,6 +542,6 @@ export const workTasksOver = (context) => {
     return {
         ...operations,
         create: async (input, by) => operations.create(input, by),
-        assign: async (id, assignment, by) => operations.assign(id, assignment, by),
+        assign: async (id, assignment, by, check) => operations.assign(id, assignment, by, check),
     };
 };

package/dist/tasks/index.d.ts

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

package/dist/tasks/index.js

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

package/dist/tasks/priority.d.ts

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

package/dist/tasks/priority.js

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

package/package.json

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

package/parity.json

@@ -3678,18 +3678,14 @@
       }
     },
     "projects": {
-      "in": [],
+      "in": ["max", "tg"],
       "planned": {
-        "max": "max-cli#886, on the cli-core release with this row",
-        "tg": "tg-cli#798, on the cli-core release with this row",
         "wa": "wa backlog: mount projectsCommand once wa is on cli-core 0.504.0"
       }
     },
     "projects evidence": {
-      "in": [],
+      "in": ["max", "tg"],
       "planned": {
-        "max": "max-cli#886, on the cli-core release with this row",
-        "tg": "tg-cli#798, on the cli-core release with this row",
         "wa": "wa backlog: mount projectsCommand once wa is on cli-core 0.504.0"
       },
       "options": {