@wirecat/cli-core 0.527.0 → 0.529.0

package/CHANGELOG.md

@@ -5,7 +5,52 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 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
+
+- **Every profile keeps its messenger library's warnings, and `doctor` counts the last day's.** A message the
+  library could not decrypt used to leave no trace unless the CLI's own log variable was set. `providerLogPathFor(app,
+  profile, env)` names `<state>/provider-log/<profile>.jsonl`; `openProviderLog(path)` makes it private (mode 600)
+  and keeps it under 1 MB with one older file, so an engine in another process can append to the path it is given;
+  `writeProviderWarning(path, kind, message)` appends from Node. A line is `{"time","level","kind"?,"message"}`, the
+  shape zerolog writes; `kind` is the adapter's tag. The adapter masks phone numbers, ids of people and text before
+  writing. `doctor` answers `provider_log: { path, last_day: { total, kinds } }` and checks the file is private.
 
 ## 0.527.0 — 01.11.2026
 

package/dist/cli/index.d.ts

@@ -23,6 +23,7 @@ export { NO_RULES, NO_TASKS, NOT_ALLOWED, ONLY_TASK, type Replied, type Replier,
 export { repliesStatePathFor } from "../replies/state.js";
 export { type CacheEvent, type DiagnosticEvent, type EventSink, providerErrorKey, type RequestEvent, renderEvent, type WarningEvent, } from "../runs/events.js";
 export { CORE_LOG_EVENTS } from "../runs/log-events.js";
+export { openProviderLog, PROVIDER_LOG_BYTES, type ProviderWarnings, providerLogPathFor, providerWarnings, writeProviderWarning, } from "../runs/provider-log.js";
 export { crashOf, type Recording, type RecordingOptions, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, type RunContext, type RunMetadata, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
 export { runContextOf, secretInput } from "../runs/run-context.js";
@@ -105,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

@@ -19,6 +19,7 @@ export { NO_RULES, NO_TASKS, NOT_ALLOWED, ONLY_TASK, replyTo } from "../replies/
 export { repliesStatePathFor } from "../replies/state.js";
 export { providerErrorKey, renderEvent, } from "../runs/events.js";
 export { CORE_LOG_EVENTS } from "../runs/log-events.js";
+export { openProviderLog, PROVIDER_LOG_BYTES, providerLogPathFor, providerWarnings, writeProviderWarning, } from "../runs/provider-log.js";
 export { crashOf, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
 export { runContextOf, secretInput } from "../runs/run-context.js";
@@ -94,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/doctor-command.js

@@ -5,6 +5,7 @@ import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { engineStates } from "../../attachments/extract.js";
 import { providerErrorKey } from "../../runs/events.js";
+import { providerLogPathFor, providerWarnings } from "../../runs/provider-log.js";
 import { listRuns, runsDirFor, runtime } from "../../runs/run.js";
 import { FloodMemory, floodPathFor } from "../../sends/flood.js";
 import { SendJournal, sendsPathFor } from "../../sends/journal.js";
@@ -20,6 +21,7 @@ import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
 import { privateFiles, withSqliteSidecars } from "./private-files.js";
 import { buildReport, reportFileName } from "./report.js";
+import { DAY_MS } from "./serve-members.js";
 import { storeSummary } from "./store-maintenance-command.js";
 /**
  * The state this installation is in, read from disk and **never from the messenger unless
@@ -121,6 +123,7 @@ const rememberedOf = (report) => report.account?.remembered ?? undefined;
  * What `doctor` answers, as data. A configuration that will not load is a field, not an exception:
  * then there is no renderer from the settings, and the caller renders with the defaults.
  */
+const providerLogState = ({ path, total, kinds }) => ({ path, last_day: { total, kinds } });
 const diagnose = async (command, messenger) => {
     const { app, provider } = messenger;
     const env = environmentOf(command).env ?? process.env;
@@ -183,8 +186,9 @@ const diagnose = async (command, messenger) => {
     const store = storePath(env);
     const sends = sendsPathFor(app, profile, env);
     const flood = floodPathFor(app, profile, env);
+    const providerLog = providerLogPathFor(app, profile, env);
     const files = privateFiles({
-        files: [...own.files, ...withSqliteSidecars(store), sends, flood],
+        files: [...own.files, ...withSqliteSidecars(store), sends, flood, providerLog],
         // A folder the owner chose with MESSAGING_STORE may rightly be shared, like the home folder itself.
         dirs: [
             ...own.dirs,
@@ -192,6 +196,7 @@ const diagnose = async (command, messenger) => {
             dirname(sends),
             dirname(flood),
             runsDirFor(app, env),
+            dirname(providerLog),
         ],
     });
     return {
@@ -209,6 +214,7 @@ const diagnose = async (command, messenger) => {
             readers: engineStates(),
             sends: sendsState(new SendJournal(sendsPathFor(app, profile, env))),
             flood: floodState(new FloodMemory(flood)),
+            provider_log: providerLogState(providerWarnings(providerLog, new Date(Date.now() - DAY_MS))),
             runs: { directory: runsDirFor(app, env), kept: listRuns(runsDirFor(app, env)).length },
             // The messenger's own block keeps the keys it gives: some of them are file paths.
             files: filesReport(files),

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/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/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/runs/provider-log.d.ts

@@ -0,0 +1,22 @@
+import type { AppIdentity } from "../ports/app.js";
+/**
+ * The messenger library's warnings for one profile, always kept: a message it failed to decrypt is lost without a
+ * trace otherwise. One JSON object per line, `{"time","level","kind"?,"message"}` — the shape zerolog writes, so an
+ * engine in another process appends to the file directly. **No phone number, id of a person or message text**: the
+ * adapter or its engine masks before writing. `kind` is the adapter's tag (`decrypt`), counted by `doctor`.
+ */
+export declare const providerLogPathFor: (app: AppIdentity, profile: string, env?: NodeJS.ProcessEnv) => string;
+export declare const PROVIDER_LOG_BYTES: number;
+/**
+ * The file, private and under its cap, ready for an engine to append to. The cap is kept here rather than by the
+ * writer, because an engine in another language appends without knowing it: one older file is kept.
+ */
+export declare const openProviderLog: (path: string, maxBytes?: number) => string;
+export declare const writeProviderWarning: (path: string, kind: string, message: string, now?: Date) => void;
+export interface ProviderWarnings {
+    path: string;
+    total: number;
+    kinds: Record<string, number>;
+}
+/** Warnings since `since`, by kind; a line without one counts as `other`, a line that is not JSON is skipped. */
+export declare const providerWarnings: (path: string, since: Date) => ProviderWarnings;

package/dist/runs/provider-log.js

@@ -0,0 +1,55 @@
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolvePaths } from "@wirecat/cli-base";
+/**
+ * The messenger library's warnings for one profile, always kept: a message it failed to decrypt is lost without a
+ * trace otherwise. One JSON object per line, `{"time","level","kind"?,"message"}` — the shape zerolog writes, so an
+ * engine in another process appends to the file directly. **No phone number, id of a person or message text**: the
+ * adapter or its engine masks before writing. `kind` is the adapter's tag (`decrypt`), counted by `doctor`.
+ */
+export const providerLogPathFor = (app, profile, env = process.env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "provider-log", `${profile}.jsonl`);
+export const PROVIDER_LOG_BYTES = 1024 * 1024;
+const previousOf = (path) => path.replace(/\.jsonl$/, ".1.jsonl");
+/**
+ * The file, private and under its cap, ready for an engine to append to. The cap is kept here rather than by the
+ * writer, because an engine in another language appends without knowing it: one older file is kept.
+ */
+export const openProviderLog = (path, maxBytes = PROVIDER_LOG_BYTES) => {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    if (existsSync(path) && statSync(path).size >= maxBytes)
+        renameSync(path, previousOf(path));
+    closeSync(openSync(path, "a", 0o600));
+    chmodSync(path, 0o600);
+    return path;
+};
+export const writeProviderWarning = (path, kind, message, now = new Date()) => {
+    openProviderLog(path);
+    appendFileSync(path, `${JSON.stringify({ time: now.toISOString(), level: "warn", kind, message })}\n`);
+};
+/** Warnings since `since`, by kind; a line without one counts as `other`, a line that is not JSON is skipped. */
+export const providerWarnings = (path, since) => {
+    const kinds = {};
+    let total = 0;
+    for (const file of [previousOf(path), path]) {
+        if (!existsSync(file))
+            continue;
+        for (const line of readFileSync(file, "utf8").split("\n")) {
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const at = typeof entry.time === "string" ? Date.parse(entry.time) : Number.NaN;
+            if (!(at >= since.getTime()))
+                continue;
+            const kind = typeof entry.kind === "string" && entry.kind ? entry.kind : "other";
+            kinds[kind] = (kinds[kind] ?? 0) + 1;
+            total++;
+        }
+    }
+    return { path, total, kinds };
+};

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.527.0",
+  "version": "0.529.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": {