@wirecat/cli-core 0.537.0 → 0.538.0

package/CHANGELOG.md

@@ -7,6 +7,39 @@ shape of this file.
 
 ## Unreleased
 
+## 0.538.0 — 01.11.2026
+
+### Added
+
+- **`events prepare [event]`, in the shared calendar commands: what the store holds for one meeting.** The event as
+  `events show` gives it, and for each attendee other than the owner their linked identities, latest one-to-one
+  messages and mail, their messages in groups, past events and recorded meetings with them, read in every account that
+  saw them. Without an event, the next meeting with other attendees. `meta.accounts` names what was read, and
+  `meta.complete: false` names a chat the store does not hold whole (`chat.not-read`) or meetings not yet indexed
+  (`meetings.index-pending`); `untrusted` marks all third-party text. It summarises nothing. `recordContext` is
+  `personContext` for a person already found, read in the accounts the caller names.
+- **A task error names the tasks it is about**: `task.has-subtasks` gives `details.subtasks` (their keys) and
+  `task.is-subtask` gives `details.parent`, in the JSON a CLI prints. The keys were raised but not kept.
+- **`parent:` in the project task query**: `parent:<key>` lists a task's subtasks, also by a key it had before it
+  moved to another project; `parent:none` and `parent:any`.
+
+### Fixed
+
+- **Mail a server search stores first gets the owner's rule tags.** `searchMailServer` saved new mail without the
+  `tag:` labels and `mailRuleId` its rules give, and sync never reads mail whose place it already knows, so that mail
+  stayed untagged until `rules apply`. It now tags it as `syncMail` does, and writes reused or refused labels back into
+  the rules the same way.
+- **A findings batch stays approvable after a sibling batch of the same project is decided.** Accepting checks only
+  the evidence and assignee the accepted findings cite. Before, every task a
+  decision created moved the project's row, and every other waiting batch of that project was refused as
+  `evidence-findings.stale`. A renamed project no longer refuses a batch either; the project must still exist.
+  Meeting findings are unchanged.
+
+### Changed — may break callers
+
+- **Moving a subtask to another project is refused** with `task.is-subtask` (details `parent`, its parent's key),
+  unless the same edit detaches it with `parent: null`. Before, the move dropped its parent without saying so.
+
 ## 0.537.0 — 01.11.2026
 
 ### Added

package/dist/calendar/cli/answers.d.ts

@@ -249,6 +249,149 @@ export declare const calendarAttendee: v.StrictObjectSchema<{
     readonly events: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;
+export declare const calendarEventPreparation: v.StrictObjectSchema<{
+    readonly event: v.StrictObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly event_series_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly timezone: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly origin: v.PicklistSchema<["auto", "owner", "calendar"], undefined>;
+        readonly status: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly all_day: v.BooleanSchema<undefined>;
+        readonly source_deleted_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly deleted_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly updated_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly change: v.OptionalSchema<v.PicklistSchema<["new", "moved", "cancelled"], undefined>, undefined>;
+        readonly changed_at: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>, undefined>;
+        readonly was: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>, undefined>;
+        readonly overlapping: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly overlaps: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly ref: v.StringSchema<undefined>;
+        readonly entries: v.ArraySchema<v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly calendar_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly external_id: v.StringSchema<undefined>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly status: v.StringSchema<undefined>;
+            readonly event_type: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly own_response: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly join_url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly deleted_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>, undefined>;
+        readonly attendees: v.ArraySchema<v.StrictObjectSchema<{
+            email: v.StringSchema<undefined>;
+            name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            response: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            organizer: v.BooleanSchema<undefined>;
+            optional: v.BooleanSchema<undefined>;
+            resource: v.BooleanSchema<undefined>;
+            self: v.BooleanSchema<undefined>;
+            /** `person:<id>` when the shared store knows the address. */
+            person: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
+            readonly file_id: v.StringSchema<undefined>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly document: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly history: v.ArraySchema<v.StrictObjectSchema<{
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly status: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly changed_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        }, undefined>, undefined>;
+        readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly people: v.ArraySchema<v.StrictObjectSchema<{
+        readonly email: v.StringSchema<undefined>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly response: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly organizer: v.BooleanSchema<undefined>;
+        readonly optional: v.BooleanSchema<undefined>;
+        readonly person: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly read: v.BooleanSchema<undefined>;
+        readonly identities: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly recent: v.StrictObjectSchema<{
+            readonly direct: v.ArraySchema<v.StrictObjectSchema<{
+                readonly locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly provider: v.StringSchema<undefined>;
+                readonly account: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+                readonly sender_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+                readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly groups: v.ArraySchema<v.StrictObjectSchema<{
+                readonly locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly provider: v.StringSchema<undefined>;
+                readonly account: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+                readonly sender_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+                readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+        readonly past_events: v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly all_day: v.BooleanSchema<undefined>;
+            readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly status: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly meetings: v.ArraySchema<v.StrictObjectSchema<{
+            readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly cues: v.ArraySchema<v.StrictObjectSchema<{
+                readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly fingerprint: v.StringSchema<undefined>;
+                readonly transcript_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly content_hash: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly start_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly end_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly speaker_participant_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly speaker_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+                readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
+            }, undefined>, undefined>;
+            readonly cue_coverage: v.StrictObjectSchema<{
+                readonly included: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly omitted: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly has_more: v.BooleanSchema<undefined>;
+            }, undefined>;
+        }, undefined>, undefined>;
+        readonly has_more: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly limits: v.StrictObjectSchema<{
+        readonly people: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
 export declare const calendarLinkedPerson: v.StrictObjectSchema<{
     readonly person: v.StringSchema<undefined>;
     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;

package/dist/calendar/cli/answers.js

@@ -2,7 +2,8 @@ import { annotate } from "@wirecat/cli-base/commands";
 import { queryFieldsOf } from "@wirecat/cli-base/query";
 import * as v from "valibot";
 import { answerEntity } from "../../cli/answer-entity.js";
-import { count, id, text, time, untrusted } from "../../entities/fields.js";
+import { contextEvent, contextMessage, meetingCue } from "../../entities/contact-context.js";
+import { count, id, reference, text, time, untrusted } from "../../entities/fields.js";
 import { event } from "../../meetings/index.js";
 const nullableText = v.nullable(text);
 const nullableTime = v.nullable(time);
@@ -180,6 +181,31 @@ export const calendarAttendee = v.strictObject({
     events: v.optional(count),
     untrusted,
 });
+/** An attendee of the prepared event other than the owner, with what the store holds of them; `read` false: nothing. */
+const preparedPerson = v.strictObject({
+    email: text,
+    name: nullableText,
+    response: nullableText,
+    organizer: v.boolean(),
+    optional: v.boolean(),
+    person: nullableText,
+    read: v.boolean(),
+    identities: v.array(text),
+    recent: v.strictObject({ direct: v.array(contextMessage), groups: v.array(contextMessage) }),
+    past_events: v.array(contextEvent),
+    meetings: v.array(v.strictObject({
+        reference,
+        cues: v.array(meetingCue),
+        cue_coverage: v.strictObject({ included: count, omitted: v.nullable(count), has_more: v.boolean() }),
+    })),
+    has_more: v.boolean(),
+});
+export const calendarEventPreparation = v.strictObject({
+    event: calendarEvent,
+    people: v.array(preparedPerson),
+    limits: v.strictObject({ people: count, messages: count, bytes: count }),
+    untrusted,
+});
 export const calendarLinkedPerson = v.strictObject({ person: text, name: nullableText, identities: v.array(text) });
 export const calendarLinkReview = v.strictObject({
     id,
@@ -198,6 +224,7 @@ const ANSWERS = {
     "store status": { name: "calendar_sync_progress", schema: calendarSyncProgress },
     "events list": { name: "event" },
     "events show": { name: "calendar_event", schema: calendarEvent },
+    "events prepare": { name: "calendar_event_preparation", schema: calendarEventPreparation },
     "events create": { name: "calendar_event_write", schema: calendarEventWrite },
     "events update": { name: "calendar_event_write", schema: calendarEventWrite },
     "events delete": { name: "calendar_event_write", schema: calendarEventWrite },

package/dist/calendar/cli/index.js

@@ -8,8 +8,10 @@ import { queryTerms, withQuery } from "../../cli/list-query.js";
 import { terminalAsker } from "../../cli/messenger/ask.js";
 import { lineOf } from "../../cli/steps.js";
 import { searchEvents } from "../../services/events-search.js";
+import { dateWindow } from "../../services/moment.js";
 import { linkPeople } from "../../services/people.js";
 import { BUSY_QUERY, BUSY_QUERY_NOTE, busyAnswer, busyQuery, workingHoursOf } from "../busy.js";
+import { eventPreparation, nextMeeting, PREPARE_MESSAGES } from "../prepare.js";
 import { accountsMeta, CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY, EVENTS_QUERY_NOTE, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, peopleAnswer, resolveAnswer, reviewsAnswer, sourceAccounts, weekFilter, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
 import { bothSearchAnswer, serverSearchAnswer } from "../server-search.js";
@@ -40,6 +42,12 @@ const integer = (text) => {
         throw new InvalidArgumentError("expected a positive integer");
     return Number(text);
 };
+const upTo = (most) => (text) => {
+    const value = integer(text);
+    if (value > most)
+        throw new InvalidArgumentError(`expected 1 to ${most}`);
+    return value;
+};
 const minutes = (text) => {
     const value = integer(text);
     if (value < 5 || value > 1440)
@@ -232,6 +240,33 @@ const addCalendarCommandsDefinition = (program, deps) => {
         const shown = await eventAnswer(await eventOf(deps.store, deps.accountId, eventIdOf(reference)), personOfEmail);
         print({ ...shown, untrusted: CALENDAR_UNTRUSTED_FIELDS }, command);
     });
+    example(annotate(events.command("prepare"), { effects: LOCAL_READ, partial: true })
+        .description("before a meeting: the event, its attendees with their answer, and each one's latest messages, mail and " +
+        "meetings the store holds; the next meeting when no event is named")
+        .summary("what the store holds for one meeting and the people in it")
+        .argument("[event]", "the event's id, or event:<id>; the next meeting with other attendees when absent"), "events prepare --json", "events prepare event:42 --limit 3", "events prepare event:42 --since-time 2026-10-01")
+        .option("--limit <n>", `messages per person in each list, 1–50; ${PREPARE_MESSAGES} if not given`, upTo(50))
+        .option("--since-time <time>", "no message or meeting older than this ISO 8601 time, or 30d ago")
+        .action(async (reference, opts, command) => {
+        const window = dateWindow({
+            ...(opts.sinceTime === undefined ? {} : { sinceTime: opts.sinceTime }),
+            zone: zone(),
+            now: now(),
+        });
+        const details = reference === undefined
+            ? await nextMeeting(deps.store, deps.accountId, now())
+            : await eventOf(deps.store, deps.accountId, eventIdOf(reference));
+        const { meta, ...prepared } = await eventPreparation(details, {
+            store: deps.store,
+            messages: messages("events prepare"),
+            account: { id: deps.accountId, key: deps.account },
+            personOf: personOfEmail ?? (async () => null),
+            now: now(),
+            ...(opts.limit === undefined ? {} : { limit: opts.limit }),
+            ...(window.since === undefined ? {} : { since: window.since }),
+        });
+        print({ ...prepared, meta: { ...meta, ...window.meta } }, command);
+    });
     const searches = annotate(program.command("search").description("find stored things by text: events"), {
         effects: GROUP,
     });

package/dist/calendar/prepare.d.ts

@@ -0,0 +1,134 @@
+import type { EventDetails, EventStore } from "../meetings/index.js";
+import { type ContextEvent, type ContextMessage } from "../services/person-context.js";
+import { type PersonMeetingContextItem } from "../services/person-meeting-context.js";
+import type { MessageStore } from "../store/store.js";
+import { type PersonOfEmail, type ReadAccount } from "./reads.js";
+export declare const PREPARE_MESSAGES = 5;
+/** Attendees past this many are listed without their messages: a meeting of fifty would not fit any budget. */
+export declare const PREPARE_PEOPLE = 10;
+export declare const PREPARE_BYTES: number;
+/** The account's next meeting that has not started yet, by the rule of `isMeeting`. */
+export declare const nextMeeting: (store: EventStore, accountId: number, now: number) => Promise<EventDetails>;
+export interface PreparationOptions {
+    store: EventStore;
+    messages: MessageStore;
+    account: ReadAccount;
+    personOf: PersonOfEmail;
+    now: number;
+    /** Messages per person, each list. */
+    limit?: number;
+    /** ms: no message or meeting older. */
+    since?: number;
+}
+/**
+ * The stored evidence for one meeting: the event, and for each attendee other than the owner, their linked identities,
+ * their latest messages and mail, the events and recorded meetings they shared with the owner. Reads the store only,
+ * every account that saw each person (WC-ACCT-9), and writes nothing; the brief is the agent's.
+ */
+export declare const eventPreparation: (details: EventDetails, options: PreparationOptions) => Promise<{
+    event: {
+        id: string;
+        event_series_id: string | null;
+        title: string | null;
+        description: string | null;
+        location: string | null;
+        starts_at: string | null;
+        ends_at: string | null;
+        timezone: string | null;
+        origin: "auto" | "calendar" | "owner";
+        status: string | null;
+        all_day: boolean;
+        source_deleted_at: string | null;
+        deleted_at: string | null;
+        created_at: string;
+        updated_at: string;
+        untrusted?: string[] | undefined;
+        change?: "cancelled" | "moved" | "new" | undefined;
+        changed_at?: string | null | undefined;
+        was?: {
+            starts_at: string | null;
+            ends_at: string | null;
+        } | undefined;
+        overlapping?: boolean | undefined;
+        overlaps?: string[] | undefined;
+        ref: string;
+        entries: {
+            id: string;
+            calendar_id: string;
+            external_id: string;
+            kind: import("../meetings/event-store.js").EntryKind;
+            title: string | null;
+            status: import("../meetings/event-store.js").EntryStatus;
+            event_type: import("../meetings/event-store.js").EntryEventType | null;
+            own_response: import("../meetings/event-store.js").ParticipantResponse | null;
+            starts_at: string | null;
+            ends_at: string | null;
+            join_url: string | null;
+            url: string | null;
+            deleted_at: string | null;
+        }[];
+        attendees: {
+            email: string;
+            name: string | null;
+            response: import("../meetings/event-store.js").ParticipantResponse | null;
+            organizer: boolean;
+            optional: boolean;
+            resource: boolean;
+            self: boolean;
+            person: string | null;
+        }[];
+        attachments: {
+            file_id: string;
+            title: string | null;
+            document: string | null;
+        }[];
+        history: {
+            title: string | null;
+            starts_at: string | null;
+            ends_at: string | null;
+            location: string | null;
+            status: string | null;
+            changed_at: string;
+        }[];
+    };
+    people: {
+        email: string;
+        name: string | null;
+        response: string | null;
+        organizer: boolean;
+        optional: boolean;
+        person: string | null;
+        read: boolean;
+        identities: string[];
+        recent: {
+            direct: ContextMessage[];
+            groups: ContextMessage[];
+        };
+        pastEvents: ContextEvent[];
+        meetings: PersonMeetingContextItem[];
+        hasMore: boolean;
+    }[];
+    limits: {
+        people: number;
+        messages: number;
+        bytes: number;
+    };
+    untrusted: string[];
+    meta: Pick<{
+        run_id: string;
+        duration_ms: number;
+        accounts?: string[] | undefined;
+        complete: boolean;
+        issues?: {
+            code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
+            reason?: string | undefined;
+            source: string;
+        }[] | undefined;
+        truncated?: boolean | undefined;
+        timezone?: string | undefined;
+        window?: {
+            since?: string | undefined;
+            until?: string | undefined;
+        } | undefined;
+    }, "accounts" | "complete" | "issues" | "truncated">;
+}>;

package/dist/calendar/prepare.js

@@ -0,0 +1,179 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseMeetingReference } from "../meetings/index.js";
+import { readsOf, recordContext } from "../services/person-context.js";
+import { personMeetingContext } from "../services/person-meeting-context.js";
+import { accountsMeta, CALENDAR_UNTRUSTED_FIELDS, eventAnswer, eventOf, } from "./reads.js";
+export const PREPARE_MESSAGES = 5;
+/** Attendees past this many are listed without their messages: a meeting of fifty would not fit any budget. */
+export const PREPARE_PEOPLE = 10;
+export const PREPARE_BYTES = 128 * 1024;
+const PERSON_BYTES = 24 * 1024;
+const MEETINGS = 2;
+const CUES = 5;
+/** How many upcoming events the next-meeting rule looks at before it gives up. */
+const NEXT_SCAN = 200;
+const NEXT_PAGE = 50;
+const nameOf = ({ provider, account }) => `${provider}:${account}`;
+const size = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+/**
+ * What makes an event the next meeting: timed, not cancelled, not declined by the owner, an ordinary event (no focus
+ * time, out-of-office or working location), and someone other than the owner and the rooms invited.
+ */
+const isMeeting = (details) => {
+    if (details.event.allDay || details.event.status === "cancelled")
+        return false;
+    const live = details.entries.filter((entry) => entry.deletedAt === null && entry.status !== "cancelled");
+    if (!live.length || live.every((entry) => entry.ownResponse === "declined"))
+        return false;
+    if (live.every((entry) => entry.eventType !== null && entry.eventType !== "default"))
+        return false;
+    return details.participants.some((one) => !one.self && !one.resource);
+};
+/** The account's next meeting that has not started yet, by the rule of `isMeeting`. */
+export const nextMeeting = async (store, accountId, now) => {
+    for (let offset = 0; offset < NEXT_SCAN; offset += NEXT_PAGE) {
+        const page = await store.events({ accountId, startsFrom: now, limit: NEXT_PAGE, offset });
+        for (const one of page) {
+            if (one.allDay || one.status === "cancelled")
+                continue;
+            const details = await eventOf(store, accountId, one.id).catch(() => undefined);
+            if (details && isMeeting(details))
+                return details;
+        }
+        if (page.length < NEXT_PAGE)
+            break;
+    }
+    throw new CliError("not_found", "no upcoming meeting with other attendees in the store; run sync, or name an event", {
+        reason: "calendar.no-upcoming",
+    });
+};
+const UNTRUSTED = [
+    ...CALENDAR_UNTRUSTED_FIELDS.filter((field) => !["candidates.title", "entry.title", "ended.title"].includes(field)).map((field) => `event.${field}`),
+    "people.name",
+    ...["direct", "groups"].flatMap((list) => ["chat_title", "sender_name", "text"].map((field) => `people.recent.${list}.${field}`)),
+    "people.past_events.title",
+    "people.past_events.location",
+    "people.meetings.cues.speaker_name",
+    "people.meetings.cues.text",
+];
+/**
+ * The stored evidence for one meeting: the event, and for each attendee other than the owner, their linked identities,
+ * their latest messages and mail, the events and recorded meetings they shared with the owner. Reads the store only,
+ * every account that saw each person (WC-ACCT-9), and writes nothing; the brief is the agent's.
+ */
+export const eventPreparation = async (details, options) => {
+    const { messages: store, account, personOf, now, since } = options;
+    const limit = options.limit ?? PREPARE_MESSAGES;
+    const shown = await eventAnswer(details, personOf);
+    const others = shown.attendees
+        .filter((one) => !one.self && !one.resource)
+        .sort((a, b) => Number(b.organizer) - Number(a.organizer));
+    const read = new Map([[nameOf(account.key), account.key]]);
+    const issues = [];
+    const stored = await store.accounts.storedAccounts();
+    let left = PREPARE_BYTES - size(shown);
+    let truncated = others.length > PREPARE_PEOPLE;
+    let pending = 0;
+    const people = [];
+    for (const [index, attendee] of others.entries()) {
+        const base = {
+            email: attendee.email,
+            name: attendee.name,
+            response: attendee.response,
+            organizer: attendee.organizer,
+            optional: attendee.optional,
+            person: attendee.person,
+        };
+        const record = attendee.person ? await store.people.personOf({ provider: "email", id: attendee.email }) : undefined;
+        const nothing = {
+            ...base,
+            read: false,
+            identities: record ? record.identities.map(({ provider, id }) => `${provider}:${id}`) : [],
+            recent: { direct: [], groups: [] },
+            pastEvents: [],
+            meetings: [],
+            hasMore: false,
+        };
+        if (!record || index >= PREPARE_PEOPLE || left < 2048) {
+            if (record && index < PREPARE_PEOPLE)
+                truncated = true;
+            people.push(nothing);
+            continue;
+        }
+        const reads = readsOf(record, account.key);
+        for (const { key } of reads)
+            read.set(nameOf(key), key);
+        const context = await recordContext(store, record, reads, {
+            messages: limit,
+            bytes: Math.min(left, PERSON_BYTES),
+            now,
+            ...(since === undefined ? {} : { since }),
+        });
+        for (const chat of context.notRead)
+            issues.push({
+                code: "not_found",
+                reason: "chat.not-read",
+                source: `${chat.provider}:${chat.account}/${chat.chatId}`,
+            });
+        const meetings = await meetingsWith(store, record.uid, stored, since);
+        pending = Math.max(pending, meetings.pending);
+        for (const id of meetings.accounts) {
+            const one = stored.find((held) => held.id === id);
+            if (one)
+                read.set(nameOf(one), { provider: one.provider, account: one.account });
+        }
+        const entry = {
+            ...nothing,
+            read: true,
+            recent: context.recent,
+            pastEvents: context.events.recent.filter((one) => one.ref !== shown.ref).slice(0, limit),
+            meetings: meetings.items,
+            hasMore: context.hasMore || meetings.hasMore,
+        };
+        left -= size(entry);
+        people.push(entry);
+    }
+    if (pending > 0)
+        issues.push({ code: "not_found", reason: "meetings.index-pending", source: "meetings" });
+    const calendar = await accountsMeta(options.store, [account], [], now);
+    const all = [...(calendar.issues ?? []), ...issues];
+    const meta = {
+        accounts: [...read.keys()],
+        complete: all.length === 0,
+        ...(all.length ? { issues: all } : {}),
+        ...(truncated || left < 0 ? { truncated: true } : {}),
+    };
+    return {
+        event: shown,
+        people,
+        limits: { people: PREPARE_PEOPLE, messages: limit, bytes: PREPARE_BYTES },
+        untrusted: UNTRUSTED,
+        meta,
+    };
+};
+/** Their latest recorded meetings in every stored account that saw them; none is not an error. */
+const meetingsWith = async (store, uid, stored, since) => {
+    const none = { items: [], hasMore: false, accounts: [], pending: 0 };
+    if (!stored.length)
+        return none;
+    try {
+        const found = await personMeetingContext(store, `person:${uid}`, {
+            accountIds: stored.slice(0, 1000).map(({ id }) => id),
+            meetings: MEETINGS,
+            cues: CUES,
+            bytes: PERSON_BYTES,
+            ...(since === undefined ? {} : { since }),
+        });
+        return {
+            items: found.items,
+            hasMore: found.coverage.truncatedBy !== null || found.coverage.scanLimitReached,
+            accounts: [...new Set(found.items.map((item) => parseMeetingReference(item.reference).accountId))],
+            pending: found.coverage.pending,
+        };
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "not_found")
+            return none;
+        throw error;
+    }
+};

package/dist/calendar/testing/answers.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 /**
  * Parses what a shared calendar command handed its host against the command's entity, as a host prints it: keys in
- * snake_case, a list's items one by one, a search's hits each with the search's `untrusted`, and no `next`.
+ * snake_case, a list's items one by one, a search's hits each with the search's `untrusted`, and no `next`. A `meta`
+ * goes into the host's envelope, never into the item.
  */
 export declare const checkCalendarAnswer: (root: Command, argv: readonly string[], value: unknown) => void;

package/dist/calendar/testing/answers.js

@@ -13,14 +13,15 @@ const commandAt = (root, argv) => {
 };
 /**
  * Parses what a shared calendar command handed its host against the command's entity, as a host prints it: keys in
- * snake_case, a list's items one by one, a search's hits each with the search's `untrusted`, and no `next`.
+ * snake_case, a list's items one by one, a search's hits each with the search's `untrusted`, and no `next`. A `meta`
+ * goes into the host's envelope, never into the item.
  */
 export const checkCalendarAnswer = (root, argv, value) => {
     const command = commandAt(root, argv);
     const schema = answerEntitySchema(command);
     if (!schema)
         throw new Error(`${argv.join(" ")} declares no answer entity`);
-    const { next: _next, ...body } = snakeKeys(value);
+    const { next: _next, meta: _meta, ...body } = snakeKeys(value);
     const marker = body.untrusted
         ?.filter((field) => field.startsWith("hits."))
         .map((field) => field.slice("hits.".length));

package/dist/entities/contact-context.d.ts

@@ -1,4 +1,26 @@
 import * as v from "valibot";
+export declare const contextMessage: v.StrictObjectSchema<{
+    readonly locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly provider: v.StringSchema<undefined>;
+    readonly account: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly sender_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly text: v.StringSchema<undefined>;
+}, undefined>;
+export declare const contextEvent: v.StrictObjectSchema<{
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly all_day: v.BooleanSchema<undefined>;
+    readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly status: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
 export declare const contactMessages: v.StrictObjectSchema<{
     readonly person: v.StrictObjectSchema<{
         readonly uid: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -1401,6 +1423,19 @@ export declare const contactContext: v.UnionSchema<[v.StrictObjectSchema<{
         readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>;
 }, undefined>], undefined>;
+export declare const meetingCue: v.StrictObjectSchema<{
+    readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly fingerprint: v.StringSchema<undefined>;
+    readonly transcript_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly content_hash: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly start_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly end_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly speaker_participant_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly speaker_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly text: v.StringSchema<undefined>;
+    readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
+}, undefined>;
 export declare const contactPreparation: v.StrictObjectSchema<{
     readonly person: v.StrictObjectSchema<{
         readonly uid: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/contact-context.js

@@ -4,7 +4,7 @@ import { linkedPerson } from "./contact-activity.js";
 import { count, id, reference, text, time } from "./fields.js";
 import { message } from "./message.js";
 const contextPerson = v.strictObject({ ...linkedPerson.entries, provider: text, id });
-const contextMessage = v.strictObject({
+export const contextMessage = v.strictObject({
     locator: reference,
     provider: text,
     account: id,
@@ -25,7 +25,7 @@ const sharedChat = v.strictObject({
     kind: chat.entries.kind,
     last_message_at: v.nullable(time),
 });
-const contextEvent = v.strictObject({
+export const contextEvent = v.strictObject({
     ref: reference,
     title: v.nullable(text),
     starts_at: v.nullable(time),
@@ -124,7 +124,7 @@ const coverage = v.strictObject({
     has_more: v.boolean(),
     cut_by: v.nullable(v.picklist(["limit", "bytes"])),
 });
-const meetingCue = v.strictObject({
+export const meetingCue = v.strictObject({
     reference,
     fingerprint: text,
     transcript_id: count,

package/dist/errors/reasons.d.ts

@@ -7,7 +7,7 @@ export declare const REASONS: ErrorReason[];
  * Detail keys an error from this package may carry, until each is registered on its own reason. Not `cause`:
  * that can hold a provider's or SQLite's raw text.
  */
-export declare const DETAILS: readonly ["contracts", "calendars", "allowed", "alternative", "arguments", "at", "available", "batch", "budget", "built", "candidates", "chat", "chat_id", "cli", "complete", "emitted_bytes", "exact", "forum", "guide", "hint", "id", "index", "kind", "limit", "limit_source", "max_bytes", "model", "name", "operation_id", "operation_ids", "text_limit", "store_refused_in", "partial_output", "path", "permission", "person_ids", "previous_chat_id", "profiles", "provider_error", "provider", "recovery", "reference", "remembered", "retry_at", "retry_after_ms", "runtime", "saved", "scheduled_for", "script", "sent", "sent_count", "settlement_failed", "span", "sqlite", "stage", "standing", "state", "stderr", "term", "total", "upgraded", "wanted"];
+export declare const DETAILS: readonly ["contracts", "calendars", "allowed", "alternative", "arguments", "at", "available", "batch", "budget", "built", "candidates", "chat", "chat_id", "cli", "complete", "emitted_bytes", "exact", "forum", "guide", "hint", "id", "index", "kind", "limit", "limit_source", "max_bytes", "model", "name", "operation_id", "operation_ids", "text_limit", "store_refused_in", "subtasks", "partial_output", "parent", "path", "permission", "person_ids", "previous_chat_id", "profiles", "provider_error", "provider", "recovery", "reference", "remembered", "retry_at", "retry_after_ms", "runtime", "saved", "scheduled_for", "script", "sent", "sent_count", "settlement_failed", "span", "sqlite", "stage", "standing", "state", "stderr", "term", "total", "upgraded", "wanted"];
 /** What a CLI adds to the shared registry: its own reasons, and the detail keys its adapters raise. */
 export interface AppErrors {
     reasons?: readonly ErrorReason[];

package/dist/errors/reasons.js

@@ -65,6 +65,9 @@ const OTHERS = [
     ["calendar.read-only", "permission_error", "the calendar takes no new events from this account"],
     ["calendar.unsynced", "not_found", "the calendar account has no synced calendar in the store"],
     ["calendar.sync-incomplete", "not_found", "a synced calendar's sync never finished or is mid-round"],
+    ["calendar.no-upcoming", "not_found", "no upcoming meeting with other attendees is stored for this account"],
+    ["chat.not-read", "not_found", "a chat shared with this person is not held whole in the store"],
+    ["meetings.index-pending", "not_found", "some stored meetings are not indexed by person yet"],
     ["profile.locked", "permission_error", "a profile lock pins this process to its own account"],
     ["busy.offline", "permission_error", "calendars busy asks the provider; --offline was given"],
     validation("busy.no-calendars", "no calendar syncs and no person was named, so there is nobody to ask"),
@@ -134,6 +137,7 @@ const OTHERS = [
     validation("task.column", "the task beside which it moves is in another column than the status asked for"),
     validation("task.dependency-cycle", "the task would depend on itself"),
     validation("task.has-subtasks", "the task has subtasks; move or detach them before it moves to another project"),
+    validation("task.is-subtask", "a subtask moves to another project only when it is detached from its parent in the same write"),
     validation("task.duplicate-candidates", "open tasks may be the same job: attach to one, or add it as new"),
     validation("task.certainty-required", "an agent closes a task with its certainty, 0 to 1"),
     ["task.pair-decided", "permission_error", "the owner already decided the pair; an agent does not change it"],
@@ -210,7 +214,9 @@ export const DETAILS = [
     "operation_ids",
     "text_limit",
     "store_refused_in",
+    "subtasks",
     "partial_output",
+    "parent",
     "path",
     "permission",
     "person_ids",

package/dist/mail/server-search.js

@@ -9,7 +9,8 @@ import { factsOf } from "./facts.js";
 import { mailHeadersOf } from "./headers.js";
 import { parseMail } from "./parse.js";
 import { storedMailRules } from "./rule-stored.js";
-import { decide } from "./rules.js";
+import { ruleTagger, settleRuleTags } from "./rule-tags.js";
+import { decide, tagsOf } from "./rules.js";
 import { mailCriteriaOf } from "./server-query.js";
 const refusal = {
     unsupported: "this mailbox's server cannot be searched — use --backend archive",
@@ -74,6 +75,8 @@ export const searchMailServer = async (store, mailbox, access, request) => {
     };
     const accountId = await store.accounts.saveAccount(mailbox, { name: mailbox.account });
     const fresh = [];
+    let rules = [];
+    const ruled = new Map();
     let raws;
     let opening;
     let openFailure;
@@ -124,7 +127,7 @@ export const searchMailServer = async (store, mailbox, access, request) => {
         if (!open)
             return;
         const unique = [...new Map(listed.map((item) => [item.messageId, item])).values()];
-        const rules = await storedMailRules(store, { address: mailbox.account });
+        rules = await storedMailRules(store, { address: mailbox.account });
         const facts = factsOf(unique, rules);
         for (const item of unique) {
             const held = (await store.mail.email(accountId, item.messageId)) !== null;
@@ -133,8 +136,10 @@ export const searchMailServer = async (store, mailbox, access, request) => {
                 continue;
             report.returned += 1;
             sources.set(sourceKey(item.threadId, item.messageId), held ? "both" : "server");
-            if (!held)
-                fresh.push(item);
+            if (held)
+                continue;
+            fresh.push(item);
+            ruled.set(item, { ruleId: rule?.id ?? null, tags: tagsOf(rules, facts(item)) });
         }
         if (fresh.length)
             raws = await source.fetchRaw(fresh);
@@ -175,6 +180,7 @@ export const searchMailServer = async (store, mailbox, access, request) => {
     }
     const now = Date.now();
     const inputs = [];
+    const saved = [];
     for (const [index, item] of fresh.entries()) {
         const raw = raws?.[index];
         try {
@@ -201,10 +207,12 @@ export const searchMailServer = async (store, mailbox, access, request) => {
                             : { locations: [{ folder, uidvalidity: validity, uid: Number(item.uid) }] }),
                         ...(item.seen === undefined ? {} : { read: item.seen }),
                         ...(item.flagged === undefined ? {} : { flagged: item.flagged }),
+                        mailRuleId: ruled.get(item)?.ruleId ?? null,
                         attachments: files,
                     },
                 ],
             });
+            saved.push(item);
         }
         catch {
             sources.delete(sourceKey(item.threadId, item.messageId));
@@ -213,6 +221,14 @@ export const searchMailServer = async (store, mailbox, access, request) => {
     }
     if (inputs.length)
         await store.mail.saveThreads(inputs);
+    // Sync never reads mail whose place it knows again, so a rule's tags go on here or never.
+    const tagger = ruleTagger(store, mailbox);
+    for (const item of saved) {
+        const tags = ruled.get(item)?.tags ?? [];
+        if (tags.length)
+            await tagger.tag({ type: "message", chatId: item.threadId, messageId: item.messageId }, tags);
+    }
+    await settleRuleTags(store, accountId, rules, tagger.outcome());
     report.new = inputs.length;
     report.returned = sources.size;
     return { report, sources };

package/dist/meetings/mcp/index.d.ts

@@ -38,7 +38,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -54,11 +53,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -76,11 +75,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -102,6 +101,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -188,7 +188,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -204,11 +203,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -226,11 +225,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -252,6 +251,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -338,7 +338,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -354,11 +353,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -376,11 +375,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -402,6 +401,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -488,7 +488,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -504,11 +503,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -526,11 +525,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -552,6 +551,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -638,7 +638,6 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -654,11 +653,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -676,11 +675,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
-            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -702,6 +701,7 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
+            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;

package/dist/services/person-context.d.ts

@@ -93,7 +93,12 @@ export declare const readsOf: (record: PersonRecord, asked: AccountKey) => {
  * What the store knows about one person, across every identity linked to them. Reads the store
  * only: nothing is fetched, nothing marked read. Identity is by id, never by name.
  */
-export declare const personContext: (store: MessageStore, asked: AccountKey, reference: string, { messages, bytes, since, now }?: ContextOptions) => Promise<PersonContext>;
+export declare const personContext: (store: MessageStore, asked: AccountKey, reference: string, options?: ContextOptions) => Promise<PersonContext>;
+/** `personContext` of a person already found, read in the identities and accounts `reads` names. */
+export declare const recordContext: (store: MessageStore, record: PersonRecord, reads: {
+    key: AccountKey;
+    identity: LinkedIdentity;
+}[], { messages, bytes, since, now }?: ContextOptions) => Promise<Omit<PersonContext, "person">>;
 /** `max:Ana` names a person in another messenger of this store; a reference with no prefix, this one. */
 export declare const identityIn: (store: MessageStore, asked: AccountKey, reference: string) => Promise<IdentityRef>;
 export declare const CHAT_MESSAGES = 20;

package/dist/services/person-context.js

@@ -92,11 +92,18 @@ export const readsOf = (record, asked) => record.identities.flatMap((identity) =
  * What the store knows about one person, across every identity linked to them. Reads the store
  * only: nothing is fetched, nothing marked read. Identity is by id, never by name.
  */
-export const personContext = async (store, asked, reference, { messages = CONTEXT_MESSAGES, bytes = CONTEXT_BYTES, since, now = Date.now() } = {}) => {
+export const personContext = async (store, asked, reference, options = {}) => {
     const found = pickPerson(reference, await store.people.people(asked.provider, { account: asked.account }));
     const record = await store.people.personOf({ provider: asked.provider, id: found.id });
     if (!record)
         throw new CliError("not_found", `no person ${found.id} in the store`);
+    return {
+        person: { ...record, provider: asked.provider, id: found.id },
+        ...(await recordContext(store, record, readsOf(record, asked), options)),
+    };
+};
+/** `personContext` of a person already found, read in the identities and accounts `reads` names. */
+export const recordContext = async (store, record, reads, { messages = CONTEXT_MESSAGES, bytes = CONTEXT_BYTES, since, now = Date.now() } = {}) => {
     const recent = (message) => since === undefined || Date.parse(message.timestamp) >= since;
     const shared = [];
     const notRead = [];
@@ -106,7 +113,7 @@ export const personContext = async (store, asked, reference, { messages = CONTEX
     const theirs = [];
     const mentions = [];
     let cut = false;
-    for (const { key, identity } of readsOf(record, asked)) {
+    for (const { key, identity } of reads) {
         const chats = await store.chats.chatsWith(key, identity.id);
         for (const chat of chats) {
             shared.push({ ...key, chatId: chat.id, title: chat.title, kind: chat.kind, lastMessageAt: chat.lastMessageAt });
@@ -177,7 +184,6 @@ export const personContext = async (store, asked, reference, { messages = CONTEX
     cut ||= direct.length > messages || groups.length > messages || mentions.length > messages;
     const kept = withinBytes(lists, bytes);
     return {
-        person: { ...record, provider: asked.provider, id: found.id },
         shared: shared.sort((a, b) => Date.parse(b.lastMessageAt ?? "") - Date.parse(a.lastMessageAt ?? "")),
         last: {
             fromThem: each.find((message) => !message.outgoing) ?? null,

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

@@ -165,7 +165,9 @@ export const evidenceFindingsStoreOver = (context) => {
             }
             const input = proposal.payload;
             // Rejecting creates nothing, so a batch whose evidence changed can still be closed. Accepting needs only the
-            // accepted findings' own project, assignee and evidence unchanged; a batch staged before parts were kept needs all.
+            // accepted findings' own evidence and assignee unchanged. The project is left out: every task a sibling batch
+            // creates moves its row, and the project still has to exist, which citing checks. A batch staged before parts
+            // were kept needs all.
             if (accepted.length) {
                 const parts = input.snapshotParts;
                 if (!parts) {
@@ -175,7 +177,7 @@ export const evidenceFindingsStoreOver = (context) => {
                 else {
                     const chosen = { ...batch.input, findings: batch.input.findings.filter((f) => accepted.includes(f.id)) };
                     const now = core.snapshotParts(chosen, cite());
-                    if (Object.entries(now).some(([key, hash]) => parts[key] !== hash))
+                    if (Object.entries(now).some(([key, hash]) => !key.startsWith("project:") && parts[key] !== hash))
                         return stale();
                 }
             }

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

@@ -27,6 +27,7 @@ export const PROJECT_TASK_FIELDS = [
         relation: "low, medium, high, critical or none; a range of labels or of the 0–1 number: priority:[high TO critical]",
     }),
     field("agent", "kw", "agent:hermes", { relation: "the agent working on it, by name; none or any" }),
+    field("parent", "kw", "parent:HRB-1", { relation: "the subtasks of a task, by its key; none or any" }),
     field("due", "time", "due:[today TO 2026-12-31]", {
         relation: "the due date; today, tomorrow and yesterday are your calendar days; NOT due:* has none",
     }),
@@ -134,6 +135,20 @@ const agentWhere = (node) => {
         ? { sql: "lower(t.agent) GLOB ?", params: [value] }
         : { sql: "lower(t.agent) = ?", params: [value] };
 };
+/** A key the task had before it moved to another project still names it. */
+const parentWhere = (node) => {
+    const value = node.value.trim();
+    if (value.toLowerCase() === "none")
+        return { sql: "t.parent_id IS NULL", params: [] };
+    if (value.toLowerCase() === "any")
+        return { sql: "t.parent_id IS NOT NULL", params: [] };
+    const key = value.replace(/^task:/, "");
+    return {
+        sql: "t.parent_id IN (SELECT id FROM tasks WHERE key = ? OR package_id = ? UNION SELECT task_id FROM task_events " +
+            "WHERE kind = 'project' AND json_extract(changes, '$.key[0]') = ?)",
+        params: [key.toUpperCase(), key, key.toUpperCase()],
+    };
+};
 const truth = (node, sql) => ({
     sql: node.value.toLowerCase() === "true" ? sql : `NOT (${sql})`,
     params: [],
@@ -166,6 +181,7 @@ export const projectTaskColumns = (now, zone) => ({
     assignee: { where: assigneeWhere },
     priority: { where: priorityWhere },
     agent: { where: agentWhere },
+    parent: { where: parentWhere },
     due: { type: "time", sql: "t.due_at" },
     closed: { type: "time", sql: "t.closed_at" },
     overdue: { where: (node) => truth(node, dueGroups(now, zone).overdue) },

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

@@ -31,7 +31,10 @@ export interface TaskFields {
     reason?: string | null;
     /** A name the caller checked against its category list; every change is a `category` event. */
     category?: string;
-    /** Another owner project, by key or `project:<id>`: the task takes the next key there; its old key still finds it. */
+    /**
+     * Another owner project, by key or `project:<id>`: the task takes the next key there; its old key still finds it.
+     * A subtask moves only with `parent: null` in the same edit.
+     */
     project?: string;
     /** A project task's kind, bug, feature or chore. */
     type?: WorkTaskType;

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

@@ -170,7 +170,7 @@ export const workTaskOperationsOver = (context) => {
     const details = (id) => detailsOf(rowById(id));
     const onBoard = (task) => Boolean(database.prepare(`SELECT 1 FROM tasks t WHERE t.id = ? AND ${BOARD_SCOPE}`).get(task));
     /** The task takes the target's next number and key; the source's counter never goes back, so its old key stays unique. */
-    const moveToProject = (task, before, target, actor, at) => {
+    const moveToProject = (task, before, target, actor, at, detach) => {
         if (target === Number(before.project_id))
             return;
         if (!onBoard(task))
@@ -178,6 +178,10 @@ export const workTaskOperationsOver = (context) => {
         const targetRow = database.prepare("SELECT key FROM projects WHERE id = ?").get(target);
         if (String(targetRow.key).length === INBOX_KEY_LENGTH)
             throw new CliError("validation_error", "a task moves only into one of your projects");
+        if (before.parent_id != null && !detach) {
+            const parent = taskIdOf(database, Number(before.parent_id));
+            throw new CliError("validation_error", `${String(before.key)} is a subtask of ${parent}; detach it in the same write (parent none) to move it alone`, { reason: "task.is-subtask", parent });
+        }
         const children = database
             .prepare("SELECT key FROM tasks WHERE parent_id = ? AND deleted_at IS NULL ORDER BY id")
             .all(task)
@@ -280,7 +284,7 @@ export const workTaskOperationsOver = (context) => {
             bump = true;
         }
         if (fields.project !== undefined)
-            moveToProject(task, before, projectOf(fields.project), actor, at);
+            moveToProject(task, before, projectOf(fields.project), actor, at, fields.parent === null);
         if (set.length === 0) {
             if (bump)
                 database.prepare("UPDATE tasks SET revision = revision + 1 WHERE id = ?").run(task);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.537.0",
+  "version": "0.538.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",