@wirecat/cli-core 0.528.0 → 0.530.0

package/CHANGELOG.md

@@ -7,6 +7,51 @@ shape of this file.
 
 ## Unreleased
 
+## 0.530.0 — 01.11.2026
+
+### Added
+
+- **`configCommand(app, config, { ownerOnly })`**: settings and permission keys an agent with `mcp.authority` still
+  cannot change over MCP, beside `mcp.*` and `bot.api` — for a mail CLI, the server hosts its password goes to, and
+  the key that lets an agent mail other people. A permission key there covers the keys under it.
+- **`safeName` from `./files`**: the file-name cleaner downloads use (no path, no leading dot, no control or direction
+  character; Windows' reserved names refused), for a CLI that saves a file someone else named.
+
+## 0.529.0 — 01.11.2026
+
+### Added
+
+- **`people.add({ name })`** adds a person known by name only, to assign a task to before any message names them.
+  `tasks.taskPeople({ limit })` lists everyone the store knows, the owner first, then by how many live tasks name
+  them; it took only the owner and people with a task role.
+- **`tasks.create` takes `status`**, so a task starts in its column with its due date and agent in one write.
+- **`priorityOf` reads a score with a decimal point**, `0.0` to `1.0`; a bare `0` … `4` keeps the old scale.
+- **`when:` in the project task query**: `overdue`, `today`, `upcoming` (the 7 days after today), `later` or
+  `none`, by the owner's calendar day. `boardCounts` counts them in `due`, and counts tasks by `agent`; each project
+  count carries the `ref` a task's `project` names. A task carries `projectKey` and `projectName`
+  (`project_key`, `project_name` in the `task` and `task_card` entities).
+- **A findings batch can be about a person, an organization, a task or nobody**, and cite a `note:`: a fact finding
+  takes an optional `subject` and may name no project; a task finding still names its project. A batch holds at most
+  one project. `contextRecordOf` reads notes, so a note's fingerprint can be cited. `evidenceFindings.list({ project })`
+  also finds a batch whose findings name that project.
+- **`dateOrNone`** from `./cli`: the `--due` parser of the shared `tasks update`, for a CLI's own `tasks add`.
+
+### Fixed
+
+- **`overdue:true` no longer matches a task due later today**: it is open work due before today, in the owner's zone.
+- **A task's history gives due dates and other times as ISO**, as the task does, not epoch milliseconds.
+- **Scoring mail senders no longer hides a broken store.** `scoreSenders` treated any failure of the account lookup
+  as "no such account" and returned quietly; now only `not_found` does, and a locked or damaged store fails the
+  sync as it does elsewhere.
+
+### Changed — may break callers
+
+- **`EvidenceFindingsBatch.project` is `null`** when the findings name no project, and the batch carries `subject`.
+  A finding's `project` is optional in `FindingsInput`; meeting findings still require it.
+- **Needs `@wirecat/cli-base` 0.71.x** (peer range `>=0.71.0 <0.72.0`, was 0.68.x). 0.71.0 lets `--to` take an e-mail
+  address and `--subject` a subject line in the shared command vocabulary, which mail-cli uses. A CLI on cli-base
+  0.68 or 0.69 moves to 0.71 together with this version.
+
 ## 0.528.0 — 01.11.2026
 
 ### Added

package/dist/cli/config-command.d.ts

@@ -6,8 +6,18 @@ import { type Configuration } from "./settings.js";
  * The settings in force and where each came from, and changing them. Printed whole: no field the
  * configuration accepts can hold a secret — the schema has nowhere to put one.
  */
-export declare const configCommand: (app: AppIdentity, config: Configuration, { permissionKey }?: {
+/**
+ * Settings and permission keys an agent with `mcp.authority` still may not change, beyond the ones that let it in:
+ * where the password goes (a server host), or a permission the app reads only from the owner's file.
+ */
+export interface OwnerOnlySettings {
+    settings?: readonly string[];
+    /** A key here covers the keys under it too: `messages.send.others` covers `messages.send.others.x`. */
+    permissions?: readonly string[];
+}
+export declare const configCommand: (app: AppIdentity, config: Configuration, { permissionKey, ownerOnly, }?: {
     permissionKey?: PermissionKeySource | undefined;
+    ownerOnly?: OwnerOnlySettings;
 }) => Command;
 /**
  * A key no command or write is checked against would be saved and do nothing (BUG-137) — whether it

package/dist/cli/config-command.js

@@ -10,11 +10,7 @@ import { knownBeside, knownPermissionKeys, unknownPermissionIssues, } from "./pe
 import { fromFile, NONE_NAMED } from "./settings.js";
 import { nextStep } from "./steps.js";
 import { changeStoreSetting, isStoreSetting, offersStoreSetting, storeSettings, storeSettingsOf, } from "./store-settings.js";
-/**
- * The settings in force and where each came from, and changing them. Printed whole: no field the
- * configuration accepts can hold a secret — the schema has nowhere to put one.
- */
-export const configCommand = (app, config, { permissionKey = config.permissions } = {}) => {
+export const configCommand = (app, config, { permissionKey = config.permissions, ownerOnly = {}, } = {}) => {
     const command = new Command("config").description("the settings in force, and where each one came from");
     // Only a messenger has bots, and with them the personal and bot sections of the file. Elsewhere the options stay
     // accepted, so a script that passes one still runs, but help, `commands --json` and MCP leave them out.
@@ -120,7 +116,7 @@ export const configCommand = (app, config, { permissionKey = config.permissions
                 throw new CliError("permission_error", `this process is locked to profile ${settings.profile} (${lock}) — ${root ? setting : "--defaults"} changes other profiles`);
             }
             if (environmentOf(this).agent)
-                refuseGuardedKey(setting, action === "set" ? String(given) : undefined);
+                refuseGuardedKey(setting, action === "set" ? String(given) : undefined, ownerOnly);
             if (action === "set")
                 refuseUnknownKey(this, setting, String(given), permissionKey);
             const saved = config.changeSetting(settings.configPath, {
@@ -166,7 +162,11 @@ export const refuseUnknownKey = (command, setting, value, permissionKey) => {
  * profile, in the defaults, or by replacing `permissions` whole. Only the owner, in a terminal, turns it on or off
  * (NEED-1662, NEED-1679).
  */
-const refuseGuardedKey = (setting, value) => {
+const refuseGuardedKey = (setting, value, ownerOnly) => {
+    if (ownerOnly.settings?.includes(setting))
+        throw new CliError("permission_error", `an agent cannot change ${setting} — the owner sets it in a terminal`, {
+            setting,
+        });
     const keys = setting.startsWith("permissions.")
         ? [setting.slice("permissions.".length)]
         : setting === "permissions"
@@ -174,11 +174,13 @@ const refuseGuardedKey = (setting, value) => {
                 ? ["mcp"]
                 : objectKeys(value)
             : [];
-    const guarded = keys.some((key) => key === BOT_API_KEY || key.startsWith(`${BOT_API_KEY}.`))
+    const under = (key, guarded) => key === guarded || key.startsWith(`${guarded}.`);
+    const listed = keys.flatMap((key) => (ownerOnly.permissions ?? []).filter((guarded) => under(key, guarded)));
+    const guarded = keys.some((key) => under(key, BOT_API_KEY))
         ? BOT_API_KEY
-        : keys.some((key) => key === "mcp" || key.startsWith("mcp."))
+        : keys.some((key) => under(key, "mcp"))
             ? AUTHORITY_KEY
-            : undefined;
+            : listed[0];
     if (!guarded)
         return;
     throw new CliError("permission_error", `an agent cannot change permissions.${guarded} — the owner sets it in a terminal`, { permission: guarded });

package/dist/cli/index.d.ts

@@ -106,6 +106,7 @@ export { STEMS_EVERY_MS, STEMS_SLICE_MS, type StemFills, stemFills } from "./mes
 export type { Running, ServerOptions, ServerProcess, ServerSystem } from "./messenger/server-command.js";
 export { storeSummary } from "./messenger/store-maintenance-command.js";
 export { type Saving, stored } from "./messenger/stored.js";
+export { dateOrNone } from "./messenger/tasks-command.js";
 export { MODEL_CATALOGUE_QUERY, type ModelCatalogueOptions } from "./model-catalogue-command.js";
 export { window, withPaging } from "./paging.js";
 export { type CommandPermissions, commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, type PermissionKeyOf, type PermissionKeySource, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";

package/dist/cli/index.js

@@ -95,6 +95,7 @@ export { DAY_MS, FIRST_FETCH_MS, memberFetches } from "./messenger/serve-members
 export { STEMS_EVERY_MS, STEMS_SLICE_MS, stemFills } from "./messenger/serve-stems.js";
 export { storeSummary } from "./messenger/store-maintenance-command.js";
 export { stored } from "./messenger/stored.js";
+export { dateOrNone } from "./messenger/tasks-command.js";
 export { MODEL_CATALOGUE_QUERY } from "./model-catalogue-command.js";
 export { window, withPaging } from "./paging.js";
 export { commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";

package/dist/cli/messenger/download-command.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 import type { Id } from "../../domain/models.js";
-export { downloadMessage, type Saved, safeName, save } from "../../services/file-download.js";
+export { safeName } from "../../files/safe-name.js";
+export { downloadMessage, type Saved, save } from "../../services/file-download.js";
 import { type Messenger } from "./context.js";
 /** `messages download`: every file of one message, or with `--all` of a whole chat, never over a file already there. */
 export declare const downloadSubcommand: (messages: Command, messenger: Messenger) => Command;

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

@@ -7,7 +7,8 @@ import { NOT_FILES } from "../../domain/attachments.js";
 import { FETCHING, keyOf } from "../../services/archive.js";
 import { batchProgress, mergeBatches } from "../../services/batch.js";
 import { saveFiles } from "../../services/file-download.js";
-export { downloadMessage, safeName, save } from "../../services/file-download.js";
+export { safeName } from "../../files/safe-name.js";
+export { downloadMessage, save } from "../../services/file-download.js";
 import { parseDuration } from "../../domain/duration.js";
 import { OFFLINE } from "../../services/deps.js";
 import { patiently } from "../../services/patience.js";

package/dist/cli/messenger/tasks-command.d.ts

@@ -1,5 +1,7 @@
 import { Command } from "commander";
 import { type Messenger } from "./context.js";
+/** `none` clears a date; anything else is a time ahead. Not `null`: commander stores a parser's `null` as "". */
+export declare const dateOrNone: (flag: string) => (typed: string) => "none" | Date;
 /** What waits on the owner — kept in the local store by `src/tasks/`; nothing here reaches the messenger. */
 export declare const tasksCommand: (messenger: Messenger) => Command;
 export declare const tasksStatsCommand: (messenger: Messenger) => Command;

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

@@ -92,7 +92,7 @@ const pairLine = (pair) => [
     `(${pair.reasons.join(", ")})`,
 ].join("  ");
 /** `none` clears a date; anything else is a time ahead. Not `null`: commander stores a parser's `null` as "". */
-const dateOrNone = (flag) => (typed) => typed.trim().toLowerCase() === "none" ? "none" : new Date(aheadOf(typed, flag));
+export const dateOrNone = (flag) => (typed) => typed.trim().toLowerCase() === "none" ? "none" : new Date(aheadOf(typed, flag));
 const durationOf = (flag) => (typed) => {
     const wanted = typed.trim();
     const ms = Date.now() - momentOf(wanted, flag);

package/dist/cli/shared-command-exports.d.ts

@@ -528,6 +528,7 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
     permissions?: import("./permission-keys.js").CommandPermissions | undefined;
 }, args_2?: {
     permissionKey?: import("./permission-keys.js").PermissionKeySource | undefined;
+    ownerOnly?: import("./config-command.js").OwnerOnlySettings;
 } | undefined) => import("commander").Command;
 export declare const guideCommand: (app: Pick<import("./entry.js").AppIdentity, "command">, options: import("./guide.js").GuideOptions) => import("commander").Command;
 export declare const addMeetingBatchCommand: (program: import("commander").Command, deps: {

package/dist/entities/index.d.ts

@@ -4761,6 +4761,8 @@ export declare const ENTITIES: {
         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 project_key: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly account: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         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>;
@@ -4829,6 +4831,8 @@ export declare const ENTITIES: {
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly key: v.StringSchema<undefined>;
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly project_key: v.StringSchema<undefined>;
+        readonly project_name: v.StringSchema<undefined>;
         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>;
@@ -4933,6 +4937,8 @@ export declare const ENTITIES: {
             readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly key: v.StringSchema<undefined>;
             readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly project_key: v.StringSchema<undefined>;
+            readonly project_name: v.StringSchema<undefined>;
             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>;
@@ -5038,6 +5044,8 @@ export declare const ENTITIES: {
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly key: v.StringSchema<undefined>;
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly project_key: v.StringSchema<undefined>;
+        readonly project_name: v.StringSchema<undefined>;
         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>;
@@ -5171,6 +5179,8 @@ export declare const ENTITIES: {
             readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly key: v.StringSchema<undefined>;
             readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly project_key: v.StringSchema<undefined>;
+            readonly project_name: v.StringSchema<undefined>;
             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>;
@@ -5269,6 +5279,8 @@ export declare const ENTITIES: {
             readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly key: v.StringSchema<undefined>;
             readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly project_key: v.StringSchema<undefined>;
+            readonly project_name: v.StringSchema<undefined>;
             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>;

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

@@ -4,6 +4,8 @@ export declare const taskCard: v.StrictObjectSchema<{
     readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
     readonly key: v.StringSchema<undefined>;
     readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly project_key: v.StringSchema<undefined>;
+    readonly project_name: v.StringSchema<undefined>;
     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>;
@@ -108,6 +110,8 @@ export declare const taskCreated: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly key: v.StringSchema<undefined>;
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly project_key: v.StringSchema<undefined>;
+        readonly project_name: v.StringSchema<undefined>;
         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>;
@@ -213,6 +217,8 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
     readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
     readonly key: v.StringSchema<undefined>;
     readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly project_key: v.StringSchema<undefined>;
+    readonly project_name: v.StringSchema<undefined>;
     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>;
@@ -346,6 +352,8 @@ export declare const taskMerge: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly key: v.StringSchema<undefined>;
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly project_key: v.StringSchema<undefined>;
+        readonly project_name: v.StringSchema<undefined>;
         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>;
@@ -444,6 +452,8 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly key: v.StringSchema<undefined>;
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly project_key: v.StringSchema<undefined>;
+        readonly project_name: v.StringSchema<undefined>;
         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>;

package/dist/entities/task-results.js

@@ -25,6 +25,8 @@ export const taskCard = v.strictObject({
     ref: reference,
     key: text,
     project: reference,
+    project_key: text,
+    project_name: text,
     title: text,
     description: v.nullable(text),
     type: v.picklist(TASK_TYPES),

package/dist/entities/task.d.ts

@@ -19,6 +19,9 @@ export declare const task: v.StrictObjectSchema<{
     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>;
+    /** The project's key and name, as `tasks counts` names it. */
+    readonly project_key: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly account: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     /** The chat it came from, as a `chat:` reference. */
     readonly chat: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;

package/dist/entities/task.js

@@ -22,6 +22,9 @@ export const task = v.strictObject({
     state: v.picklist(TASK_STATES),
     origin: v.optional(v.picklist(TASK_ORIGINS)),
     project: v.optional(v.nullable(text)),
+    /** The project's key and name, as `tasks counts` names it. */
+    project_key: v.optional(v.nullable(text)),
+    project_name: v.optional(v.nullable(text)),
     account: v.optional(text),
     /** The chat it came from, as a `chat:` reference. */
     chat: v.optional(v.nullable(reference)),

package/dist/files/index.d.ts

@@ -4,4 +4,5 @@ export { acquireLock, type FileLock } from "./lock.js";
 export type { NativeWriterLeaseLayout } from "./native-writer-lease.js";
 export { nativeWriterLeaseStore } from "./native-writer-lease.js";
 export { openOrdinaryFile, sameOrdinaryFile, syncDirectory } from "./ordinary-file.js";
+export { safeName } from "./safe-name.js";
 export type { WriterLease, WriterLeaseAcquisition, WriterLeaseInfo, WriterLeaseOptions, WriterLeaseStore, } from "./writer-lease.js";

package/dist/files/index.js

@@ -3,3 +3,4 @@ export { readBoundedUtf8File } from "./bounded-utf8.js";
 export { acquireLock } from "./lock.js";
 export { nativeWriterLeaseStore } from "./native-writer-lease.js";
 export { openOrdinaryFile, sameOrdinaryFile, syncDirectory } from "./ordinary-file.js";
+export { safeName } from "./safe-name.js";

package/dist/files/safe-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A name another person chose cannot climb out of the folder, cannot be a dot file we would then
+ * hide, and carries no control or direction character to rewrite the terminal or disguise its extension.
+ */
+export declare const safeName: (name: string | undefined, platform?: NodeJS.Platform) => string | undefined;

package/dist/files/safe-name.js

@@ -0,0 +1,18 @@
+import { basename } from "node:path";
+/**
+ * A name another person chose cannot climb out of the folder, cannot be a dot file we would then
+ * hide, and carries no control or direction character to rewrite the terminal or disguise its extension.
+ */
+export const safeName = (name, platform = process.platform) => {
+    let plain = name === undefined
+        ? ""
+        : basename(name.replaceAll("\\", "/"))
+            .replace(/[\p{Cc}​-‏‪-‮⁦-⁩]/gu, "")
+            .replace(/^\.+/, "");
+    if (platform === "win32") {
+        plain = plain.replace(/[<>:"|?*]/g, "_").replace(/[. ]+$/, "");
+        if (/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(plain))
+            return undefined;
+    }
+    return plain === "" ? undefined : plain;
+};

package/dist/mail/sender-scores.js

@@ -1,3 +1,4 @@
+import { CliError } from "@wirecat/cli-base";
 import { domainsToAge, groupKey, probeMail } from "./probe.js";
 import { decide } from "./rules.js";
 import { FRAUD_SIGNALS, FREE_MAIL, registrableOf, WEIGHTS } from "./score.js";
@@ -22,7 +23,11 @@ export const scoreSenders = async (store, address, ages, now = Date.now(), rules
     const done = last === undefined ? undefined : JSON.parse(last);
     if (done !== undefined && done.version === SCORE_VERSION && now - done.at < DAY)
         return undefined;
-    const stored = await store.accounts.storedAccount(key).catch(() => null);
+    const stored = await store.accounts.storedAccount(key).catch((error) => {
+        if (error instanceof CliError && error.code === "not_found")
+            return null;
+        throw error;
+    });
     if (stored === null)
         return undefined;
     const items = (await store.mail.emailFacts({ accountId: stored.id })).map((email) => {

package/dist/meetings/findings-rules.d.ts

@@ -6,7 +6,10 @@ export interface FindingEvidence {
 }
 interface FindingBase {
     id: string;
-    project: string;
+    /** Every task finding has one; a fact finding may have none when its rules allow it. */
+    project?: string;
+    /** Who or what a fact is about: `person:`, `organization:`, `task:` or `project:`. */
+    subject?: string;
     evidence: FindingEvidence[];
 }
 export interface FactFinding extends FindingBase {
@@ -54,6 +57,8 @@ export interface FindingsRules {
     /** "cue" */
     cited: string;
     reference: (raw: string) => string;
+    /** A fact finding may name no project, and any finding may name a subject. */
+    anySubject?: boolean;
 }
 export declare const validateFindings: (input: FindingsInput, rules: FindingsRules) => FindingsInput;
 export declare const findingFingerprint: ({ id: _id, ...finding }: Finding) => string;

package/dist/meetings/findings-rules.js

@@ -16,6 +16,7 @@ const fields = (value, allowed, noun) => {
     if (Object.keys(value).some((key) => !allowed.includes(key)))
         invalid(`unknown ${noun} field`);
 };
+const SUBJECT = /^(person|organization|project):[1-9]\d*$|^task:[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
 export const validateFindings = (input, rules) => {
     if (!input || typeof input !== "object" || Buffer.byteLength(JSON.stringify(input), "utf8") > 65536)
         return invalid(`${rules.plural} take at most 65536 UTF-8 bytes`);
@@ -36,9 +37,13 @@ export const validateFindings = (input, rules) => {
         if (!/^[a-zA-Z0-9][a-zA-Z0-9_.:-]*$/.test(id) || ids.has(id))
             return invalid("finding IDs must be unique simple keys");
         ids.add(id);
-        const project = text(finding.project, 64);
-        if (!/^project:[1-9]\d*$/.test(project))
+        const project = finding.project === undefined && rules.anySubject ? undefined : text(finding.project, 64);
+        if (project !== undefined && !/^project:[1-9]\d*$/.test(project))
             return invalid("a finding names a project reference");
+        if (finding.subject !== undefined && (!rules.anySubject || !SUBJECT.test(text(finding.subject, 80))))
+            return invalid("a finding's subject is a person:, organization:, task: or project: reference");
+        if (finding.kind === "task" && project === undefined)
+            return invalid("a task finding names the project the task goes in");
         if (!Array.isArray(finding.evidence) || finding.evidence.length < 1 || finding.evidence.length > 8)
             return invalid(`a finding requires 1–8 cited ${rules.cited}s`);
         const evidence = finding.evidence
@@ -56,9 +61,14 @@ export const validateFindings = (input, rules) => {
             .sort((a, b) => a.reference.localeCompare(b.reference));
         if (new Set(evidence.map((item) => item.reference)).size !== evidence.length)
             return invalid(`duplicate evidence ${rules.cited}`);
-        const base = { id, project, evidence };
+        const base = {
+            id,
+            ...(project === undefined ? {} : { project }),
+            ...(finding.subject === undefined ? {} : { subject: finding.subject }),
+            evidence,
+        };
         if (finding.kind === "fact") {
-            fields(finding, ["id", "project", "evidence", "kind", "type", "statement"], rules.singular);
+            fields(finding, ["id", "project", "subject", "evidence", "kind", "type", "statement"], rules.singular);
             if (!FACT_TYPES.includes(finding.type))
                 return invalid("unknown fact finding type");
             return { ...base, kind: "fact", type: finding.type, statement: text(finding.statement, 2000) };

package/dist/services/file-download.d.ts

@@ -1,5 +1,6 @@
 import type { RefreshedFile } from "../domain/attachments.js";
 import type { Id } from "../domain/models.js";
+import { safeName } from "../files/safe-name.js";
 import type { RemoteFile } from "../ports/messenger.js";
 import { batchProgress } from "./batch.js";
 import type { MessagesService } from "./messages.js";
@@ -39,11 +40,7 @@ export declare const saveFiles: (messages: Pick<MessagesService, "keepDownloaded
         maxErrorPercent: number;
     };
 }>;
-/**
- * A name another person chose cannot climb out of the folder, cannot be a dot file we would then
- * hide, and carries no control or direction character to rewrite the terminal or disguise its extension.
- */
-export declare const safeName: (name: string | undefined, platform?: NodeJS.Platform) => string | undefined;
+export { safeName };
 /**
  * The bytes go to a temporary name first and are then hard-linked to the real one, which fails if the
  * name is taken — so an existing file survives, and an interrupted download leaves no half file under

package/dist/services/file-download.js

@@ -1,9 +1,10 @@
 import { createWriteStream, mkdirSync } from "node:fs";
 import { link, rm } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { CliError } from "@wirecat/cli-base";
+import { safeName } from "../files/safe-name.js";
 import { batchProgress } from "./batch.js";
 /** The files the messenger gave a new reference for while their bytes were read, to save without a path. */
 export const refreshedFiles = (files) => files.flatMap(({ kind, name, position, providerRef }) => providerRef === undefined || Object.keys(providerRef).length === 0
@@ -90,23 +91,7 @@ const EXTENSIONS = {
 };
 /** Telegram sends a photo with no name and no type; it is always a JPEG. */
 const BY_KIND = { photo: "jpg" };
-/**
- * A name another person chose cannot climb out of the folder, cannot be a dot file we would then
- * hide, and carries no control or direction character to rewrite the terminal or disguise its extension.
- */
-export const safeName = (name, platform = process.platform) => {
-    let plain = name === undefined
-        ? ""
-        : basename(name.replaceAll("\\", "/"))
-            .replace(/[\p{Cc}​-‏‪-‮⁦-⁩]/gu, "")
-            .replace(/^\.+/, "");
-    if (platform === "win32") {
-        plain = plain.replace(/[<>:"|?*]/g, "_").replace(/[. ]+$/, "");
-        if (/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(plain))
-            return undefined;
-    }
-    return plain === "" ? undefined : plain;
-};
+export { safeName };
 /**
  * The bytes go to a temporary name first and are then hard-linked to the real one, which fails if the
  * name is taken — so an existing file survives, and an interrupted download leaves no half file under

package/dist/store/evidence-findings.d.ts

@@ -20,7 +20,10 @@ export interface EvidenceFindingsReceipt extends FindingsReceipt {
 }
 export interface EvidenceFindingsBatch {
     id: string;
-    project: string;
+    /** `null` when its findings name no one project. */
+    project: string | null;
+    /** Who or what every finding is about, when they agree: a project, person, organization or task; else `null`. */
+    subject: string | null;
     input: FindingsInput;
     fingerprint: string;
     status: "proposed" | "reviewed";

package/dist/store/evidence-findings.js

@@ -3,13 +3,19 @@ import { formatLocator, parseLocator } from "../domain/locator.js";
 import { validateFindings } from "../meetings/index.js";
 export const EVIDENCE_FINDINGS_KIND = "evidence_findings";
 const reference = (raw) => {
-    if (/^document:[1-9]\d*$/.test(raw))
+    if (/^(document|note):[1-9]\d*$/.test(raw))
         return raw;
     try {
         return formatLocator(parseLocator(raw));
     }
     catch {
-        throw new CliError("validation_error", "finding evidence is a msg: or document: reference");
+        throw new CliError("validation_error", "finding evidence is a msg:, document: or note: reference");
     }
 };
-export const validateEvidenceFindings = (input) => validateFindings(input, { plural: "evidence findings", singular: "evidence finding", cited: "reference", reference });
+export const validateEvidenceFindings = (input) => validateFindings(input, {
+    plural: "evidence findings",
+    singular: "evidence finding",
+    cited: "reference",
+    reference,
+    anySubject: true,
+});

package/dist/store/people.d.ts

@@ -59,6 +59,10 @@ export interface PeopleStore extends AccountPeople {
     unlinkIdentity(identity: IdentityRef, options: LinkOptions): Promise<PersonRecord>;
     /** The identity, and everyone linked with it, is the owner. */
     linkToOwner(identity: IdentityRef): Promise<PersonRecord>;
+    /** A person known by name only, with no identity yet: someone to assign a task to before any message names them. */
+    add(input: {
+        name: string;
+    }): Promise<PersonRecord>;
 }
 export declare const accountPeopleOver: (context: StoreContext) => AccountPeople;
 export declare const peopleStoreOver: (context: StoreContext, keyed: AccountPeople) => PeopleStore;

package/dist/store/people.js

@@ -62,6 +62,18 @@ export const peopleStoreOver = (context, keyed) => {
         personOf: async (identity) => personLinks.personOf(context, identity),
         personSeenInAccounts: async (uid, accountIds) => personSeenInAccounts(context, uid, accountIds),
         personByUid: async (uid) => personLinks.personByUid(context, uid),
+        add: async ({ name }) => {
+            const text = typeof name === "string" ? name.trim() : "";
+            if (!text || text.length > 200)
+                throw new CliError("validation_error", "a person's name takes 1–200 characters");
+            const id = write(database, () => {
+                const at = context.now();
+                return Number(database
+                    .prepare("INSERT INTO persons (name, owner, created_at, updated_at) VALUES (?, 0, ?, ?) RETURNING id")
+                    .get(text, at, at)?.id);
+            });
+            return personLinks.personByUid(context, String(id));
+        },
         owner: async () => {
             try {
                 return personLinks.personByUid(context, String(ownerPerson(database).id));

package/dist/store/sqlite/context-evidence.js

@@ -258,6 +258,20 @@ export const contextRecordOf = (database, ref) => {
             }
             : null;
     }
+    const note = /^note:([1-9]\d*)$/.exec(ref);
+    if (note) {
+        const row = database
+            .prepare("SELECT title, body, revision FROM notes WHERE id=? AND deleted_at IS NULL")
+            .get(Number(note[1]));
+        return row
+            ? {
+                ref,
+                title: row.title == null ? null : String(row.title),
+                text: String(row.body),
+                revision: Number(row.revision),
+            }
+            : null;
+    }
     let at;
     try {
         at = parseLocator(ref);

package/dist/store/sqlite/evidence-findings.js

@@ -33,13 +33,16 @@ export const evidenceFindingsStoreOver = (context) => {
             return invalid("stored findings exceed the read budget");
         return proposals.get(id);
     };
+    /** The one project its findings name, or `null` when none does. */
+    const projectOf = (input) => input.findings.find((finding) => finding.project)?.project ?? null;
     const view = (proposal) => {
         const input = proposal.payload;
-        if (!input || !proposal.target || !["proposed", "approved", "rejected"].includes(proposal.status))
+        if (!input || !["proposed", "approved", "rejected"].includes(proposal.status))
             return invalid("invalid stored findings batch");
         return {
             id: proposal.id,
-            project: proposal.target,
+            project: projectOf(input),
+            subject: proposal.target,
             input: { schemaVersion: 1, key: input.key, extractor: input.extractor, findings: input.findings },
             fingerprint: findingHash({ input, author: proposal.proposedBy.id }),
             status: proposal.status === "proposed" ? "proposed" : "reviewed",
@@ -94,9 +97,12 @@ export const evidenceFindingsStoreOver = (context) => {
     return {
         stage: async (raw, rawAgent) => {
             const input = validateEvidenceFindings(raw);
-            const projects = new Set(input.findings.map((finding) => finding.project));
-            if (projects.size !== 1)
-                return invalid("an evidence findings batch is about one project");
+            const projects = new Set(input.findings.flatMap((finding) => finding.project ?? []));
+            if (projects.size > 1)
+                return invalid("an evidence findings batch is about one project at most");
+            const subjects = new Set(input.findings.map((finding) => finding.subject));
+            const shared = subjects.size === 1 ? [...subjects][0] : undefined;
+            const target = shared ?? [...projects][0];
             const by = findingsAgent(rawAgent);
             return write(database, () => {
                 const { actor } = authorActor(context, by);
@@ -118,7 +124,7 @@ export const evidenceFindingsStoreOver = (context) => {
                 return view(proposals.propose({
                     kind: EVIDENCE_FINDINGS_KIND,
                     by,
-                    target: [...projects][0],
+                    ...(target === undefined ? {} : { target }),
                     payload: { ...input, inputHash, snapshotHash, snapshotParts, agentModel: by.model ?? null },
                 }));
             });
@@ -134,8 +140,10 @@ export const evidenceFindingsStoreOver = (context) => {
             if (projectId === undefined)
                 return invalid("a findings list filters by a project reference");
             const ids = database
-                .prepare("SELECT id FROM proposed_actions WHERE account_id IS NULL AND kind=? AND (? IS NULL OR (target_type='project' AND target_id=?)) AND (? IS NULL OR status=?) ORDER BY id DESC LIMIT ? OFFSET ?")
-                .all(EVIDENCE_FINDINGS_KIND, projectId, projectId === null ? null : Number(projectId), status ?? null, status === "reviewed" ? "approved" : (status ?? null), limit + 1, offset);
+                .prepare("SELECT id FROM proposed_actions WHERE account_id IS NULL AND kind=? AND (? IS NULL OR (target_type='project' AND target_id=?) " +
+                "OR EXISTS (SELECT 1 FROM json_each(payload,'$.findings') f WHERE json_extract(f.value,'$.project')=?)) " +
+                "AND (? IS NULL OR status=?) ORDER BY id DESC LIMIT ? OFFSET ?")
+                .all(EVIDENCE_FINDINGS_KIND, projectId, projectId === null ? null : Number(projectId), projectId === null ? null : `project:${projectId}`, status ?? null, status === "reviewed" ? "approved" : (status ?? null), limit + 1, offset);
             return { items: ids.slice(0, limit).map((row) => view(load(String(row.id)))), hasMore: ids.length > limit };
         },
         review: async (id, decision) => write(database, () => {

package/dist/store/sqlite/findings-core.d.ts

@@ -11,8 +11,8 @@ export declare const findingsAgent: (agent: FindingsAgent) => FindingsAgent;
  * including a reference it already saw for another finding.
  */
 export declare const findingsCoreOver: (context: StoreContext, kind: string) => {
-    snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => string;
-    snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => Record<string, string>;
+    snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string | null, seen: Map<string, unknown>) => void) => string;
+    snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string | null, seen: Map<string, unknown>) => void) => Record<string, string>;
     previous: (account: number | null, fingerprint: string) => FindingOutcome | undefined;
     outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent) => FindingOutcome[];
 };

package/dist/store/sqlite/findings-core.js

@@ -30,15 +30,21 @@ export const findingsCoreOver = (context, kind) => {
     const cited = (input, cite) => {
         const seen = new Map();
         for (const finding of input.findings) {
-            const project = requiredThing(database, finding.project, "the project");
-            if (project.type !== "project")
-                return invalid("a finding needs an owner project");
-            const projectRow = database
-                .prepare("SELECT id,key,name,description,type,scope,updated_at FROM projects WHERE id=? AND account_id IS NULL AND deleted_at IS NULL")
-                .get(project.id);
-            if (!projectRow)
-                throw new CliError("not_found", "the owner project is unavailable");
-            seen.set(finding.project, projectRow);
+            let projectId = null;
+            if (finding.project !== undefined) {
+                const project = requiredThing(database, finding.project, "the project");
+                if (project.type !== "project")
+                    return invalid("a finding needs an owner project");
+                const projectRow = database
+                    .prepare("SELECT id,key,name,description,type,scope,updated_at FROM projects WHERE id=? AND account_id IS NULL AND deleted_at IS NULL")
+                    .get(project.id);
+                if (!projectRow)
+                    throw new CliError("not_found", "the owner project is unavailable");
+                seen.set(finding.project, projectRow);
+                projectId = String(project.id);
+            }
+            if (finding.subject !== undefined)
+                seen.set(finding.subject, requiredThing(database, finding.subject, "the subject"));
             if (finding.kind === "task" && finding.assignee) {
                 const person = requiredThing(database, finding.assignee, "the assignee");
                 if (person.type !== "person")
@@ -49,7 +55,7 @@ export const findingsCoreOver = (context, kind) => {
                 seen.set(finding.assignee, personRow);
             }
             for (const evidence of finding.evidence)
-                cite(evidence, finding, String(project.id), seen);
+                cite(evidence, finding, projectId, seen);
         }
         return seen;
     };
@@ -68,12 +74,15 @@ export const findingsCoreOver = (context, kind) => {
             const fact = facts.add({
                 type: finding.type,
                 statement: finding.statement,
-                project: finding.project,
+                ...(finding.project === undefined ? {} : { project: finding.project }),
+                ...(finding.subject === undefined ? {} : { subject: finding.subject }),
                 evidence,
                 by: agent,
             });
             return facts.accept(fact.ref).ref;
         }
+        if (finding.project === undefined)
+            return invalid("a task finding names the project the task goes in");
         const task = tasks.create({
             project: finding.project,
             title: finding.title,

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

@@ -6,8 +6,17 @@ export type TaskSort = (typeof TASK_SORTS)[number];
 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;
+/** Each due group as SQL over `t`, from day starts in the owner's zone; the filter and the counts share them. */
+export declare const dueGroups: (now: number, zone: string) => {
+    readonly overdue: `t.status NOT IN ('done', 'dismissed') AND t.due_at IS NOT NULL AND t.due_at < ${number}`;
+    readonly today: `t.due_at >= ${number} AND t.due_at < ${number}`;
+    readonly upcoming: `t.due_at >= ${number} AND t.due_at < ${number}`;
+    readonly later: `t.due_at >= ${number}`;
+    readonly none: "t.due_at IS NULL";
+};
+export type DueGroup = keyof ReturnType<typeof dueGroups>;
+/** `now` and `zone` place today; one value per answer, so the list and its counts agree. */
+export declare const projectTaskColumns: (now: number, zone: string) => 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. */

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

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { OPERATORS_BY_TYPE, walkQuery, } from "@wirecat/cli-base/query";
+import { dayBoundary, OPERATORS_BY_TYPE, walkQuery, } from "@wirecat/cli-base/query";
 import { TASK_TYPES } from "../../domain/knowledge.js";
 import { taskWordsOf } from "../../search/task-similarity.js";
 import { PRIORITY_LABELS, priorityBand, TASK_STATES } from "../../tasks/index.js";
@@ -28,7 +28,12 @@ export const PROJECT_TASK_FIELDS = [
     }),
     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("overdue", "bool", "overdue:true", { relation: "open work due before today" }),
+    field("when", "enum", "when:today", {
+        values: ["overdue", "today", "upcoming", "later", "none"],
+        relation: "the due date as a board groups it: overdue (open work due before today), today, upcoming (the next 7 days " +
+            "after today), later, or none",
+    }),
     field("closed", "time", "closed:>=14d", { relation: "when it was done or dismissed" }),
     field("ready", "bool", "ready:true", { relation: "open work whose blocked-by tasks are all done" }),
     field("text", "txt", "text:invoice", { relation: "words of the title and description; a bare word means this" }),
@@ -131,8 +136,28 @@ const truth = (node, sql) => ({
     sql: node.value.toLowerCase() === "true" ? sql : `NOT (${sql})`,
     params: [],
 });
-/** `now` is when overdue is measured; one value per answer, so the list and its counts agree. */
-export const projectTaskColumns = (now) => ({
+const SPAN = { start: 0, end: 0 };
+const UPCOMING_DAYS = 7;
+const dayIn = (at, zone, ahead) => {
+    const date = new Date(`${new Intl.DateTimeFormat("en-CA", { timeZone: zone, year: "numeric", month: "2-digit", day: "2-digit" }).format(at)}T00:00:00Z`);
+    date.setUTCDate(date.getUTCDate() + ahead);
+    return dayBoundary(date.toISOString().slice(0, 10), zone, false, SPAN);
+};
+/** Each due group as SQL over `t`, from day starts in the owner's zone; the filter and the counts share them. */
+export const dueGroups = (now, zone) => {
+    const today = dayIn(now, zone, 0);
+    const tomorrow = dayIn(now, zone, 1);
+    const after = dayIn(now, zone, UPCOMING_DAYS + 1);
+    return {
+        overdue: `${OPEN} AND t.due_at IS NOT NULL AND t.due_at < ${today}`,
+        today: `t.due_at >= ${today} AND t.due_at < ${tomorrow}`,
+        upcoming: `t.due_at >= ${tomorrow} AND t.due_at < ${after}`,
+        later: `t.due_at >= ${after}`,
+        none: "t.due_at IS NULL",
+    };
+};
+/** `now` and `zone` place today; one value per answer, so the list and its counts agree. */
+export const projectTaskColumns = (now, zone) => ({
     state: { type: "enum", sql: "t.status" },
     kind: { type: "enum", sql: "t.type" },
     project: { where: projectWhere },
@@ -141,7 +166,15 @@ export const projectTaskColumns = (now) => ({
     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)}`) },
+    overdue: { where: (node) => truth(node, dueGroups(now, zone).overdue) },
+    when: {
+        where: (node) => {
+            const group = dueGroups(now, zone)[node.value.toLowerCase()];
+            if (group === undefined)
+                throw new CliError("validation_error", "when is overdue, today, upcoming, later or none");
+            return { sql: group, params: [] };
+        },
+    },
     ready: { where: (node) => truth(node, `${OPEN} AND NOT EXISTS (${UNFINISHED_BLOCKER})`) },
     text: {
         where: (node) => {

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

@@ -6,7 +6,7 @@ import type { Actor } from "./actors.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
 import { type Where } from "./query-filter.js";
-import { type TaskSort } from "./task-board.js";
+import { type DueGroup, 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"];
@@ -31,7 +31,7 @@ export interface TaskFields {
     /** A name the caller checked against its category list; every change is a `category` event. */
     category?: string;
 }
-export interface NewWorkTask extends Omit<TaskFields, "status" | "reason"> {
+export interface NewWorkTask extends Omit<TaskFields, "reason"> {
     /** `project:<id>` or the project's key. */
     project: string;
     title: string;
@@ -48,6 +48,9 @@ export interface TaskDetails {
     ref: string;
     key: string;
     project: string;
+    /** The project's key and name, as `boardCounts` names it. */
+    projectKey: string;
+    projectName: string;
     title: string;
     description: string | null;
     type: TaskType;
@@ -109,8 +112,10 @@ export interface BoardOptions {
 /** How many tasks match, and how many hold each value: the board's pickers show these beside their choices. */
 export interface BoardCounts {
     total: number;
+    /** `value` is the key; `ref` the `project:<id>` a task's `project` names. */
     project: {
         value: string;
+        ref: string;
         name: string;
         count: number;
     }[];
@@ -129,6 +134,16 @@ export interface BoardCounts {
         value: TaskState;
         count: number;
     }[];
+    /** The groups `when:` takes, in board order; they do not overlap. */
+    due: {
+        value: DueGroup;
+        count: number;
+    }[];
+    /** The agent's name, or `none`. */
+    agent: {
+        value: string;
+        count: number;
+    }[];
 }
 export interface TaskEvent {
     kind: (typeof TASK_EVENT_KINDS)[number];
@@ -176,7 +191,10 @@ export interface WorkTasks extends TaskRelationsStore {
         total: number;
     }>;
     /** The owner and everyone who holds a role on a live task, by name: who the board offers to assign. */
-    taskPeople(): Promise<{
+    /** Everyone the store knows, the owner first, then by how many live tasks name them. */
+    taskPeople(options?: {
+        limit?: number;
+    }): Promise<{
         person: string;
         name: string | null;
         owner: boolean;

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

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { timezoneOf } from "@wirecat/cli-base/query";
 import { TASK_TYPES, WORK_TASK_TYPES } from "../../domain/knowledge.js";
 import { checkedScore, isClosedState, legacyPriority, PRIORITY_LABELS, priorityBand, priorityLabel, TASK_STATES, } from "../../tasks/index.js";
 import { folded } from "./folded.js";
@@ -7,7 +8,7 @@ import { CORPORA, drainCorpus } from "./note-index.js";
 import { requiredThing } from "./notes.js";
 import { queryFilter } from "./query-filter.js";
 import { stemmerCache } from "./stems.js";
-import { BOARD_SCOPE, boardOrder, projectTaskColumns, withoutField } from "./task-board.js";
+import { BOARD_SCOPE, boardOrder, dueGroups, projectTaskColumns, withoutField, } from "./task-board.js";
 import { closeSuggestionOf, SUGGESTION_COLUMNS } from "./task-close.js";
 import { INBOX_KEY_LENGTH, inboxKey } from "./task-keys.js";
 import { taskRelationsStoreOver } from "./task-relations.js";
@@ -53,6 +54,13 @@ 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 };
+/** A change to a time column is kept as epoch ms; it reads as ISO, as the task itself does. */
+const timesAsIso = (changes) => Object.fromEntries(Object.entries(changes).map(([key, pair]) => [
+    key,
+    key.endsWith("_at") && Array.isArray(pair)
+        ? pair.map((value) => (typeof value === "number" ? new Date(value).toISOString() : value))
+        : pair,
+]));
 /** 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)
@@ -101,6 +109,10 @@ export const workTaskOperationsOver = (context) => {
         }
         return parent;
     };
+    const projectNamed = (id) => {
+        const project = database.prepare("SELECT key, name FROM projects WHERE id = ?").get(id);
+        return { projectKey: String(project.key), projectName: String(project.name) };
+    };
     const detailsOf = (row) => {
         const id = Number(row.id);
         const reference = (taskRow) => `task:${taskIdOf(database, taskRow)}`;
@@ -109,6 +121,7 @@ export const workTaskOperationsOver = (context) => {
             ref: reference(id),
             key: String(row.key),
             project: `project:${row.project_id}`,
+            ...projectNamed(Number(row.project_id)),
             title: String(row.title),
             description: row.description == null ? null : String(row.description),
             type: row.type,
@@ -141,7 +154,7 @@ export const workTaskOperationsOver = (context) => {
     const boardWhere = (query, zone, at) => {
         if (query === undefined)
             return { sql: BOARD_SCOPE, params: [] };
-        const where = queryFilter(query, projectTaskColumns(at), {
+        const where = queryFilter(query, projectTaskColumns(at, timezoneOf(zone)), {
             command: "tasks list",
             now: at,
             ...(zone ? { zone } : {}),
@@ -483,8 +496,13 @@ export const workTaskOperationsOver = (context) => {
                     .prepare(`SELECT ${select}, count(*) AS n FROM tasks t ${from} WHERE ${where.sql} GROUP BY ${group}`)
                     .all(...where.params);
             };
-            const project = grouped("project", "p.key, p.name", "JOIN projects p ON p.id = t.project_id", "p.id")
-                .map((row) => ({ value: String(row.key), name: String(row.name), count: Number(row.n) }))
+            const project = grouped("project", "p.id, p.key, p.name", "JOIN projects p ON p.id = t.project_id", "p.id")
+                .map((row) => ({
+                value: String(row.key),
+                ref: `project:${row.id}`,
+                name: String(row.name),
+                count: Number(row.n),
+            }))
                 .sort((a, b) => a.value.localeCompare(b.value));
             const assigned = grouped("assignee", "a.assignee_id AS person, pe.name", "LEFT JOIN task_assignments a ON a.task_id = t.id AND a.assignee_type = 'person' AND a.role = 'assignee' " +
                 "LEFT JOIN persons pe ON pe.id = a.assignee_id", "a.assignee_id");
@@ -501,6 +519,17 @@ export const workTaskOperationsOver = (context) => {
                 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)]));
+            const groups = dueGroups(at, timezoneOf(zone));
+            const dueWhere = boardWhere(withoutField(withoutField(query, "when"), "overdue"), zone, at);
+            const due = Object.keys(groups).map((value) => ({
+                value,
+                count: Number(database
+                    .prepare(`SELECT count(*) AS n FROM tasks t WHERE ${dueWhere.sql} AND ${groups[value]}`)
+                    .get(...dueWhere.params)?.n ?? 0),
+            }));
+            const agent = grouped("agent", "t.agent", "", "t.agent")
+                .map((row) => ({ value: row.agent == null ? "none" : String(row.agent), count: Number(row.n) }))
+                .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
             return {
                 total: countOf(boardWhere(query, zone, at)),
                 project,
@@ -510,14 +539,16 @@ export const workTaskOperationsOver = (context) => {
                     count: priorities.get(value) ?? 0,
                 })),
                 state: TASK_STATES.map((value) => ({ value, count: states.get(value) ?? 0 })),
+                due,
+                agent,
             };
         },
-        taskPeople: async () => database
+        taskPeople: async ({ limit = 500 } = {}) => database
             .prepare("SELECT p.id, p.name, p.owner, count(DISTINCT t.id) AS n FROM persons p " +
             "LEFT JOIN task_assignments a ON a.assignee_type = 'person' AND a.assignee_id = p.id " +
             "LEFT JOIN tasks t ON t.id = a.task_id AND t.deleted_at IS NULL " +
-            "WHERE p.owner = 1 OR t.id IS NOT NULL GROUP BY p.id ORDER BY p.owner DESC, p.name COLLATE NOCASE, p.id")
-            .all()
+            "GROUP BY p.id ORDER BY p.owner DESC, n DESC, p.name IS NULL, p.name COLLATE NOCASE, p.id LIMIT ?")
+            .all(Math.min(Math.max(limit, 1), 5000))
             .map((row) => ({
             person: `person:${row.id}`,
             name: row.name == null ? null : String(row.name),
@@ -539,7 +570,7 @@ export const workTaskOperationsOver = (context) => {
                     id: Number(row.actor_id),
                     name: row.actor_name == null ? null : String(row.actor_name),
                 },
-            changes: row.changes == null ? null : JSON.parse(String(row.changes)),
+            changes: row.changes == null ? null : timesAsIso(JSON.parse(String(row.changes))),
             at: iso(row.created_at),
         })),
     };

package/dist/tasks/priority.js

@@ -33,7 +33,11 @@ export const priorityOf = (value) => {
         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`);
+    // A bare 0 or 1 is the old scale, where they mean the opposite; the decimal point says a 0–1 score is meant.
+    if (/^(0?\.\d+|[01]\.\d*)$/.test(word) && Number(word) <= 1)
+        return Number(word);
+    throw new CliError("validation_error", `a priority is ${PRIORITY_LABELS.join(", ")}, none, or a score from 0.0 to 1.0 with its decimal point; ` +
+        "0 (urgent) … 4 (low) still work as critical, high, medium, low, low");
 };
 /** `priorityOf` for a command-line option: Commander stores a parser's `null` as an empty string, so `none` stays a word. */
 export const priorityOption = (value) => priorityOf(value) ?? "none";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.528.0",
+  "version": "0.530.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",
@@ -251,7 +251,7 @@
     "@types/node": "^22.20.5",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.5",
-    "@wirecat/cli-base": "0.68.0",
+    "@wirecat/cli-base": "0.71.0",
     "@wirecat/cli-core-legacy-tags": "npm:@wirecat/cli-core@0.414.0",
     "commander": "15.0.0",
     "cspell": "10.4.0",
@@ -271,7 +271,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.68.0 <0.69.0",
+    "@wirecat/cli-base": ">=0.71.0 <0.72.0",
     "commander": ">=15"
   },
   "bin": {