@wirecat/cli-core 0.501.0 → 0.502.0

package/CHANGELOG.md

@@ -5,7 +5,31 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 0.502.0 — 31.10.2026
+
+### Added
+
+- **The event store finds events by their earliest start: `EventFilter.startsFrom`.** It keeps events that start at
+  or after an instant, and `startsFromDate` keeps all-day events by their local date, as `toDate` does (WC-TIME-5).
+  Both stores (SQLite and `memoryEventStore`) answer it, and the event store contract checks the boundary.
+- **`nativeTermLists`** from `@wirecat/cli-core/cli`: as `nativeTerms`, but named fields may repeat
+  (`person:a person:b`), every term kept.
+
+### Changed — may break callers
+
+- **The shared calendar commands take the standard query and the paths the other tools use.** A CLI that mounts
+  `addCalendarCommands` (gcal) gets:
+  - `store status` in place of `status`, and `search events <query…>` in place of `search <words…>`; the permission
+    keys are `store.status` and `search.events`, and the sync's hint names `store status`.
+  - `events list [query…]` (`EVENTS_QUERY`): `starts_at` either way, now including `starts_at>=…` and
+    `starts_at:[a TO b}`, `ends_at>=…`, `changed_at>=…`, `calendar:` and `person:`. The words `today`, `week`,
+    `from:`, `to:`, `changed:` and `overlapping` are refused as query errors.
+  - `calendars busy [query…]` (`BUSY_QUERY`): the window as `start>=…` and `end<=…`, and `calendar:` and `person:`,
+    each repeatable. `today`, `week`, `from:` and `to:` are refused.
+  - `eventsFilter(query, …)` takes the query text in place of words, and `busyQuery(query, …)` as well;
+    `EVENTS_QUERY_HELP` and `BUSY_QUERY_HELP` are gone (`EVENTS_QUERY_NOTE`, `BUSY_QUERY_NOTE`), and `weekFilter`
+    builds `people list`'s week.
+  - `calendarTools`: `status` is `store_status`, and `events_list` takes `query` in place of `words`.
 
 ## 0.501.0 — 31.10.2026
 

package/dist/calendar/busy.d.ts

@@ -1,12 +1,19 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import { type QueryWords } from "../cli/list-query.js";
 import type { EventStore, StoredCalendar } from "../meetings/index.js";
 import type { CalendarSource, SyncWindow } from "./source.js";
-export declare const BUSY_QUERY_HELP = "\nWords, any order:\n  today | week            today, or today and the next six days, in your time zone\n  from:<date> to:<date>   from the start of one day through the end of another (or a time with a zone)\n  calendar:<id>           one of the account's calendars, by its id or the provider's id; repeat for more\n  person:<email>          someone else, by email address; repeat for more\nWithout a time word: this week. Without calendar:, every calendar that syncs.";
 export interface BusyQuery {
     window: SyncWindow;
     calendars: StoredCalendar[];
     people: string[];
 }
-export declare const busyQuery: (words: readonly string[], context: {
+/**
+ * `calendars busy`'s query: the window by the answer's own `start` and `end`, and whom to ask. `calendar` and
+ * `person` repeat, and every one named is asked: the free stretches are those they all share.
+ */
+export declare const BUSY_QUERY: QueryRegistry;
+export declare const BUSY_QUERY_NOTE: string;
+export declare const busyQuery: (query: QueryWords, context: {
     store: EventStore;
     accountId: number;
     zone: string;

package/dist/calendar/busy.js

@@ -1,13 +1,8 @@
 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.`;
+import { dayBoundary, queryError, queryFieldsOf, zonedMoment, } from "@wirecat/cli-base/query";
+import { LIST_QUERY_GUIDE, listQuery, nativeTermLists, typedQuery } from "../cli/list-query.js";
+import { calendarBusy } from "./cli/answers.js";
+import { calendarIn, plusDays, timeWindow } from "./reads.js";
 /** Google answers for 50 calendars at most (`calendarExpansionMax`, reference/freebusy/query). */
 const MOST = 50;
 const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
@@ -15,41 +10,68 @@ 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));
+const BUSY = "calendars busy";
+const bound = (field, side, example) => (node) => {
+    const open = node.operator === "range" && (side === "lower" ? node.upper === "*" : node.value === "*");
+    if (!open)
+        queryError("query.unsupported-operator", node.span, `${field} takes only ${side === "lower" ? "the window's start" : "the window's end"}, such as ${example}`, { command: BUSY, guide: LIST_QUERY_GUIDE });
+};
+/**
+ * `calendars busy`'s query: the window by the answer's own `start` and `end`, and whom to ask. `calendar` and
+ * `person` repeat, and every one named is asked: the free stretches are those they all share.
+ */
+export const BUSY_QUERY = {
+    entity: "calendar_busy",
+    backend: "native",
+    fields: queryFieldsOf(calendarBusy, {
+        native: ["start", "end", "calendar", "person"],
+        relations: {
+            calendar: {
+                type: "kw",
+                example: "calendar:3",
+                relation: "one of the account's calendars, by its id or the provider's id; repeat for more",
+            },
+            person: { type: "kw", example: "person:ana@example.com", relation: "someone else, by address; repeat for more" },
+        },
+        examples: { start: "start>=2026-11-02", end: "end<=2026-11-06" },
+        validate: {
+            start: bound("start", "lower", "start>=2026-11-02"),
+            end: bound("end", "upper", "end<=2026-11-06"),
+        },
+    }).map((field) => field.native
+        ? { ...field, operators: field.type === "time" ? ["range"] : ["term", "phrase"] }
+        : field),
+};
+export const BUSY_QUERY_NOTE = "\nWithout start: from the start of today, in your time zone. Without end: seven days after the start. " +
+    "Without calendar: every calendar that syncs.";
+export const busyQuery = async (query, context) => {
+    const { zone, now } = context;
+    const today = localDate(now, zone);
     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);
+    const terms = nativeTermLists(listQuery(typedQuery(query), BUSY_QUERY, BUSY), BUSY, ["calendar", "person"]);
+    for (const [field, nodes] of terms)
+        for (const node of nodes) {
+            if (field === "start")
+                from = timeWindow(node, zone, now).lower;
+            else if (field === "end")
+                to = timeWindow(node, zone, now).upper;
+            else if (field === "calendar") {
+                const calendar = await calendarIn(context.store, context.accountId, node.value);
+                if (!calendars.some(({ id }) => id === calendar.id))
+                    calendars.push(calendar);
+            }
+            else if (field === "person") {
+                const email = node.value.trim().toLowerCase();
+                if (!EMAIL.test(email))
+                    throw new CliError("validation_error", `${node.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;
+    from ??= dayBoundary(today, zone, false, span(today));
+    to ??= from + 7 * 86_400_000;
     if (to <= from)
         throw new CliError("validation_error", "the window ends before it starts");
     const asked = calendars.length

package/dist/calendar/cli/answers.js

@@ -192,7 +192,7 @@ const ANSWERS = {
     "calendars unsync": { name: "calendar", schema: calendar },
     "calendars busy": { name: "calendar_busy", schema: calendarBusy },
     sync: { name: "calendar_sync", schema: calendarSync },
-    status: { name: "calendar_sync_progress", schema: calendarSyncProgress },
+    "store status": { name: "calendar_sync_progress", schema: calendarSyncProgress },
     "events list": { name: "event" },
     "events show": { name: "calendar_event", schema: calendarEvent },
     "events create": { name: "calendar_event_write", schema: calendarEventWrite },
@@ -200,7 +200,7 @@ const ANSWERS = {
     "events delete": { name: "calendar_event_write", schema: calendarEventWrite },
     "events move": { name: "calendar_event_write", schema: calendarEventWrite },
     "events respond": { name: "calendar_event_write", schema: calendarEventWrite },
-    search: { name: "calendar_search_hit", schema: calendarSearchHit },
+    "search events": { name: "calendar_search_hit", schema: calendarSearchHit },
     "people list": { name: "calendar_attendee", schema: calendarAttendee },
     "people link": { name: "calendar_linked_person", schema: calendarLinkedPerson },
     "links review": { name: "calendar_link_review", schema: calendarLinkReview },

package/dist/calendar/cli/index.js

@@ -9,8 +9,8 @@ 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 { BUSY_QUERY, BUSY_QUERY_NOTE, busyAnswer, busyQuery, workingHoursOf } from "../busy.js";
+import { CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY, EVENTS_QUERY_NOTE, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, peopleAnswer, resolveAnswer, reviewsAnswer, weekFilter, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
 import { serverSearchAnswer } from "../server-search.js";
 import { calendarStatus, syncCalendars } from "../sync.js";
@@ -99,11 +99,9 @@ const addCalendarCommandsDefinition = (program, deps) => {
             print(calendarItem({ ...calendar, synced }), command);
         });
     if (deps.freeBusy)
-        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")
+        example(withQuery(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"), BUSY_QUERY).addHelpText("after", BUSY_QUERY_NOTE), "calendars busy person:ana@example.com --json", "calendars busy start>=2026-11-02 end<=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) => {
@@ -162,7 +160,7 @@ const addCalendarCommandsDefinition = (program, deps) => {
                 },
             ]
             : undefined;
-        const progressAt = lineOf(command, "status");
+        const progressAt = lineOf(command, "store status");
         report.hint = stuck
             ? `this run moved nothing on: raise --timeout or --max-pages, then run sync again; see progress: ${progressAt}`
             : report.state === "partial"
@@ -193,17 +191,17 @@ const addCalendarCommandsDefinition = (program, deps) => {
             });
         print({ ...report, ...(embeddings === undefined ? {} : { embeddings }), ...(next ? { next } : {}) }, command);
     });
-    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) => {
+    const store = annotate(program.command("store").description("the local store of calendar events"), {
+        effects: GROUP,
+    });
+    example(annotate(store.command("status"), { effects: LOCAL_READ }).description("how far each synced calendar's sync is: entries done, partial or complete, and when it last moved"), "store 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 });
-    example(annotate(events.command("list"), { effects: LOCAL_READ })
-        .description("list stored events, earliest first")
-        .argument("[words...]", "today, week, from:<date>, to:<date>, person:<who>, calendar:<id>")
-        .addHelpText("after", EVENTS_QUERY_HELP), "events list week --json", "events list from:2026-11-02 to:2026-11-06 person:ana@example.com")
+    example(withQuery(annotate(events.command("list"), { effects: LOCAL_READ }).description("list stored events, earliest first"), EVENTS_QUERY).addHelpText("after", EVENTS_QUERY_NOTE), "events list starts_at>=2026-11-02 starts_at<2026-11-07 --json", "events list ends_at>=today person:ana@example.com")
         .option("--limit <n>", "events at most, 1–1000", integer, 100)
         .action(async (words, opts, command) => {
         const filter = await eventsFilter(words, {
@@ -221,12 +219,15 @@ const addCalendarCommandsDefinition = (program, deps) => {
         const shown = await eventAnswer(await eventOf(deps.store, deps.accountId, eventIdOf(reference)), personOfEmail);
         print({ ...shown, untrusted: CALENDAR_UNTRUSTED_FIELDS }, command);
     });
-    const search = example(annotate(program.command("search"), { effects: deps.serverSearch ? LOCAL_OR_REMOTE_READ : LOCAL_READ })
+    const searches = annotate(program.command("search").description("find stored things by text: events"), {
+        effects: GROUP,
+    });
+    const search = example(annotate(searches.command("events"), { effects: deps.serverSearch ? LOCAL_OR_REMOTE_READ : LOCAL_READ })
         .description(deps.serverSearch
         ? "find stored events by words, and by meaning when its model is downloaded; with --backend server, ask " +
             "the provider instead"
         : "find stored events by words, and by meaning when its model is downloaded")
-        .argument("<words...>", "what to find in titles, descriptions, places and attendees"), "search roadmap planning --json", ...(deps.serverSearch ? ["search --backend server quarterly review"] : []))
+        .argument("<query...>", "what to find in titles, descriptions, places and attendees"), "search events roadmap planning --json", ...(deps.serverSearch ? ["search events --backend server quarterly review"] : []))
         .option("--limit <n>", "events per page", integer, 20)
         .option("--cursor <cursor>", "continue from a page's next_offset", (text) => (text === "0" ? 0 : integer(text)), 0)
         .option("--exact", "every word as written, no word stems")
@@ -238,16 +239,16 @@ const addCalendarCommandsDefinition = (program, deps) => {
             .default("archive"));
     search.action(async (words, opts, command) => {
         if (opts.backend === "both")
-            throw new CliError("validation_error", "search --backend both is not offered: the store's search and the provider's rank and page events " +
+            throw new CliError("validation_error", "search events --backend both is not offered: the store's search and the provider's rank and page events " +
                 "differently, so one merged list would have no single order or next page; run --backend archive and " +
                 "--backend server", { reason: "search.one-backend" });
         if (opts.backend === "server") {
             if (command.optsWithGlobals().offline)
-                throw new CliError("permission_error", "search --backend server asks the provider; leave out --offline", {
+                throw new CliError("permission_error", "search events --backend server asks the provider; leave out --offline", {
                     reason: "search.offline",
                 });
             if (opts.exact || opts.cursor || opts.newest)
-                throw new CliError("validation_error", "search --backend server takes neither --exact, --cursor nor --newest: the provider ranks and pages it", { reason: "search.server-options" });
+                throw new CliError("validation_error", "search events --backend server takes neither --exact, --cursor nor --newest: the provider ranks and pages it", { reason: "search.server-options" });
             const found = await serverSearchAnswer(source(), deps.store, {
                 accountId: deps.accountId,
                 account: deps.account,
@@ -276,9 +277,7 @@ const addCalendarCommandsDefinition = (program, deps) => {
     withQuery(example(annotate(people.command("list"), { effects: LOCAL_READ }).description("one event's attendees, or everyone attending this week's events"), "people list --json", "people list event:42"), PEOPLE_QUERY).action(async (words, _opts, command) => {
         const reference = queryTerms(words, PEOPLE_QUERY, "people list").get("event");
         const event = reference === undefined ? undefined : eventIdOf(reference);
-        const filter = event === undefined
-            ? await eventsFilter(["week"], { store: deps.store, accountId: deps.accountId, zone: zone(), now: now() })
-            : undefined;
+        const filter = event === undefined ? weekFilter(deps.accountId, zone(), now()) : undefined;
         const people = await peopleAnswer(deps.store, deps.accountId, {
             ...(event === undefined ? {} : { event }),
             ...(filter ? { filter } : {}),

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

@@ -14,7 +14,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -23,7 +23,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words: {
+            query: {
                 type: string;
                 minLength: number;
             };
@@ -38,7 +38,7 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event: {
@@ -50,7 +50,7 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -75,7 +75,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -84,7 +84,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words: {
+            query: {
                 type: string;
                 minLength: number;
             };
@@ -99,7 +99,7 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event: {
@@ -111,7 +111,7 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -136,7 +136,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -145,7 +145,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words: {
+            query: {
                 type: string;
                 minLength: number;
             };
@@ -160,7 +160,7 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event: {
@@ -172,7 +172,7 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -197,7 +197,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;
@@ -206,7 +206,7 @@ export declare const calendarTools: ({
                 type: string;
                 minimum: number;
             };
-            words: {
+            query: {
                 type: string;
                 minLength: number;
             };
@@ -221,7 +221,7 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event: {
@@ -233,7 +233,7 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
-            words?: undefined;
+            query?: undefined;
             timezone?: undefined;
             limit?: undefined;
             event?: undefined;

package/dist/calendar/mcp/index.js

@@ -19,7 +19,7 @@ export const calendarTools = [
         required: [],
     },
     {
-        name: "status",
+        name: "store_status",
         description: "how far each synced calendar's sync is: done, state partial or complete, and cursor_age_ms, which grows while " +
             "nothing moves it",
         properties: { account_id: integer },
@@ -27,10 +27,10 @@ export const calendarTools = [
     },
     {
         name: "events_list",
-        description: "stored events, earliest first; `words` takes today, week, from:<date>, to:<date>, calendar:<id>, " +
-            "changed:<date> (events new, moved or cancelled since, each with change and was) and overlapping (events " +
-            "that clash, each with overlaps); a date in the zone given, UTC when absent",
-        properties: { account_id: integer, words: text, timezone: text, limit: { ...integer, maximum: 1000 } },
+        description: "stored events, earliest first; `query` takes field terms joined by AND: starts_at (>=, <, or " +
+            "[a TO b}), ends_at>=, changed_at>= (events new, moved or cancelled since, each with change and was), " +
+            "calendar:<id>; a date in the zone given, UTC when absent; without starts_at or ends_at, from today on",
+        properties: { account_id: integer, query: text, timezone: text, limit: { ...integer, maximum: 1000 } },
         required: [],
     },
     {
@@ -163,7 +163,7 @@ const argumentsOf = (name, input) => {
             (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1))
             throw new CliError("validation_error", `${key} must be a positive integer`);
         else if ([
-            "words",
+            "query",
             "timezone",
             "event",
             "calendar",
@@ -225,13 +225,12 @@ export const callCalendarTool = async (store, name, input, { accountIds, failure
             case "calendars_list":
                 answer = listed((await Promise.all(accounts.map((id) => store.calendars(id)))).flat().map(calendarItem));
                 break;
-            case "status":
+            case "store_status":
                 answer = listed((await Promise.all(accounts.map((id) => calendarStatus(store, id, { profile: profileOf(id), now }).then(({ items }) => items)))).flat());
                 break;
             case "events_list": {
-                const words = typeof args.words === "string" ? args.words.trim().split(/\s+/u) : [];
                 const limit = args.limit ?? 100;
-                const lists = await Promise.all(accounts.map(async (accountId) => eventsAnswer(store, await eventsFilter(words, {
+                const lists = await Promise.all(accounts.map(async (accountId) => eventsAnswer(store, await eventsFilter(args.query, {
                     store,
                     accountId,
                     zone: args.timezone ?? "UTC",

package/dist/calendar/reads.d.ts

@@ -1,3 +1,5 @@
+import { type Predicate, type QueryRegistry } from "@wirecat/cli-base/query";
+import { type QueryWords } from "../cli/list-query.js";
 import { type EventDetails, type EventFilter, type EventStore, type StoredCalendar, type StoredEntry } from "../meetings/index.js";
 /** Who looks a person up: the shared store's `people.personOf`, for an attendee's `email` contact. */
 export type PersonOfEmail = (email: string) => Promise<string | null>;
@@ -17,18 +19,27 @@ export declare const calendarItem: (one: StoredCalendar) => {
 export declare const calendarIn: (store: EventStore, accountId: number, reference: string) => Promise<StoredCalendar>;
 export declare const eventIdOf: (reference: string | number) => number;
 export declare const plusDays: (date: string, days: number) => string;
-export declare const EVENTS_QUERY_HELP = "\nWords, any order:\n  today | week            today, or today and the next six days, in your time zone\n  from:<date> to:<date>   from the start of one day through the end of another (or a time with a zone)\n  person:<email|id>       events one person attends: an address, or a person id from search\n  calendar:<id>           one calendar, by its id or the provider's id\n  changed:<date>          events new, moved or cancelled since then, each with what changed (from the local copy)\n  overlapping             events that clash with another: timed, not cancelled, not declined, not marked free\nWithout a time word: events from the start of today on.";
+/** `events list`'s query. The store answers `ends_at` and `changed_at` from below only; `starts_at` either way. */
+export declare const EVENTS_QUERY: QueryRegistry;
+export declare const EVENTS_QUERY_NOTE: string;
+/** A time term as epoch ms: from `lower` on, and before `upper`. */
+export declare const timeWindow: (node: Predicate, zone: string, now: number) => {
+    lower?: number;
+    upper?: number;
+};
 /**
- * `events list` words into a store filter, for one account. A person named by address is found through the shared
- * store; one nobody knows matches no event.
+ * `events list`'s query into a store filter, for one account. A person named by address is found through the
+ * shared store; one nobody knows matches no event.
  */
-export declare const eventsFilter: (words: readonly string[], context: {
+export declare const eventsFilter: (query: QueryWords, context: {
     store: EventStore;
     accountId: number;
     zone: string;
     now: number;
     personOf?: (reference: string) => Promise<number | null>;
 }) => Promise<EventFilter | null>;
+/** Events that end after the start of today and start within seven days, in `zone`. */
+export declare const weekFilter: (accountId: number, zone: string, now: number) => EventFilter;
 /** An event the account holds, with only its copies, or `not_found`: another account's event is not shown. */
 export declare const eventOf: (store: EventStore, accountId: number, id: number) => Promise<EventDetails>;
 export declare const entryItem: (entry: StoredEntry) => {

package/dist/calendar/reads.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
-import { dayBoundary, zonedMoment } from "@wirecat/cli-base/query";
-import { eventChange, eventItem, listed, } from "../meetings/index.js";
+import { dateRange, dayBoundary, queryError, queryFieldsOf, } from "@wirecat/cli-base/query";
+import { LIST_QUERY_GUIDE, listQuery, nativeTerms, typedQuery } from "../cli/list-query.js";
+import { event, eventChange, eventItem, listed, } from "../meetings/index.js";
 const iso = (at) => (at === null ? null : new Date(at).toISOString());
 /** Fields whose text whoever sent the invitation wrote: an agent reads them as data. */
 export const CALENDAR_UNTRUSTED_FIELDS = [
@@ -45,65 +46,114 @@ export const plusDays = (date, days) => {
     const [year, month, day] = date.split("-").map(Number);
     return new Date(Date.UTC(year, month - 1, day + days)).toISOString().slice(0, 10);
 };
-export const EVENTS_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)
-  person:<email|id>       events one person attends: an address, or a person id from search
-  calendar:<id>           one calendar, by its id or the provider's id
-  changed:<date>          events new, moved or cancelled since then, each with what changed (from the local copy)
-  overlapping             events that clash with another: timed, not cancelled, not declined, not marked free
-Without a time word: events from the start of today on.`;
+const LIST = "events list";
+const oneSided = (field, example) => (node) => {
+    if (node.operator !== "range" || node.upper !== "*")
+        queryError("query.unsupported-operator", node.span, `${field} takes only an earliest moment, such as ${example}`, {
+            command: LIST,
+            guide: LIST_QUERY_GUIDE,
+        });
+};
+/** `events list`'s query. The store answers `ends_at` and `changed_at` from below only; `starts_at` either way. */
+export const EVENTS_QUERY = {
+    entity: "event",
+    backend: "native",
+    fields: queryFieldsOf(event, {
+        native: ["starts_at", "ends_at", "changed_at", "calendar", "person"],
+        relations: {
+            calendar: { type: "kw", example: "calendar:3", relation: "one calendar, by its id or the provider's id" },
+            person: {
+                type: "kw",
+                example: "person:ana@example.com",
+                relation: "events one person attends: an address, or a person id from search",
+            },
+        },
+        examples: {
+            starts_at: "starts_at:[2026-11-02 TO 2026-11-07}",
+            ends_at: "ends_at>=2026-11-02",
+            changed_at: "changed_at>=2026-10-01",
+        },
+        validate: {
+            ends_at: oneSided("ends_at", "ends_at>=2026-11-02; for the latest, write starts_at<2026-11-07"),
+            changed_at: oneSided("changed_at", "changed_at>=2026-10-01"),
+        },
+    }).map((field) => field.native
+        ? { ...field, operators: field.type === "time" ? ["term", "range"] : ["term", "phrase"] }
+        : field),
+};
+export const EVENTS_QUERY_NOTE = "\nends_at keeps events that end after its moment, so one that ends exactly then is left out. Without starts_at " +
+    "or ends_at: events that end after the start of today, in your time zone.";
+/** A time term as epoch ms: from `lower` on, and before `upper`. */
+export const timeWindow = (node, zone, now) => {
+    const range = node.operator === "range"
+        ? dateRange(node.value, node.upper ?? "*", node.lower_inclusive !== false, node.upper_inclusive !== false, zone, node.span, now)
+        : dateRange(node.value, node.value, true, true, zone, node.span, now);
+    return {
+        ...(range.lower === undefined ? {} : { lower: range.lower_inclusive ? range.lower : range.lower + 1 }),
+        ...(range.upper === undefined ? {} : { upper: range.upper_inclusive ? range.upper + 1 : range.upper }),
+    };
+};
 /**
- * `events list` words into a store filter, for one account. A person named by address is found through the shared
- * store; one nobody knows matches no event.
+ * `events list`'s query into a store filter, for one account. A person named by address is found through the
+ * shared store; one nobody knows matches no event.
  */
-export const eventsFilter = async (words, context) => {
+export const eventsFilter = async (query, context) => {
     const filter = { accountId: context.accountId };
-    const today = localDate(context.now, context.zone);
+    const { zone, now } = context;
     const span = (text) => ({ start: 0, end: text.length });
-    const day = (date) => dayBoundary(date, context.zone, false, span(date));
-    let timed = false;
-    for (const word of words) {
-        const [, field, value = ""] = /^([a-z]+):(.+)$/u.exec(word) ?? [];
-        if (word === "today" || word === "week") {
-            filter.from = day(today);
-            filter.to = day(plusDays(today, word === "today" ? 1 : 7));
-            timed = true;
+    const day = (date) => dayBoundary(date, zone, false, span(date));
+    for (const [field, node] of nativeTerms(listQuery(typedQuery(query), EVENTS_QUERY, LIST), LIST)) {
+        if (field === "starts_at") {
+            const { lower, upper } = timeWindow(node, zone, now);
+            if (lower !== undefined)
+                filter.startsFrom = lower;
+            if (upper !== undefined)
+                filter.to = upper;
         }
-        else if (field === "from") {
-            filter.from = zonedMoment(value, context.zone, span(value));
-            timed = true;
+        else if (field === "ends_at") {
+            // Strictly after, as the default window: `ends_at>=today` leaves out yesterday's all-day event, which ends at
+            // today's midnight.
+            const { lower } = timeWindow(node, zone, now);
+            if (lower !== undefined)
+                filter.from = lower;
         }
-        else if (field === "to") {
-            filter.to = zonedMoment(value, context.zone, span(value), { end: true }) + 1;
-            timed = true;
+        else if (field === "changed_at") {
+            const { lower } = timeWindow(node, zone, now);
+            if (lower !== undefined)
+                filter.changedSince = lower;
         }
-        else if (field === "changed")
-            filter.changedSince = zonedMoment(value, context.zone, span(value));
-        else if (word === "overlapping")
-            filter.overlapping = true;
         else if (field === "calendar")
-            filter.calendarId = (await calendarIn(context.store, context.accountId, value)).id;
+            filter.calendarId = (await calendarIn(context.store, context.accountId, node.value)).id;
         else if (field === "person") {
             if (!context.personOf)
                 throw new CliError("configuration_error", "this tool cannot look people up");
-            const person = await context.personOf(value);
+            const person = await context.personOf(node.value);
             if (person === null)
                 return null;
             filter.personId = person;
         }
-        else
-            throw new CliError("validation_error", `${word} is not an events list word${EVENTS_QUERY_HELP}`, {
-                reason: "query.unknown_word",
-            });
     }
-    if (!timed)
-        filter.from = day(today);
+    if (filter.from === undefined && filter.startsFrom === undefined && filter.to === undefined)
+        filter.from = day(localDate(now, zone));
+    return datedFilter(filter, zone);
+};
+/** Events that end after the start of today and start within seven days, in `zone`. */
+export const weekFilter = (accountId, zone, now) => {
+    const today = localDate(now, zone);
+    const day = (date) => dayBoundary(date, zone, false, { start: 0, end: date.length });
+    return datedFilter({ accountId, from: day(today), to: day(plusDays(today, 7)) }, zone);
+};
+/** The local days an all-day event is compared by, from the filter's instants. */
+const datedFilter = (filter, zone) => {
     if (filter.from !== undefined)
-        filter.fromDate = localDate(filter.from, context.zone);
+        filter.fromDate = localDate(filter.from, zone);
     if (filter.to !== undefined)
-        filter.toDate = plusDays(localDate(filter.to - 1, context.zone), 1);
+        filter.toDate = plusDays(localDate(filter.to - 1, zone), 1);
+    if (filter.startsFrom !== undefined) {
+        const date = localDate(filter.startsFrom, zone);
+        const midnight = dayBoundary(date, zone, false, { start: 0, end: date.length });
+        filter.startsFromDate = midnight < filter.startsFrom ? plusDays(date, 1) : date;
+    }
     return filter;
 };
 /**

package/dist/calendar/testing/memory.js

@@ -474,6 +474,10 @@ export const memoryEventStore = () => {
                     (event.allDay && filter.toDate !== undefined
                         ? has(event, (one) => one.startDate !== null && one.startDate < (filter.toDate ?? ""))
                         : event.startsAt !== null && event.startsAt < filter.to)) &&
+                (filter.startsFrom === undefined ||
+                    (event.allDay && filter.startsFromDate !== undefined
+                        ? has(event, (one) => one.startDate !== null && one.startDate >= (filter.startsFromDate ?? ""))
+                        : event.startsAt !== null && event.startsAt >= filter.startsFrom)) &&
                 (filter.calendarId === undefined || has(event, (one) => one.calendarId === filter.calendarId)) &&
                 (filter.accountId === undefined ||
                     has(event, (one) => calendarOf(one.calendarId).accountId === filter.accountId)) &&

package/dist/cli/index.d.ts

@@ -77,7 +77,7 @@ export { type FirstScreen, type FirstScreenLine, firstScreen, installHelp, WIREC
 export { type HelpSection, inSection, SECTIONS } from "./help/sections.js";
 export { bufferedInput, type InputPolicy, inputPolicy, MAX_BUFFERED_INPUT, MAX_SECRET_INPUT, provideInputPolicy, } from "./input-policy.js";
 export { answerFields, checkJson, type EntityFields, entityFields, type JsonFieldsResolver, type JsonRequest, liftJson, } from "./json-fields.js";
-export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTerms, pagedList, pageOf, type QueryWords, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
+export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTermLists, nativeTerms, pagedList, pageOf, type QueryWords, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
 export { MCP_HTTP_DEFAULT_PORT, type McpServerOptions, type McpServerTarget, mcpServerCommand, } from "./mcp-server-command.js";
 export { formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
 export { meetingEvidenceItem, meetingPersonContextItem } from "./meeting-evidence-answer.js";

package/dist/cli/index.js

@@ -69,7 +69,7 @@ export { firstScreen, installHelp, WIRECAT_TOOLS } from "./help/first-screen.js"
 export { inSection, SECTIONS } from "./help/sections.js";
 export { bufferedInput, inputPolicy, MAX_BUFFERED_INPUT, MAX_SECRET_INPUT, provideInputPolicy, } from "./input-policy.js";
 export { answerFields, checkJson, entityFields, liftJson, } from "./json-fields.js";
-export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTerms, pagedList, pageOf, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
+export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTermLists, nativeTerms, pagedList, pageOf, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
 export { MCP_HTTP_DEFAULT_PORT, mcpServerCommand, } from "./mcp-server-command.js";
 export { formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
 export { meetingEvidenceItem, meetingPersonContextItem } from "./meeting-evidence-answer.js";

package/dist/cli/list-query.d.ts

@@ -39,6 +39,11 @@ export declare const queryArgument: (registry: QueryRegistry) => v.OptionalSchem
  * question the source cannot ask, so it is refused rather than answered from a part of the list.
  */
 export declare const nativeTerms: (ast: QueryAst | undefined, command: string) => Map<string, Predicate>;
+/**
+ * As `nativeTerms`, but each `repeatable` field may be named again, every term kept in order: `person:a person:b`
+ * asks for both, as AND reads.
+ */
+export declare const nativeTermLists: (ast: QueryAst | undefined, command: string, repeatable?: readonly string[]) => Map<string, Predicate[]>;
 /**
  * A store that compares whole values: each field's `field:value` or `field:"two words"`, enum values lowercased
  * as validation already accepts them. A range or wildcard is refused rather than read as a value.

package/dist/cli/list-query.js

@@ -91,7 +91,12 @@ export const queryArgument = (registry) => {
  * The terms of a query a provider answers: field:value joined by AND, each field once. Anything else is a
  * question the source cannot ask, so it is refused rather than answered from a part of the list.
  */
-export const nativeTerms = (ast, command) => {
+export const nativeTerms = (ast, command) => new Map([...nativeTermLists(ast, command)].map(([field, [node]]) => [field, node]));
+/**
+ * As `nativeTerms`, but each `repeatable` field may be named again, every term kept in order: `person:a person:b`
+ * asks for both, as AND reads.
+ */
+export const nativeTermLists = (ast, command, repeatable = []) => {
     const terms = new Map();
     if (!ast)
         return terms;
@@ -106,9 +111,10 @@ export const nativeTerms = (ast, command) => {
             }
             return;
         }
-        if (terms.has(node.field))
+        const held = terms.get(node.field);
+        if (held && !repeatable.includes(node.field))
             queryError("query.unsupported-placement", node.span, `${node.field} only once here`, context);
-        terms.set(node.field, node);
+        terms.set(node.field, [...(held ?? []), node]);
     };
     add(ast.root);
     return terms;

package/dist/meetings/event-store.d.ts

@@ -185,6 +185,10 @@ export interface EventFilter {
     from?: number;
     /** Events that start before this instant. */
     to?: number;
+    /** Events that start at or after this instant. */
+    startsFrom?: number;
+    /** All-day events starting on or after this local day (`YYYY-MM-DD`); `startsFrom` without it. */
+    startsFromDate?: string;
     /** All-day events, which have dates and no instant, ending after this local day (`YYYY-MM-DD`); `from` without it. */
     fromDate?: string;
     /** Events `eventChange` finds new, moved or cancelled at or after this instant. */

package/dist/meetings/testing/event-store-contract.js

@@ -281,6 +281,29 @@ export const eventStoreContract = (make) => {
             ])
                 assert.deepEqual((await store.events(filter)).map(({ title }) => title).length, 3, JSON.stringify(filter));
         }),
+        test("a list from a start keeps the event that starts exactly then, and an all-day event by its local date", async ({ store, calendar, }) => {
+            const day = 24 * HOUR;
+            const day1 = new Date(later + day).toISOString().slice(0, 10);
+            const day0 = new Date(later).toISOString().slice(0, 10);
+            // Midnight of day1 an hour east of UTC; the all-day events are stored at a midnight three hours east.
+            const startsFrom = Date.parse(day1) - HOUR;
+            const allDay = (id, date, next) => single(id, Date.parse(date) - 3 * HOUR, {
+                title: id,
+                allDay: true,
+                startDate: date,
+                endDate: next,
+                endsAt: Date.parse(next) - 3 * HOUR,
+            });
+            await store.saveEntries(calendar, [
+                single("at", startsFrom, { title: "at" }),
+                single("before", startsFrom - 1, { title: "before" }),
+                allDay("on", day1, new Date(later + 2 * day).toISOString().slice(0, 10)),
+                allDay("day before", day0, day1),
+            ], 2);
+            const titles = async (filter) => (await store.events(filter)).map(({ title }) => title).sort();
+            assert.deepEqual(await titles({ startsFrom, startsFromDate: day1 }), ["at", "on"]);
+            assert.deepEqual(await titles({ startsFrom }), ["at"]);
+        }),
         test("a list of changes since an instant finds events new, moved or cancelled since, and says which", async ({ store, calendar, }) => {
             await store.saveEntries(calendar, ["same", "moved", "back", "cancelled"].map((id) => single(id, later)), 2);
             await store.saveEntries(calendar, [

package/dist/store/sqlite/calendar-events.js

@@ -19,6 +19,7 @@ export const listEvents = (database, filter) => {
     };
     dated("end_date > ?", filter.fromDate, "coalesce(e.ends_at, e.starts_at + 1) > ?", filter.from);
     dated("start_date < ?", filter.toDate, "e.starts_at < ?", filter.to);
+    dated("start_date >= ?", filter.startsFromDate, "e.starts_at >= ?", filter.startsFrom);
     // Bounds on starts_at alone let SQLite seek its index; the CASE above cannot. They are wider than the CASE: by the
     // longest stored event back, and by a day each way for an all-day event's zone.
     const longest = () => Number(database.prepare("SELECT coalesce(max(ends_at - starts_at), 0) AS ms FROM events WHERE deleted_at IS NULL").get()
@@ -31,6 +32,10 @@ export const listEvents = (database, filter) => {
         clauses.push("e.starts_at < ?");
         params.push(filter.to + DAY);
     }
+    if (filter.startsFrom !== undefined && filter.startsFromDate !== undefined) {
+        clauses.push("e.starts_at >= ?");
+        params.push(filter.startsFrom - DAY);
+    }
     if (filter.calendarId !== undefined) {
         clauses.push(entries("ce.calendar_id = ?"));
         params.push(filter.calendarId);

package/package.json

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