@wirecat/cli-core 0.463.0 → 0.465.0

package/dist/calendar/busy.js

@@ -0,0 +1,148 @@
+import { CliError } from "@wirecat/cli-base";
+import { dayBoundary, zonedMoment } from "@wirecat/cli-base/query";
+import { calendarIn, plusDays } from "./reads.js";
+export const BUSY_QUERY_HELP = `
+Words, any order:
+  today | week            today, or today and the next six days, in your time zone
+  from:<date> to:<date>   from the start of one day through the end of another (or a time with a zone)
+  calendar:<id>           one of the account's calendars, by its id or the provider's id; repeat for more
+  person:<email>          someone else, by email address; repeat for more
+Without a time word: this week. Without calendar:, every calendar that syncs.`;
+/** Google answers for 50 calendars at most (`calendarExpansionMax`, reference/freebusy/query). */
+const MOST = 50;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+const HOURS = /^([01]\d|2[0-3]):([0-5]\d)-([01]\d|2[0-4]):([0-5]\d)$/u;
+const MINUTE = 60_000;
+const localDate = (at, zone) => new Intl.DateTimeFormat("en-CA", { timeZone: zone, year: "numeric", month: "2-digit", day: "2-digit" }).format(at);
+const span = (text) => ({ start: 0, end: text.length });
+export const busyQuery = async (words, context) => {
+    const today = localDate(context.now, context.zone);
+    const day = (date) => dayBoundary(date, context.zone, false, span(date));
+    let from;
+    let to;
+    const calendars = [];
+    const people = new Set();
+    for (const word of words) {
+        const [, field, value = ""] = /^([a-z]+):(.+)$/u.exec(word) ?? [];
+        if (word === "today" || word === "week") {
+            from = day(today);
+            to = day(plusDays(today, word === "today" ? 1 : 7));
+        }
+        else if (field === "from")
+            from = zonedMoment(value, context.zone, span(value));
+        else if (field === "to")
+            to = zonedMoment(value, context.zone, span(value), { end: true }) + 1;
+        else if (field === "calendar") {
+            const calendar = await calendarIn(context.store, context.accountId, value);
+            if (!calendars.some(({ id }) => id === calendar.id))
+                calendars.push(calendar);
+        }
+        else if (field === "person") {
+            const email = value.trim().toLowerCase();
+            if (!EMAIL.test(email))
+                throw new CliError("validation_error", `${value} is not an email address`);
+            people.add(email);
+        }
+        else
+            throw new CliError("validation_error", `${word} is not a calendars busy word${BUSY_QUERY_HELP}`, {
+                reason: "query.unknown_word",
+            });
+    }
+    from ??= day(today);
+    to ??= from === day(today) ? day(plusDays(today, 7)) : from + 7 * 86_400_000;
+    if (to <= from)
+        throw new CliError("validation_error", "the window ends before it starts");
+    const asked = calendars.length
+        ? calendars
+        : (await context.store.calendars(context.accountId)).filter(({ synced, deletedAt }) => synced && !deletedAt);
+    if (asked.length === 0 && people.size === 0)
+        throw new CliError("validation_error", "no calendar syncs yet; name one with calendar:<id>, or a person:<email>", {
+            reason: "busy.no-calendars",
+        });
+    if (asked.length + people.size > MOST)
+        throw new CliError("validation_error", `at most ${MOST} calendars and people at once`);
+    return { window: { from, to }, calendars: asked, people: [...people] };
+};
+export const workingHoursOf = (text) => {
+    const match = HOURS.exec(text.trim());
+    const [start, end] = match ? [Number(match[1]) * 60 + Number(match[2]), Number(match[3]) * 60 + Number(match[4])] : [];
+    if (start === undefined || end === undefined || end <= start || end > 24 * 60)
+        throw new CliError("validation_error", "working hours are HH:MM-HH:MM in your time zone, such as 09:00-17:00");
+    return { start, end };
+};
+const clock = (minutes) => `${String(Math.floor(minutes / 60)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}`;
+/** Each weekday's working hours as moments in `zone`, so a day that changes its clock is still read in local time. */
+const workingSpans = (window, hours, zone) => {
+    const spans = [];
+    const last = localDate(window.to - 1, zone);
+    for (let date = localDate(window.from, zone); date <= last; date = plusDays(date, 1)) {
+        const weekday = new Date(`${date}T12:00:00Z`).getUTCDay();
+        if (weekday === 0 || weekday === 6)
+            continue;
+        const at = (minutes) => minutes === 24 * 60
+            ? dayBoundary(plusDays(date, 1), zone, false, span(date))
+            : zonedMoment(`${date}T${clock(minutes)}`, zone, span(date));
+        spans.push({ from: at(hours.start), to: at(hours.end) });
+    }
+    return spans;
+};
+/**
+ * The stretches of at least `minutes` inside working hours on weekdays, after `now`, that no busy time touches.
+ * A stretch is returned whole; the caller picks where in it to put the meeting.
+ */
+export const freeSlots = (busy, window, options) => {
+    const taken = [...busy].sort((a, b) => a.from - b.from);
+    const slots = [];
+    for (const day of workingSpans(window, options.hours, options.zone)) {
+        let cursor = Math.max(day.from, window.from, options.now);
+        const end = Math.min(day.to, window.to);
+        for (const one of taken) {
+            if (one.to <= cursor || one.from >= end)
+                continue;
+            if (one.from - cursor >= options.minutes * MINUTE)
+                slots.push({ from: cursor, to: one.from });
+            cursor = Math.max(cursor, one.to);
+        }
+        if (end - cursor >= options.minutes * MINUTE)
+            slots.push({ from: cursor, to: end });
+    }
+    return slots;
+};
+const iso = (at) => new Date(at).toISOString();
+const times = ({ from, to }) => ({ start: iso(from), end: iso(to) });
+/**
+ * `calendars busy`: the provider's busy times for the query, and with `slot` the free stretches every calendar and
+ * person shares. Nothing is stored, and a person appears only by the address the caller gave.
+ */
+export const busyAnswer = async (source, query, options) => {
+    if (!source.freeBusy)
+        throw new CliError("configuration_error", "this calendar provider cannot tell busy times");
+    const answered = await source.freeBusy({
+        calendars: query.calendars.map(({ externalId }) => externalId),
+        people: query.people,
+        window: query.window,
+    });
+    const byId = new Map(answered.map((one) => [one.id, one]));
+    const missing = (id) => byId.get(id) ?? { id, busy: [], error: "notAnswered" };
+    const rows = [
+        ...query.calendars.map((calendar) => ({ calendar: String(calendar.id), ...missing(calendar.externalId) })),
+        ...query.people.map((person) => ({ person, ...missing(person) })),
+    ];
+    const unknown = rows.filter(({ error }) => error !== undefined).map(({ id }) => id);
+    return {
+        ...times(query.window),
+        timezone: options.zone,
+        calendars: rows.map(({ busy, error, ...row }) => ({
+            ...row,
+            busy: busy.map(times),
+            ...(error === undefined ? {} : { error }),
+        })),
+        ...(options.slot
+            ? {
+                slots: freeSlots(rows.flatMap(({ busy }) => busy), query.window, { ...options.slot, zone: options.zone, now: options.now }).map(times),
+                // Free here means free in every calendar the provider answered for: these were not.
+                ...(unknown.length ? { unknown } : {}),
+            }
+            : {}),
+    };
+};

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

@@ -9,10 +9,17 @@ export interface CalendarCommandDeps {
     accountId: number;
     /** The same account as the shared store names it, for search and people. */
     account: AccountKey;
+    /** The profile's name, which `status` gives as each sync's `profile`. */
+    profile?: string;
     /** The shared store: `search`, `people link` and the person of an attendee read it. */
     messages?: MessageStore;
     /** The provider; `sync` and `calendars list` read it. */
     source?: CalendarSource;
+    /**
+     * The source answers `freeBusy`: mounts `calendars busy`. A flag rather than a look at `source`, which a CLI may
+     * build only once a profile is open.
+     */
+    freeBusy?: boolean;
     /** For a source with `expands: "local"`. */
     expand?: CalendarExpander;
     /** After `sync --embed`: embeds new events for search by meaning (`embedEvents`), as drive's `sync --embed`. */

package/dist/calendar/cli/index.js

@@ -2,16 +2,21 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
 import { timezoneOf } from "@wirecat/cli-base/query";
 import { Argument, InvalidArgumentError } from "commander";
+import { environmentOf, runBudgetOf } from "../../cli/context.js";
 import { honoursDryRun } from "../../cli/dry-run-guard.js";
 import { terminalAsker } from "../../cli/messenger/ask.js";
+import { lineOf } from "../../cli/steps.js";
 import { searchEvents } from "../../services/events-search.js";
 import { linkPeople } from "../../services/people.js";
+import { BUSY_QUERY_HELP, busyAnswer, busyQuery, workingHoursOf } from "../busy.js";
 import { CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY_HELP, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, peopleAnswer, resolveAnswer, reviewsAnswer, } from "../reads.js";
-import { syncCalendars } from "../sync.js";
+import { REPEAT_HELP } from "../recurrence.js";
+import { calendarStatus, syncCalendars } from "../sync.js";
 import { createEvent, deleteEvent, EVENT_RESPONSES, respondToEvent, updateEvent, } from "../writes.js";
 const LOCAL_READ = { remote: "none", local: "read" };
 const LOCAL_WRITE = { remote: "none", local: "write" };
 const FETCH = { remote: "read", local: "write" };
+const REMOTE_READ = { remote: "read", local: "none" };
 const REMOTE_WRITE = { remote: "write", local: "write" };
 const GROUP = { remote: "none", local: "none" };
 /** How many pieces one `sync --embed` embeds, as drive's. */
@@ -30,6 +35,12 @@ const integer = (text) => {
         throw new InvalidArgumentError("expected a positive integer");
     return Number(text);
 };
+const minutes = (text) => {
+    const value = integer(text);
+    if (value < 5 || value > 1440)
+        throw new InvalidArgumentError("expected 5 to 1440 minutes");
+    return value;
+};
 const addCalendarCommandsDefinition = (program, deps) => {
     const now = () => deps.now?.() ?? Date.now();
     const zone = () => timezoneOf(deps.timezone);
@@ -85,27 +96,90 @@ const addCalendarCommandsDefinition = (program, deps) => {
             await deps.store.setCalendarSynced(calendar.id, synced, now());
             print(calendarItem({ ...calendar, synced }), command);
         });
-    output(example(annotate(program.command("sync"), { effects: FETCH, offline: false }).description("bring the synced calendars up to date: what changed since the last sync, or everything with --full"), "sync", "sync --full --embed"))
-        .option("--full", "list every synced calendar's window again instead of reading changes")
+    if (deps.freeBusy)
+        output(example(annotate(calendars.command("busy"), { effects: REMOTE_READ, offline: false })
+            .description("when calendars and people are taken, asked of the provider and not stored; with --duration-minutes, " +
+            "the free stretches they share")
+            .argument("[words...]", "today, week, from:<date>, to:<date>, calendar:<id>, person:<email>")
+            .addHelpText("after", BUSY_QUERY_HELP), "calendars busy week person:ana@example.com --json", "calendars busy from:2026-11-02 to:2026-11-06 person:ana@example.com --duration-minutes 30 --hours 10:00-16:00"))
+            .option("--duration-minutes <minutes>", "find free stretches at least this long, 5–1440", minutes)
+            .option("--hours <from-to>", "working hours in your time zone, Monday to Friday, with --duration-minutes", "09:00-17:00")
+            .action(async (words, opts, command) => {
+            if (command.optsWithGlobals().offline)
+                throw new CliError("permission_error", "calendars busy asks the provider; leave out --offline", {
+                    reason: "busy.offline",
+                });
+            const hours = workingHoursOf(opts.hours);
+            const query = await busyQuery(words, { store: deps.store, accountId: deps.accountId, zone: zone(), now: now() });
+            print(await busyAnswer(source(), query, {
+                zone: zone(),
+                now: now(),
+                ...(opts.durationMinutes === undefined ? {} : { slot: { minutes: opts.durationMinutes, hours } }),
+            }), command);
+        });
+    output(example(annotate(program.command("sync"), {
+        effects: FETCH,
+        offline: false,
+        cooperative: true,
+        partial: true,
+    }).description("bring the synced calendars up to date: what changed since the last sync, or everything with --rescan; a run " +
+        "stops before its deadline or --max-pages and the next one goes on from there"), "sync", "sync --rescan --embed", "sync --timeout 2m"))
+        .option("--rescan", "list every synced calendar's window again, dropping a round in progress")
+        .option("--max-pages <pages>", "at most this many requests to the provider in this run; as many as fit the deadline if not given", integer)
         .option("--embed", "also index new events for meaning search, with a model already downloaded")
         .action(async (opts, command) => {
-        // The shared program has a global --full of its own, which claims the flag before this command sees it.
-        const full = command.optsWithGlobals().full === true;
+        // --full is the shared program's output flag; it used to start the round over here, and silently would not now.
+        if (command.optsWithGlobals().full)
+            throw new CliError("validation_error", "sync starts over with --rescan; --full only widens output");
+        const { signal } = environmentOf(command);
         const report = await syncCalendars(source(), deps.store, {
             accountId: deps.accountId,
             now: now(),
-            ...(full ? { full: true } : {}),
+            budget: runBudgetOf(command, opts.maxPages),
+            ...(signal ? { signal } : {}),
+            ...(opts.rescan ? { full: true } : {}),
             ...(deps.expand ? { expand: deps.expand } : {}),
         });
         if (opts.embed && !deps.embed)
             throw new CliError("configuration_error", "this tool cannot embed events");
-        const embeddings = opts.embed ? await deps.embed?.(EMBED_MAX) : undefined;
-        print(embeddings === undefined ? report : { ...report, embeddings }, command);
-        if (!report.complete)
+        // A run its budget stopped has no time left for the model; the run that finishes the round embeds.
+        const embeddings = opts.embed && !report.stopped ? await deps.embed?.(EMBED_MAX) : undefined;
+        const timeout = command.optsWithGlobals().timeout;
+        // The same command again, never --rescan: that would drop the round this run leaves in progress. A run that moved
+        // nothing on would only repeat itself, so it gets no step an agent may run unasked.
+        const stuck = report.state === "partial" && report.progress.steps === 0 && !report.synced.some((one) => one.error);
+        const next = report.state === "partial" && !stuck && !report.synced.some((one) => one.error !== undefined)
+            ? [
+                {
+                    kind: "command",
+                    step: "calendar.sync",
+                    command: "sync",
+                    args: Object.fromEntries(Object.entries({ max_pages: opts.maxPages, timeout, embed: opts.embed }).filter(([, value]) => value !== undefined)),
+                    why: "the sync stopped before its end to answer in time; running it again goes on from where it stopped",
+                    safe_to_auto_execute: true,
+                },
+            ]
+            : undefined;
+        const progressAt = lineOf(command, "status");
+        report.hint = stuck
+            ? `this run moved nothing on: raise --timeout or --max-pages, then run sync again; see progress: ${progressAt}`
+            : report.state === "partial"
+                ? `run sync again to continue; see progress: ${progressAt}`
+                : report.hint;
+        if (report.hint === undefined)
+            delete report.hint;
+        print({ ...report, ...(embeddings === undefined ? {} : { embeddings }), ...(next ? { next } : {}) }, command);
+        if (report.synced.some((one) => one.error !== undefined))
             throw new CliError("provider_error", "some calendars did not sync; run sync again to retry them", {
                 reason: "sync.partial",
             });
     });
+    output(example(annotate(program.command("status"), { effects: LOCAL_READ }).description("how far each synced calendar's sync is: entries done, partial or complete, and when it last moved"), "status --json")).action(async (_opts, command) => {
+        print(await calendarStatus(deps.store, deps.accountId, {
+            profile: deps.profile ?? `account ${deps.accountId}`,
+            now: now(),
+        }), command);
+    });
     const events = annotate(program.command("events").description("the account's stored events"), { effects: GROUP });
     output(example(annotate(events.command("list"), { effects: LOCAL_READ, output: { entity: "event" } })
         .description("list stored events, earliest first")
@@ -199,7 +273,13 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
         ask: terminalAsker(command),
         now: now(),
         zone: zone(),
-        names: { notify: "--notify or --no-notify", id: "--id", calendar: "--calendar", series: "--series" },
+        names: {
+            notify: "--notify or --no-notify",
+            id: "--id",
+            calendar: "--calendar",
+            series: "--series",
+            repeat: "--repeat",
+        },
     });
     const printWritten = (value, command) => print({ ...value, untrusted: CALENDAR_UNTRUSTED_FIELDS }, command);
     // Left out on purpose: with other attendees the owner must choose, so neither switch is the default.
@@ -216,7 +296,8 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
         .option("--location <text>", "where; empty clears it")
         .option("--description <text>", "the details; empty clears it")
         // 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("--attendee <email>", `an attendee; repeat for each${replacing ? ", replacing the list" : ""}`, collect, [])
+        .option("--repeat <rule>", `how it repeats${replacing ? ", with --series" : ""}: ${REPEAT_HELP}`);
     const fieldsOf = ({ attendee, ...given }) => ({
         ...Object.fromEntries(Object.entries(given).filter(([, value]) => value !== undefined)),
         ...(attendee === undefined || attendee.length === 0 ? {} : { attendees: attendee }),
@@ -231,9 +312,10 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
         .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");
     output(example(notify(fields(write("create"), false)
-        .description("add an event to a calendar; one that repeats is made in the calendar itself")
+        .description("add an event to a calendar; with --repeat, one that repeats")
         .argument("<calendar>", "the calendar's id, or the provider's id")).option("--id <id>", "the 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 " +
-        "--attendee ana@example.com --no-notify")).action(async (calendar, opts, command) => {
+        "--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, id, ...rest } = opts;
         printWritten(await createEvent(context(command), calendar, fieldsOf(rest), {
             ...(choice === undefined ? {} : { notify: choice }),
@@ -241,8 +323,9 @@ const addEventWrites = (events, writes, { deps, now, zone, output, print, exampl
         }), command);
     });
     output(example(notify(target(fields(write("update"), true))
-        .description("change an event; with --series every occurrence of the repeating event")
-        .option("--series", "change the whole repeating event, not only this occurrence")), "events update event:42 --start-time 2026-11-02T14:00 --end-time 2026-11-02T15:00 --notify")).action(async (reference, opts, command) => {
+        .description("change an event; with --series every occurrence of the repeating event; new times or dates switch it " +
+        "between timed and all-day")
+        .option("--series", "change the whole repeating event, not only this occurrence")), "events update event:42 --start-time 2026-11-02T14:00 --end-time 2026-11-02T15:00 --notify", "events update event:42 --series --repeat 'FREQ=WEEKLY;BYDAY=TU;UNTIL=20261231T230000Z' --no-notify")).action(async (reference, opts, command) => {
         const { calendar: _calendar, series: _series, notify: _notify, ...rest } = opts;
         printWritten(await updateEvent(context(command), reference, fieldsOf(rest), choicesOf(opts)), command);
     });

package/dist/calendar/index.d.ts

@@ -1,5 +1,6 @@
 export type { CalendarAccessRole, CalendarInput, EntryAttachment, EntryAttachmentInput, EntryEventType, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EntryTransparency, EntryVisibility, EventDetails, EventFilter, EventStore, LinkReview, ParticipantResponse, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "../meetings/index.js";
-export type { CalendarExpander, CalendarSource, CalendarSourceTraits, ChangePage, ChangeResult, SyncWindow, } from "./source.js";
-export { type CalendarCursor, type CalendarSyncOptions, type CalendarSyncReport, type CalendarSyncResult, calendarSyncWindow, parseCalendarCursor, syncCalendars, } from "./sync.js";
+export { repeatRule } from "./recurrence.js";
+export type { BusyTimes, CalendarExpander, CalendarSource, CalendarSourceTraits, ChangePage, ChangeResult, FreeBusyRequest, SyncWindow, } from "./source.js";
+export { type CalendarCursor, type CalendarSyncOptions, type CalendarSyncReport, type CalendarSyncResult, calendarStatus, calendarSyncWindow, type PendingRound, parseCalendarCursor, syncCalendars, } from "./sync.js";
 export { CALENDAR_WRITE_DEFAULTS, CALENDAR_WRITE_KEYS, type CalendarWrite, type CalendarWriter, calendarConflict, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, type EventDraft, type EventPatch, type EventResponse, type WriteScope, } from "./writer.js";
 export type { CalendarWrites } from "./writes.js";

package/dist/calendar/index.js

@@ -1,2 +1,3 @@
-export { calendarSyncWindow, parseCalendarCursor, syncCalendars, } from "./sync.js";
+export { repeatRule } from "./recurrence.js";
+export { calendarStatus, calendarSyncWindow, parseCalendarCursor, syncCalendars, } from "./sync.js";
 export { CALENDAR_WRITE_DEFAULTS, CALENDAR_WRITE_KEYS, calendarConflict, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, } from "./writer.js";

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

@@ -10,13 +10,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
         } | {
             account_id: {
@@ -38,9 +38,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event: {
                 type: string;
                 minLength: number;
@@ -50,9 +50,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
             account_id?: undefined;
         };
@@ -71,13 +71,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
         } | {
             account_id: {
@@ -99,9 +99,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event: {
                 type: string;
                 minLength: number;
@@ -111,9 +111,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
             account_id?: undefined;
         };
@@ -132,13 +132,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
         } | {
             account_id: {
@@ -160,9 +160,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event: {
                 type: string;
                 minLength: number;
@@ -172,9 +172,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
             account_id?: undefined;
         };
@@ -193,13 +193,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
         } | {
             account_id: {
@@ -221,9 +221,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event: {
                 type: string;
                 minLength: number;
@@ -233,9 +233,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             words?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             event?: undefined;
             account_id?: undefined;
         };
@@ -303,6 +303,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -365,6 +370,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -488,6 +498,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -550,6 +565,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -673,6 +693,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -735,6 +760,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -858,6 +888,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -920,6 +955,11 @@ export declare const calendarWriteTools: ({
                 };
                 description: string;
             };
+            repeat: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
             account_id: {
                 type: string;
                 minimum: number;
@@ -998,8 +1038,10 @@ export declare const calendarWriteTools: ({
  * Runs one calendar tool over the accounts the host serves. Without `account_id` a tool reads every one of them and
  * names them in `accounts`; with one it must be among them.
  */
-export declare const callCalendarTool: (store: EventStore, name: string, input: unknown, { accountIds, failure, now, writes, }: {
+export declare const callCalendarTool: (store: EventStore, name: string, input: unknown, { accountIds, failure, now, writes, profileOf, }: {
     accountIds: readonly number[];
+    /** What `status` calls each account's sync. */
+    profileOf?: (accountId: number) => string;
     failure?: FailureContext;
     now?: number;
     /** Each account's writer and profile; without it the write tools refuse. */