@wirecat/cli-core 0.537.0 → 0.539.0

package/CHANGELOG.md

@@ -7,6 +7,65 @@ shape of this file.
 
 ## Unreleased
 
+## 0.539.0 — 01.11.2026
+
+### Added
+
+- **`events create --text <line>`**: an event the provider reads from one line, such as 'Lunch with Ana tomorrow
+  1pm', when the writer has the new optional `CalendarWriter.quickAdd`. Checked as `events.create` and
+  `extraKeys("quick-add")`; takes no `--operation-id`, since the provider picks the id, and mails nobody without
+  `--notify`.
+- **`events export [query…] [--output <file>]`**: the events `events list`'s query finds, as iCalendar (RFC 5545).
+  `--output` exists when the host passes `deps.writeFile`, and is left out of MCP tools: an agent gets the text.
+  `writeIcs` and `readIcs` are in `./calendar`.
+- **`events import <calendar> <file>`**: an iCalendar file's events into a calendar, each under its UID, when the
+  writer has the new optional `CalendarWriter.importEvent` and the host passes `deps.readFile`. Its key `events.import`
+  asks by default (`CALENDAR_WRITE_DEFAULTS`).
+- **`events list` takes `id:<id>` and `event_type:<kind>`**, and `-event_type:<kind>` or `NOT event_type:<kind>` to
+  leave a kind out, such as birthdays and working-location blocks; filtered in the store
+  (`EventFilter.id`, `eventType`, `notEventTypes`). `nativeTermLists` takes the fields a list lets the query exclude.
+- **A calendar by its title**: `calendar:`, `<calendar>`, `--calendar` and `--to-calendar` take a calendar's title,
+  case aside, after its id and the provider's id. A title two calendars share is refused (`calendar.ambiguous`) with
+  their ids.
+
+### Changed — may break callers
+
+- `CalendarWrite` has `quick-add` and `import`: a `Record<CalendarWrite, …>`, such as a CLI's map of write to its API
+  keys, needs both.
+
+## 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/busy.js

@@ -29,7 +29,7 @@ export const BUSY_QUERY = {
             calendar: {
                 type: "kw",
                 example: "calendar:3",
-                relation: "one of the account's calendars, by its id or the provider's id; repeat for more",
+                relation: "one of the account's calendars, by its id, the provider's id or its title; repeat for more",
             },
             person: { type: "kw", example: "person:ana@example.com", relation: "someone else, by address; repeat for more" },
         },

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

@@ -236,6 +236,42 @@ export declare const calendarEventWrite: v.StrictObjectSchema<{
     readonly hint: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;
+export declare const calendarExport: v.StrictObjectSchema<{
+    readonly format: v.LiteralSchema<"ics", undefined>;
+    readonly events: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    /** The iCalendar text, when no `--output` took it. */
+    readonly content: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly output: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export declare const calendarImport: v.StrictObjectSchema<{
+    readonly operation_id: v.StringSchema<undefined>;
+    readonly calendar: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly imported: v.ArraySchema<v.StrictObjectSchema<{
+        readonly uid: v.StringSchema<undefined>;
+        readonly event: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly entry: v.NullableSchema<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>;
+    }, undefined>, undefined>;
+    readonly skipped: v.ArraySchema<v.StrictObjectSchema<{
+        readonly uid: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly reason: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
 export declare const calendarAttendee: v.StrictObjectSchema<{
     readonly email: v.StringSchema<undefined>;
     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -249,6 +285,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);
@@ -174,12 +175,52 @@ export const calendarEventWrite = v.strictObject({
     hint: v.optional(text),
     untrusted,
 });
+export const calendarExport = v.strictObject({
+    format: v.literal("ics"),
+    events: count,
+    /** The iCalendar text, when no `--output` took it. */
+    content: v.optional(text),
+    output: v.optional(text),
+    untrusted: v.optional(v.array(text)),
+});
+export const calendarImport = v.strictObject({
+    operation_id: text,
+    calendar: id,
+    imported: v.array(v.strictObject({ uid: text, event: nullableText, entry: v.nullable(entry) })),
+    skipped: v.array(v.strictObject({ uid: nullableText, reason: text })),
+    untrusted,
+});
 export const calendarAttendee = v.strictObject({
     ...attendee,
     /** How many of the listed events the person attends; only on the week's list. */
     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 +239,9 @@ 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 export": { name: "calendar_export", schema: calendarExport },
+    "events import": { name: "calendar_import", schema: calendarImport },
     "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.d.ts

@@ -39,6 +39,10 @@ export interface CalendarCommandDeps {
     timezone?: string;
     /** The provider's writer and the profile's guard: `events create|update|delete|respond` exist only with it. */
     writes?: CalendarWrites;
+    /** Writes `events export --output`'s file; without it the export is printed only. */
+    writeFile?: (path: string, content: string) => Promise<void>;
+    /** Reads `events import`'s file; without it, and the writer's `import`, there is no `events import`. */
+    readFile?: (path: string) => Promise<string>;
     /** A profile lock pins the process (WC-ACCT-5): `events list --source` may then read only the profile's account. */
     locked?: boolean;
 }

package/dist/calendar/cli/index.js

@@ -4,17 +4,20 @@ import { timezoneOf } from "@wirecat/cli-base/query";
 import { Argument, InvalidArgumentError, Option } from "commander";
 import { environmentOf, runBudgetOf } from "../../cli/context.js";
 import { honoursDryRun } from "../../cli/dry-run-guard.js";
+import { ownerOnlyOption } from "../../cli/effects.js";
 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 { 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 { eventPreparation, nextMeeting, PREPARE_MESSAGES } from "../prepare.js";
+import { accountsMeta, CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY, EVENTS_QUERY_NOTE, EXPORT_MAX, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, eventsIcs, peopleAnswer, resolveAnswer, reviewsAnswer, sourceAccounts, weekFilter, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
 import { bothSearchAnswer, serverSearchAnswer } from "../server-search.js";
 import { calendarStatus, syncCalendars } from "../sync.js";
-import { createEvent, deleteEvent, EVENT_RESPONSES, moveEvent, respondToEvent, updateEvent, } from "../writes.js";
+import { createEvent, createEventFromText, deleteEvent, EVENT_RESPONSES, IMPORT_MAX, importEvents, moveEvent, respondToEvent, updateEvent, } from "../writes.js";
 import { CALENDARS_QUERY, declareCalendarAnswers, PEOPLE_QUERY } from "./answers.js";
 const LOCAL_READ = { remote: "none", local: "read" };
 const LOCAL_WRITE = { remote: "none", local: "write" };
@@ -31,6 +34,9 @@ const ATTENDEE_UNTRUSTED = ["name"];
 const REVIEW_UNTRUSTED = ["candidates.title"];
 const SEARCH_UNTRUSTED = ["hits.title", "hits.location", "hits.excerpt"];
 const SERVER_SEARCH_UNTRUSTED = ["hits.title", "hits.location"];
+const IMPORT_UNTRUSTED = ["imported.uid", "imported.entry.title", "skipped.uid", "skipped.reason"];
+/** The largest .ics file `events import` reads. */
+const ICS_MAX_BYTES = 10 * 1024 * 1024;
 const eachMarked = (answer, untrusted) => ({
     ...answer,
     items: answer.items.map((item) => ({ ...item, untrusted })),
@@ -40,6 +46,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)
@@ -93,7 +105,7 @@ const addCalendarCommandsDefinition = (program, deps) => {
     ])
         example(annotate(calendars.command(name), { effects: LOCAL_WRITE })
             .description(synced ? "sync this calendar from now on" : "stop syncing this calendar; what is stored stays")
-            .argument("<calendar>", "the calendar's id, or the provider's id"), `calendars ${name} 3`).action(async (reference, _opts, command) => {
+            .argument("<calendar>", "the calendar's id, the provider's id, or its title"), `calendars ${name} 3`).action(async (reference, _opts, command) => {
             const calendar = await calendarIn(deps.store, deps.accountId, reference);
             await deps.store.setCalendarSynced(calendar.id, synced, now());
             print(calendarItem({ ...calendar, synced }), command);
@@ -226,12 +238,67 @@ const addCalendarCommandsDefinition = (program, deps) => {
             meta: await accountsMeta(deps.store, accounts, skipped, now()),
         }, command);
     });
+    const exporter = example(withQuery(annotate(events.command("export"), { effects: deps.writeFile ? LOCAL_WRITE : LOCAL_READ }).description(`write stored events as iCalendar (.ics), at most ${EXPORT_MAX}: one with id:<id>, or those the query ` +
+        "finds; each occurrence of a repeating event as an event of its own"), EVENTS_QUERY).addHelpText("after", EVENTS_QUERY_NOTE), ...(deps.writeFile
+        ? [
+            "events export id:42 --output planning.ics",
+            "events export starts_at:[2026-11-02 TO 2026-11-09} NOT event_type:birthday --output week.ics",
+        ]
+        : ["events export id:42", "events export starts_at:[2026-11-02 TO 2026-11-09} NOT event_type:birthday"]));
+    // Not over MCP: an agent would choose where on the owner's disk to write. It gets the text in the answer.
+    if (deps.writeFile)
+        exporter.addOption(ownerOnlyOption("--output <file>", "the file to write; printed in the answer when absent"));
+    exporter.action(async (words, opts, command) => {
+        const filter = await eventsFilter(words, {
+            store: deps.store,
+            accountId: deps.accountId,
+            zone: zone(),
+            now: now(),
+            personOf: personId,
+        });
+        const exported = await eventsIcs(deps.store, deps.accountId, filter, { now: now(), product: program.name() });
+        if (opts.output === undefined) {
+            print({ ...exported, untrusted: ["content"] }, command);
+            return;
+        }
+        if (!opts.output.trim())
+            throw new CliError("validation_error", "--output names no file");
+        await deps.writeFile?.(opts.output, exported.content);
+        print({ format: exported.format, events: exported.events, output: opts.output }, command);
+    });
     example(annotate(events.command("show"), { effects: LOCAL_READ })
         .description("one event: its calendar copies, attendees with their person, Drive files and history")
         .argument("<event>", "the event's id, or event:<id>"), "events show event:42 --json").action(async (reference, _opts, command) => {
         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,
     });
@@ -369,6 +436,7 @@ const addEventWrites = (events, writes, { deps, now, zone, print, example }) =>
         // The empty default marks the flag as repeatable, so an agent's tool takes a list; empty is "not given".
         .option("--attendee <email>", `an attendee; repeat for each${replacing ? ", replacing the list" : ""}`, collect, [])
         .option("--repeat <rule>", `how it repeats${replacing ? ", with --series" : ""}: ${REPEAT_HELP}`);
+    const flagOf = (field) => field === "attendees" ? "--attendee" : `--${field.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`)}`;
     const fieldsOf = ({ attendee, ...given }) => ({
         ...Object.fromEntries(Object.entries(given).filter(([, value]) => value !== undefined)),
         ...(attendee === undefined || attendee.length === 0 ? {} : { attendees: attendee }),
@@ -382,13 +450,30 @@ const addEventWrites = (events, writes, { deps, now, zone, print, example }) =>
     const write = (name) => annotate(events.command(name), { effects: REMOTE_WRITE, offline: false });
     const target = (command) => command
         .argument("<event>", "the event's id, or event:<id>")
-        .option("--calendar <id>", "the calendar, when the event is on more than one of the account's");
-    example(notify(fields(write("create"), false)
-        .description("add an event to a calendar; with --repeat, one that repeats")
-        .argument("<calendar>", "the calendar's id, or the provider's id")).option("--operation-id <id>", "the operation_id a create that ended in outcome_unknown named: a retry finds that event"), "events create 3 --title 'Example planning' --start-time 2026-11-02T10:00 --end-time 2026-11-02T11:00", "events create 3 --title 'Example review' --start-date 2026-11-03 --end-date 2026-11-03 " +
+        .option("--calendar <id>", "the calendar, by id or title, when the event is on more than one of the account's");
+    const quick = writes.writer.quickAdd !== undefined;
+    const create = example(notify(fields(write("create"), false)
+        .description(quick
+        ? "add an event to a calendar; with --repeat, one that repeats; with --text, one the provider reads " +
+            "from a line such as 'Lunch with Ana tomorrow 1pm'"
+        : "add an event to a calendar; with --repeat, one that repeats")
+        .argument("<calendar>", "the calendar's id, the provider's id, or its title")).option("--operation-id <id>", "the operation_id a create that ended in outcome_unknown named: a retry finds that event"), quick
+        ? "events create Work --text 'Example lunch with Ana tomorrow 1pm at Example Cafe'"
+        : "events create 3 --title 'Example planning' --start-time 2026-11-02T10:00 --end-time 2026-11-02T11:00", "events create 3 --title 'Example review' --start-date 2026-11-03 --end-date 2026-11-03 " +
         "--attendee ana@example.com --no-notify", "events create 3 --title 'Example standup' --start-time 2026-11-02T09:30 --end-time 2026-11-02T09:45 " +
-        "--repeat 'FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=12'").action(async (calendar, opts, command) => {
-        const { notify: choice, operationId: id, ...rest } = opts;
+        "--repeat 'FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=12'");
+    if (quick)
+        create.option("--text <text>", "one line the provider reads the title, date, time and place from, in place of the other fields; nobody is " +
+            "mailed without --notify, and a retry after outcome_unknown may add the event twice");
+    create.action(async (calendar, opts, command) => {
+        const { notify: choice, operationId: id, text, ...rest } = opts;
+        if (text !== undefined) {
+            const given = Object.keys(fieldsOf(rest));
+            if (given.length || id !== undefined)
+                throw new CliError("validation_error", `--text takes the whole event from its line; leave out ${[...given.map(flagOf), ...(id === undefined ? [] : ["--operation-id"])].join(", ")}`, { reason: "event.text-with-fields", param: "--text" });
+            printWritten(await createEventFromText(context(command), calendar, text, choice === undefined ? {} : { notify: choice }), command);
+            return;
+        }
         printWritten(await createEvent(context(command), calendar, fieldsOf(rest), {
             ...(choice === undefined ? {} : { notify: choice }),
             ...(id === undefined ? {} : { id }),
@@ -414,10 +499,24 @@ const addEventWrites = (events, writes, { deps, now, zone, print, example }) =>
         .option("--following", "delete this occurrence and every later one: the repeating event ends before it")), "events delete event:42 --no-notify", "events delete event:42 --following --no-notify").action(async (reference, opts, command) => {
         printWritten(await deleteEvent(context(command), reference, choicesOf(opts)), command);
     });
+    const readFile = deps.readFile;
+    if (writes.writer.importEvent && readFile)
+        example(write("import")
+            .description(`add the events of an iCalendar (.ics) file to a calendar, at most ${IMPORT_MAX}, each under its own UID; ` +
+            "nobody is mailed; a changed occurrence of a repeating event (RECURRENCE-ID) is skipped")
+            .argument("<calendar>", "the calendar's id, the provider's id, or its title")
+            .argument("<file>", "the .ics file to read"), "events import Work planning.ics").action(async (calendar, file, _opts, command) => {
+            const text = await readFile(file);
+            if (Buffer.byteLength(text, "utf8") > ICS_MAX_BYTES)
+                throw new CliError("validation_error", `${file} is larger than ${ICS_MAX_BYTES / 1024 / 1024} MB`, {
+                    reason: "ics.too-large",
+                });
+            print({ ...(await importEvents(context(command), calendar, text)), untrusted: IMPORT_UNTRUSTED }, command);
+        });
     if (writes.writer.move)
         example(notify(target(write("move"))
             .description("move an event, with its id, to another calendar of the account; a repeating one moves whole")
-            .requiredOption("--to-calendar <id>", "the calendar to move it to: its id, or the provider's id")
+            .requiredOption("--to-calendar <id>", "the calendar to move it to: its id, the provider's id, or its title")
             .option("--series", "move the whole repeating event an occurrence belongs to")), "events move event:42 --to-calendar 4 --no-notify").action(async (reference, opts, command) => {
             const { series, calendar, notify } = opts;
             printWritten(await moveEvent(context(command), reference, opts.toCalendar, choicesOf({ series, calendar, notify })), command);

package/dist/calendar/ics.d.ts

@@ -0,0 +1,55 @@
+import type { EntryStatus, EntryTransparency, ParticipantResponse } from "../meetings/index.js";
+/**
+ * The part of iCalendar (RFC 5545, https://www.rfc-editor.org/rfc/rfc5545) the calendar commands read and write: one
+ * VCALENDAR of VEVENTs, with no VTIMEZONE. Times are written in UTC; a time read with a TZID keeps that zone's name,
+ * which the provider takes as it is.
+ */
+export interface IcsEvent {
+    uid: string;
+    title: string | null;
+    description?: string | null;
+    location?: string | null;
+    /** A timed event, epoch ms, end exclusive. */
+    startsAt?: number;
+    endsAt?: number;
+    /** An all-day event, `YYYY-MM-DD`, end exclusive. */
+    startDate?: string;
+    endDate?: string;
+    /** The zone a read time named (`TZID`), or the reader's zone for a floating one. */
+    timezone?: string | null;
+    /** RRULE, RDATE and EXDATE lines, as written. */
+    recurrence?: string[];
+    status?: EntryStatus | null;
+    transparency?: EntryTransparency | null;
+    organizer?: {
+        email: string;
+        name?: string | null;
+    } | null;
+    attendees?: {
+        email: string;
+        name?: string | null;
+        response?: ParticipantResponse | null;
+        optional?: boolean;
+    }[];
+    url?: string | null;
+}
+/** Lines longer than 75 octets go on under a leading space, never splitting a character's UTF-8 bytes. */
+export declare const foldLine: (line: string) => string;
+/** One VCALENDAR holding the events, CRLF line ends and folded lines, as RFC 5545 §3.1 asks. */
+export declare const writeIcs: (events: readonly IcsEvent[], options: {
+    now: number;
+    product: string;
+}) => string;
+/** An event the reader could not take, by its UID when it had one. */
+export interface IcsSkip {
+    uid: string | null;
+    reason: string;
+}
+/**
+ * The VEVENTs of an iCalendar text; times with neither `Z` nor a TZID are read in `zone`. An event that cannot be
+ * imported alone is in `skipped` with the reason; a text with no VCALENDAR is refused.
+ */
+export declare const readIcs: (text: string, zone: string) => {
+    events: IcsEvent[];
+    skipped: IcsSkip[];
+};