@wirecat/cli-core 0.525.0 → 0.527.0

package/CHANGELOG.md

@@ -7,6 +7,48 @@ shape of this file.
 
 ## Unreleased
 
+## 0.527.0 — 01.11.2026
+
+### Added
+
+- **`events list --source <accounts>`: events of several calendar accounts as one list.** The shared calendar
+  `events list` takes `--source` as `search messages` does (`all`, a provider or its alias, `provider:account`,
+  `group:<name>`; WC-ACCT-8) and reads the accounts in one store query (`EventFilter.accountIds`), so a meeting two
+  accounts hold is one item and pages stay exact. Every answer names the accounts it read in `meta.accounts`
+  (WC-ACCT-9); `meta.complete` is false, with an issue per account, when one has no synced calendar
+  (`calendar.unsynced`) or a sync that never finished or is mid-round (`calendar.sync-incomplete`); the command
+  declares `partial`, so such an answer exits 0. `CalendarCommandDeps.locked` keeps a process under a profile lock to
+  its own account (`profile.locked`).
+- **`overlapping:true` in `events list`: meetings that overlap.** A field of the event entity (`overlapping`, with
+  `overlaps` listing the others), filtered in the store with a self-join. Timed events only, not cancelled, not
+  declined, not free and not a working-location block; back-to-back events do not overlap. `overlapping:false` keeps
+  the rest. Across `--source` it finds a work meeting that clashes with a personal one.
+
+### Changed — may break callers
+
+- `EventStoreFixture` (the event store contract) takes `otherAccountId`, a second calendar account.
+- `EventFilter.overlapping: false` now keeps the events that do not overlap; before, it filtered nothing.
+- `EventFilter.overlapping` also leaves out working-location blocks.
+
+## 0.526.0 — 01.11.2026
+
+### Added
+
+- **`mailIds` from `@wirecat/cli-core/mail`: one email id for mail and memo.** On every server but Gmail the id is
+  the hash of the Message-ID (the UID with its folder and UIDVALIDITY when there is none) and the thread is the first
+  id of References, else In-Reply-To. OBJECTID's EMAILID is not used, so a server that turns OBJECTID on keeps its
+  ids. Gmail keeps X-GM-MSGID and X-GM-THRID.
+- **`decodedLabelName` for a Gmail label already decoded.** imapflow decodes X-GM-LABELS; `labelName` decodes the
+  modified UTF-7 again and turned `R&D-team` into `Rteam`. `labelName` stays for the wire form.
+- **`storedMailRuleSet`: the stored rules this build cannot read, with why.** A sync reports them instead of dropping
+  them silently; `storedMailRules` still returns only the rules.
+
+### Fixed
+
+- **`conversations list` and `conversations show` no longer read a failing store as "nothing stored".** Only a
+  missing account answers empty or not found; a locked or broken store fails the command.
+- **The messenger `search messages` help sends mail searches to `mail <profile> search messages`**, not to memo.
+
 ## 0.525.0 — 01.11.2026
 
 ### Added

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

@@ -113,6 +113,7 @@ export declare const calendarEvent: 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<{

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

@@ -39,5 +39,7 @@ 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;
+    /** A profile lock pins the process (WC-ACCT-5): `events list --source` may then read only the profile's account. */
+    locked?: boolean;
 }
 export declare const addCalendarCommands: (program: Command, deps: CalendarCommandDeps) => void;

package/dist/calendar/cli/index.js

@@ -10,7 +10,7 @@ import { lineOf } from "../../cli/steps.js";
 import { searchEvents } from "../../services/events-search.js";
 import { linkPeople } from "../../services/people.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 { accountsMeta, CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY, EVENTS_QUERY_NOTE, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, peopleAnswer, resolveAnswer, reviewsAnswer, sourceAccounts, weekFilter, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
 import { bothSearchAnswer, serverSearchAnswer } from "../server-search.js";
 import { calendarStatus, syncCalendars } from "../sync.js";
@@ -201,18 +201,30 @@ const addCalendarCommandsDefinition = (program, deps) => {
         }), command);
     });
     const events = annotate(program.command("events").description("the account's stored events"), { effects: GROUP });
-    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", "events list starts_at>=2026-11-02 --limit 50 --page 2")
+    example(withQuery(annotate(events.command("list"), { effects: LOCAL_READ, partial: true }).description("list stored events, earliest first; --source reads several accounts as one list"), 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", "events list overlapping:true --source all")
         .option("--limit <n>", "events per page, 1–1000", integer, 100)
         .option("--page <n>", "which page, starting at 1", integer, 1)
+        .option("--source <accounts>", "calendar accounts held in the store to read as one list: all, a provider, or a list such as " +
+        `${program.name()}:work,${program.name()}:personal or group:<name>; the profile's account when absent`)
         .action(async (words, opts, command) => {
+        const own = { id: deps.accountId, key: deps.account };
+        const { accounts, skipped } = opts.source === undefined
+            ? { accounts: [own], skipped: [] }
+            : await sourceAccounts(messages("--source"), deps.account, opts.source, program.name());
+        if (deps.locked && accounts.some(({ id }) => id !== own.id))
+            throw new CliError("permission_error", "this process is locked to one profile; --source may name only its own account", { reason: "profile.locked" });
         const filter = await eventsFilter(words, {
             store: deps.store,
             accountId: deps.accountId,
+            accountIds: accounts.map(({ id }) => id),
             zone: zone(),
             now: now(),
             personOf: personId,
         });
-        print(eachMarked(await eventsAnswer(deps.store, filter && { ...filter, limit: opts.limit }, opts.page), EVENT_ITEM_UNTRUSTED), command);
+        print({
+            ...eachMarked(await eventsAnswer(deps.store, filter && { ...filter, limit: opts.limit }, opts.page), EVENT_ITEM_UNTRUSTED),
+            meta: await accountsMeta(deps.store, accounts, skipped, now()),
+        }, command);
     });
     example(annotate(events.command("show"), { effects: LOCAL_READ })
         .description("one event: its calendar copies, attendees with their person, Drive files and history")

package/dist/calendar/mcp/index.js

@@ -30,7 +30,8 @@ export const calendarTools = [
         name: "events_list",
         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",
+            "overlapping:true (timed events that clash, each with overlaps), 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,

package/dist/calendar/reads.d.ts

@@ -1,6 +1,8 @@
 import { type Predicate, type QueryRegistry } from "@wirecat/cli-base/query";
+import type { Issue, Meta } from "@wirecat/cli-base/standards";
 import { type QueryWords } from "../cli/list-query.js";
 import { type EventDetails, type EventFilter, type EventStore, type StoredCalendar, type StoredEntry } from "../meetings/index.js";
+import type { AccountKey, MessageStore } from "../store/store.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>;
 /** Fields whose text whoever sent the invitation wrote: an agent reads them as data. */
@@ -28,12 +30,14 @@ export declare const timeWindow: (node: Predicate, zone: string, now: number) =>
     upper?: number;
 };
 /**
- * `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.
+ * `events list`'s query into a store filter, for one account or, with `accountIds`, several. A person named by
+ * address is found through the shared store; one nobody knows matches no event.
  */
 export declare const eventsFilter: (query: QueryWords, context: {
     store: EventStore;
     accountId: number;
+    /** These accounts in place of `accountId`. */
+    accountIds?: readonly number[];
     zone: string;
     now: number;
     personOf?: (reference: string) => Promise<number | null>;
@@ -80,6 +84,7 @@ export declare const eventAnswer: (details: EventDetails, personOf?: PersonOfEma
         starts_at: string | null;
         ends_at: string | null;
     } | undefined;
+    overlapping?: boolean | undefined;
     overlaps?: string[] | undefined;
     ref: string;
     entries: {
@@ -209,7 +214,27 @@ export declare const eventsAnswer: (store: EventStore, filter: EventFilter | nul
             starts_at: string | null;
             ends_at: string | null;
         } | undefined;
+        overlapping?: boolean | undefined;
         overlaps?: string[] | undefined;
     }[];
     page: number;
 }>;
+/** A calendar account a list reads: the store's id, and its name as `meta.accounts` gives it. */
+export interface ReadAccount {
+    id: number;
+    key: AccountKey;
+}
+/**
+ * The calendar accounts `--source` names, as `search messages --source` reads them (WC-ACCT-8): `all`, a provider,
+ * `provider:account` with an account or a profile, or `group:<name>`. An entry that names no calendar account is in
+ * `skipped`; nothing at all is an error.
+ */
+export declare const sourceAccounts: (messages: MessageStore, running: AccountKey, source: string, command: string) => Promise<{
+    accounts: ReadAccount[];
+    skipped: Issue[];
+}>;
+/**
+ * `meta` of a list over calendar accounts (WC-ACCT-9): which it read, and `complete: false` when one has no synced
+ * calendar, or a calendar whose sync never finished or is in the middle of a round, so its events may be missing.
+ */
+export declare const accountsMeta: (store: EventStore, accounts: readonly ReadAccount[], skipped: readonly Issue[], now: number) => Promise<Pick<Meta, "accounts" | "complete" | "issues">>;

package/dist/calendar/reads.js

@@ -2,6 +2,9 @@ import { CliError } from "@wirecat/cli-base";
 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";
+import { entriesOfList, fitting } from "../search/account-list.js";
+import { listContextOf } from "../services/search-kind.js";
+import { calendarStatus } from "./sync.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 = [
@@ -27,6 +30,22 @@ export const calendarItem = (one) => ({
     synced: one.synced,
     seen_at: iso(one.seenAt),
 });
+/** A stored calendar by its id or the provider's id, among the accounts' calendars; one the id names twice is refused. */
+const calendarAmong = async (store, accountIds, reference) => {
+    if (accountIds.length === 1)
+        return calendarIn(store, accountIds[0], reference);
+    const calendars = (await Promise.all(accountIds.map((id) => store.calendars(id)))).flat();
+    const byId = calendars.find((one) => String(one.id) === reference);
+    if (byId)
+        return byId;
+    const byExternal = calendars.filter((one) => one.externalId === reference);
+    if (byExternal.length > 1)
+        throw new CliError("validation_error", `calendar ${reference} is in more than one of these accounts; name it by its id: ` +
+            byExternal.map(({ id }) => id).join(", "));
+    if (!byExternal[0])
+        throw new CliError("not_found", `no calendar ${reference} in these accounts`);
+    return byExternal[0];
+};
 /** A stored calendar by its id or the provider's id, among the account's calendars. */
 export const calendarIn = async (store, accountId, reference) => {
     const calendars = await store.calendars(accountId);
@@ -59,7 +78,7 @@ export const EVENTS_QUERY = {
     entity: "event",
     backend: "native",
     fields: queryFieldsOf(event, {
-        native: ["starts_at", "ends_at", "changed_at", "calendar", "person"],
+        native: ["starts_at", "ends_at", "changed_at", "overlapping", "calendar", "person"],
         relations: {
             calendar: { type: "kw", example: "calendar:3", relation: "one calendar, by its id or the provider's id" },
             person: {
@@ -72,17 +91,27 @@ export const EVENTS_QUERY = {
             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",
+            overlapping: "overlapping:true",
         },
         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,
+            operators: field.type === "time"
+                ? ["term", "range"]
+                : field.type === "bool"
+                    ? ["term"]
+                    : ["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.";
+    "or ends_at: events that end after the start of today, in your time zone.\noverlapping:true keeps timed events " +
+    "that overlap another in the accounts read, each with overlaps: the others. Left out: all-day, cancelled, " +
+    "declined and free events and working-location blocks; back-to-back events do not overlap.";
 /** A time term as epoch ms: from `lower` on, and before `upper`. */
 export const timeWindow = (node, zone, now) => {
     const range = node.operator === "range"
@@ -94,11 +123,12 @@ export const timeWindow = (node, zone, now) => {
     };
 };
 /**
- * `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.
+ * `events list`'s query into a store filter, for one account or, with `accountIds`, several. A person named by
+ * address is found through the shared store; one nobody knows matches no event.
  */
 export const eventsFilter = async (query, context) => {
-    const filter = { accountId: context.accountId };
+    const accounts = context.accountIds ?? [context.accountId];
+    const filter = accounts.length === 1 ? { accountId: accounts[0] } : { accountIds: accounts };
     const { zone, now } = context;
     const span = (text) => ({ start: 0, end: text.length });
     const day = (date) => dayBoundary(date, zone, false, span(date));
@@ -122,8 +152,10 @@ export const eventsFilter = async (query, context) => {
             if (lower !== undefined)
                 filter.changedSince = lower;
         }
+        else if (field === "overlapping")
+            filter.overlapping = node.value.toLowerCase() === "true";
         else if (field === "calendar")
-            filter.calendarId = (await calendarIn(context.store, context.accountId, node.value)).id;
+            filter.calendarId = (await calendarAmong(context.store, accounts, node.value)).id;
         else if (field === "person") {
             if (!context.personOf)
                 throw new CliError("configuration_error", "this tool cannot look people up");
@@ -172,6 +204,12 @@ const ownCopies = (details, calendars) => {
     };
 };
 const calendarIds = async (store, accountId) => new Set((await store.calendars(accountId)).map(({ id }) => id));
+const accountsOf = (filter) => filter.accountIds ?? (filter.accountId === undefined ? [] : [filter.accountId]);
+const scopeOf = (filter) => filter.accountIds !== undefined
+    ? { accountIds: filter.accountIds }
+    : filter.accountId === undefined
+        ? {}
+        : { accountId: filter.accountId };
 /** An event the account holds, with only its copies, or `not_found`: another account's event is not shown. */
 export const eventOf = async (store, accountId, id) => {
     const details = await store.event(id);
@@ -305,7 +343,7 @@ export const resolveAnswer = async (store, accountId, review, choice, now) => {
 };
 /** What changed about each listed event since the filter's instant, from its own copies. */
 const changesOf = async (store, rows, filter, since) => {
-    const mine = filter.accountId === undefined ? [] : [...(await calendarIds(store, filter.accountId))];
+    const mine = (await Promise.all(accountsOf(filter).map(async (id) => [...(await calendarIds(store, id))]))).flat();
     const { entries, revisions } = await store.historyOf(rows.map(({ id }) => id), mine, since);
     return new Map(rows.map((event) => [
         event.id,
@@ -318,7 +356,7 @@ const overlapsOf = async (store, rows, filter) => {
     if (!timed.length)
         return new Map();
     const others = await store.events({
-        ...(filter.accountId === undefined ? {} : { accountId: filter.accountId }),
+        ...scopeOf(filter),
         from: Math.min(...timed.map(({ startsAt }) => startsAt)),
         to: Math.max(...timed.map(({ endsAt }) => endsAt)),
         overlapping: true,
@@ -337,7 +375,7 @@ export const eventsAnswer = async (store, filter, number = 1) => {
         return listed([]);
     const { rows, limit, hasMore } = await page(store, { ...filter, offset: (number - 1) * (filter.limit ?? 100) });
     const changes = filter.changedSince === undefined ? null : await changesOf(store, rows, filter, filter.changedSince);
-    const overlaps = filter.overlapping ? await overlapsOf(store, rows, filter) : null;
+    const overlaps = filter.overlapping === true ? await overlapsOf(store, rows, filter) : null;
     return listed(rows.map((event) => {
         const change = changes?.get(event.id);
         return {
@@ -349,7 +387,52 @@ export const eventsAnswer = async (store, filter, number = 1) => {
                     ...(change.was ? { was: { starts_at: iso(change.was.startsAt), ends_at: iso(change.was.endsAt) } } : {}),
                 }
                 : {}),
+            ...(filter.overlapping === undefined ? {} : { overlapping: filter.overlapping }),
             ...(overlaps ? { overlaps: (overlaps.get(event.id) ?? []).map(({ id }) => `event:${id}`) } : {}),
         };
     }), { limit, hasMore, page: number });
 };
+const nameOf = ({ provider, account }) => `${provider}:${account}`;
+/**
+ * The calendar accounts `--source` names, as `search messages --source` reads them (WC-ACCT-8): `all`, a provider,
+ * `provider:account` with an account or a profile, or `group:<name>`. An entry that names no calendar account is in
+ * `skipped`; nothing at all is an error.
+ */
+export const sourceAccounts = async (messages, running, source, command) => {
+    const context = await listContextOf(messages, running, undefined);
+    const { accounts, skipped } = fitting(entriesOfList(source, { ...context, running: { provider: running.provider, command } }), ["events"], `${command} events list`);
+    const stored = await messages.accounts.storedAccounts();
+    const read = [];
+    const issues = skipped.map(({ code, source }) => ({ code, source }));
+    for (const key of accounts) {
+        const held = stored.find((one) => one.provider === key.provider && one.account === key.account);
+        if (held)
+            read.push({ id: held.id, key });
+        else
+            issues.push({ code: "not_found", reason: "calendar.unsynced", source: nameOf(key) });
+    }
+    if (read.length === 0)
+        throw new CliError("not_found", `--source ${source} names no calendar account this store holds`, {
+            reason: "calendar.unsynced",
+        });
+    return { accounts: read, skipped: issues };
+};
+/**
+ * `meta` of a list over calendar accounts (WC-ACCT-9): which it read, and `complete: false` when one has no synced
+ * calendar, or a calendar whose sync never finished or is in the middle of a round, so its events may be missing.
+ */
+export const accountsMeta = async (store, accounts, skipped, now) => {
+    const issues = [...skipped];
+    for (const { id, key } of accounts) {
+        const { items } = await calendarStatus(store, id, { profile: nameOf(key), now });
+        if (items.length === 0)
+            issues.push({ code: "not_found", reason: "calendar.unsynced", source: nameOf(key) });
+        else if (items.some(({ state }) => state !== "complete"))
+            issues.push({ code: "not_found", reason: "calendar.sync-incomplete", source: nameOf(key) });
+    }
+    return {
+        accounts: accounts.map(({ key }) => nameOf(key)),
+        complete: issues.length === 0,
+        ...(issues.length ? { issues } : {}),
+    };
+};

package/dist/calendar/testing/memory.js

@@ -453,8 +453,13 @@ export const memoryEventStore = () => {
             if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
                 throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
             const has = (event, check) => entries.some((one) => one.eventId === event.id && check(one));
-            const copiesOf = (event) => entries.filter((one) => one.eventId === event.id &&
-                (filter.accountId === undefined || calendarOf(one.calendarId).accountId === filter.accountId));
+            if (filter.accountIds !== undefined && filter.accountId !== undefined)
+                throw new CliError("validation_error", "an event filter takes accountId or accountIds, not both");
+            if (filter.accountIds?.length === 0)
+                throw new CliError("validation_error", "accountIds names no account");
+            const accounts = filter.accountIds ?? (filter.accountId === undefined ? undefined : [filter.accountId]);
+            const inAccounts = (one) => accounts === undefined || accounts.includes(calendarOf(one.calendarId).accountId);
+            const copiesOf = (event) => entries.filter((one) => one.eventId === event.id && inAccounts(one));
             const busy = (event) => event.deletedAt === null &&
                 event.status !== "cancelled" &&
                 !event.allDay &&
@@ -463,7 +468,13 @@ export const memoryEventStore = () => {
                 copiesOf(event).some((one) => one.deletedAt === null &&
                     one.status !== "cancelled" &&
                     one.ownResponse !== "declined" &&
-                    one.transparency !== "transparent");
+                    one.transparency !== "transparent" &&
+                    one.eventType !== "working-location");
+            const clashes = (event) => busy(event) &&
+                [...events.values()].some((other) => other.id !== event.id &&
+                    busy(other) &&
+                    other.startsAt < event.endsAt &&
+                    other.endsAt > event.startsAt);
             return [...events.values()]
                 .filter((event) => event.deletedAt === null &&
                 (filter.from === undefined ||
@@ -479,18 +490,12 @@ export const memoryEventStore = () => {
                         ? 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)) &&
+                (accounts === undefined || has(event, inAccounts)) &&
                 (filter.personId === undefined ||
                     has(event, (one) => participants.some((p) => p.entryId === one.id && p.identityId === filter.personId))) &&
                 (filter.changedSince === undefined ||
                     eventChange(event, copiesOf(event), revisions, filter.changedSince) !== null) &&
-                (!filter.overlapping ||
-                    (busy(event) &&
-                        [...events.values()].some((other) => other.id !== event.id &&
-                            busy(other) &&
-                            other.startsAt < event.endsAt &&
-                            other.endsAt > event.startsAt))))
+                (filter.overlapping === undefined || clashes(event) === filter.overlapping))
                 .sort((a, b) => ((a.startsAt ?? -1) - (b.startsAt ?? -1) || a.id - b.id) * (filter.newest ? -1 : 1))
                 .slice(offset, offset + limit)
                 .map((event) => ({ ...event }));

package/dist/cli/messenger/messages-search-command.js

@@ -49,7 +49,7 @@ offer \`${messenger.app.command} messages sync <chat>\` and run it only once the
         : `Search reads the local archive: what \`${messenger.app.command} serve\` has kept since the account was linked.
 Keep serve running so new messages are searchable.`} Notes are
 \`${messenger.app.command} search notes\`, messages and notes at once \`${messenger.app.command} search all\`; for mail,
-the separate memo CLI: \`memo search mail\`.
+the mail CLI: \`mail <profile> search messages\`.
 A bare word looks in message text, voice transcripts, file names and file text. text:, transcript:,
 content: (the text of files) and filename: (their names) narrow it to one —
 \`${messenger.app.command} search messages 'content:invoice'\`. chat: narrows it to one chat; has:voice, has:file and

package/dist/entities/index.d.ts

@@ -6362,6 +6362,7 @@ export declare const ENTITIES: {
             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>;
     }, undefined>;
     readonly meeting_review: v.StrictObjectSchema<{

package/dist/errors/reasons.js

@@ -63,6 +63,9 @@ const OTHERS = [
     validation("event.repeat-count", "a COUNT series is split only with a rule for its new part"),
     validation("event.unmovable", "the provider keeps this kind of event on its calendar"),
     ["calendar.read-only", "permission_error", "the calendar takes no new events from this account"],
+    ["calendar.unsynced", "not_found", "the calendar account has no synced calendar in the store"],
+    ["calendar.sync-incomplete", "not_found", "a synced calendar's sync never finished or is mid-round"],
+    ["profile.locked", "permission_error", "a profile lock pins this process to its own account"],
     ["busy.offline", "permission_error", "calendars busy asks the provider; --offline was given"],
     validation("busy.no-calendars", "no calendar syncs and no person was named, so there is nobody to ask"),
     ["search.offline", "permission_error", "search --backend server asks the provider; --offline was given"],

package/dist/mail/cli/index.js

@@ -18,6 +18,12 @@ import { searchMailServer } from "../../mail/server-search.js";
 import { atDetail } from "../../output-detail.js";
 import { sourceKey } from "../../services/server-search.js";
 import { queryFilter, THREAD_COLUMNS } from "../../store/store.js";
+/** A locked or broken store must fail the command, not read as "nothing stored yet". */
+const absentAccount = (error) => {
+    if (error instanceof CliError && error.code === "not_found")
+        return undefined;
+    throw error;
+};
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 100;
 const limitOf = (value) => {
@@ -252,7 +258,7 @@ const conversationsCommand = (mail) => {
         const typed = typedQuery(words);
         const query = listQuery(typed, THREAD_QUERY, "conversations list");
         const { threads, mailbox } = await mail.read(this, async (store, mailbox) => {
-            const account = await store.accounts.storedAccount(mailbox).catch(() => undefined);
+            const account = await store.accounts.storedAccount(mailbox).catch(absentAccount);
             if (!account)
                 return { threads: [], mailbox };
             const where = query ? queryFilter(query, THREAD_COLUMNS, { command: "conversations list" }) : undefined;
@@ -296,7 +302,7 @@ const conversationsCommand = (mail) => {
         const full = detailOf(this) === "full";
         const emails = await mail.read(this, async (store, mailbox) => {
             const thread = threadOf(mailbox, given);
-            const account = await store.accounts.storedAccount(mailbox).catch(() => undefined);
+            const account = await store.accounts.storedAccount(mailbox).catch(absentAccount);
             const hits = account ? await store.mail.threadHits(account.id, thread) : [];
             if (!account || hits.length === 0)
                 throw new CliError("not_found", `no stored thread ${given}`);

package/dist/mail/ids.d.ts

@@ -0,0 +1,20 @@
+export interface MailIdsInput {
+    /** As the server's envelope gives it; read from `head` when absent. */
+    messageId?: string | undefined;
+    /** Header text holding at least References and In-Reply-To. */
+    head: string;
+    folder: string;
+    validity: string;
+    uid: string;
+}
+/**
+ * The ids of an email on any server but Gmail, whose X-GM-MSGID and X-GM-THRID are used as they are. OBJECTID's
+ * EMAILID is not used: mail and memo must give one email one id, and a server that turns OBJECTID on later must not
+ * store its mail again. The Message-ID is the identity; without one, the UID, which means nothing without
+ * UIDVALIDITY. The thread is the first Message-ID of References, the thread's first email (RFC 5322 §3.6.4), else
+ * In-Reply-To's parent, so a server without thread ids (Yandex, Mail.ru) still keeps a conversation together.
+ */
+export declare const mailIds: ({ messageId, head, folder, validity, uid }: MailIdsInput) => {
+    messageId: string;
+    threadId: string;
+};

package/dist/mail/ids.js

@@ -0,0 +1,17 @@
+import { createHash } from "node:crypto";
+import { field, unfold } from "./headers.js";
+const digest = (id) => `imap:${createHash("sha256").update(id).digest("hex")}`;
+const firstId = (value) => /<[^<>\s]+>/.exec(value ?? "")?.[0];
+/**
+ * The ids of an email on any server but Gmail, whose X-GM-MSGID and X-GM-THRID are used as they are. OBJECTID's
+ * EMAILID is not used: mail and memo must give one email one id, and a server that turns OBJECTID on later must not
+ * store its mail again. The Message-ID is the identity; without one, the UID, which means nothing without
+ * UIDVALIDITY. The thread is the first Message-ID of References, the thread's first email (RFC 5322 §3.6.4), else
+ * In-Reply-To's parent, so a server without thread ids (Yandex, Mail.ru) still keeps a conversation together.
+ */
+export const mailIds = ({ messageId, head, folder, validity, uid }) => {
+    const unfolded = unfold(head);
+    const identity = (messageId ?? field(unfolded, "message-id"))?.trim() || `uid:${folder}:${validity}:${uid}`;
+    const root = firstId(field(unfolded, "references")) ?? firstId(field(unfolded, "in-reply-to"));
+    return { messageId: digest(identity), threadId: digest(root ?? identity) };
+};

package/dist/mail/index.d.ts

@@ -3,7 +3,8 @@ export { factsOf } from "./facts.js";
 export { GMAIL_ALL_MAIL, mailFolders } from "./folders.js";
 export { dropMissing, type Gone, tooManyGone } from "./gone.js";
 export { type AuthVerdicts, HEADER_FIELDS, headersOf, type MailHeaders, mailHeadersOf } from "./headers.js";
-export { decodeMailboxName, labelName, systemLabel } from "./labels.js";
+export { type MailIdsInput, mailIds } from "./ids.js";
+export { decodedLabelName, decodeMailboxName, labelName, systemLabel } from "./labels.js";
 export { type Address, htmlToText, looksLikeHtml, MAX_BODY_CHARS, type ParsedMail, parseMail, } from "./parse.js";
 export { PRESET_NAMES, PRESETS, type PresetName, presetMatches } from "./presets.js";
 export { domainsToAge, groupKey, type Probe, type ProbeGroup, probeMail, SUGGEST_RULE } from "./probe.js";
@@ -11,7 +12,7 @@ export { type MailFolderProgress, mailProgress } from "./progress.js";
 export { ATTACHMENT_CHARS, attachmentsText, hitText, lowerSuspicious, type MailSearch, type ShownMail, searchMail, showMail, withAttachmentText, } from "./read.js";
 export { type FileStamp, FULL_PASS_MS, MBOX_RESUME, type MboxPoint, mergeRanges, parsePoint, type Ranges, type ResumePoint, rangesOf, resumeKey, rulesKey, within, } from "./resume.js";
 export { ruleInput, STORE_ACTION } from "./rule-input.js";
-export { storedMailRule, storedMailRules } from "./rule-stored.js";
+export { type MailRuleSet, storedMailRule, storedMailRuleSet, storedMailRules } from "./rule-stored.js";
 export { mapProposedTags, ruleTagger, settleRuleTags, type TagOutcome } from "./rule-tags.js";
 export { conditionKeys, decide, describeMatch, ENVELOPE, envelopeBox, envelopeBoxOf, type MailAction, type MailFacts, type MailRule, type MailRuleMatch, matches, sameMatch, tagsOf, } from "./rules.js";
 export { type DomainAge, FRAUD_SIGNALS, FREE_MAIL, registrableOf, SCORE_RULE, type Scored, type Signal, scoreGroup, WEIGHTS, } from "./score.js";

package/dist/mail/index.js

@@ -3,7 +3,8 @@ export { factsOf } from "./facts.js";
 export { GMAIL_ALL_MAIL, mailFolders } from "./folders.js";
 export { dropMissing, tooManyGone } from "./gone.js";
 export { HEADER_FIELDS, headersOf, mailHeadersOf } from "./headers.js";
-export { decodeMailboxName, labelName, systemLabel } from "./labels.js";
+export { mailIds } from "./ids.js";
+export { decodedLabelName, decodeMailboxName, labelName, systemLabel } from "./labels.js";
 export { htmlToText, looksLikeHtml, MAX_BODY_CHARS, parseMail, } from "./parse.js";
 export { PRESET_NAMES, PRESETS, presetMatches } from "./presets.js";
 export { domainsToAge, groupKey, probeMail, SUGGEST_RULE } from "./probe.js";
@@ -11,7 +12,7 @@ export { mailProgress } from "./progress.js";
 export { ATTACHMENT_CHARS, attachmentsText, hitText, lowerSuspicious, searchMail, showMail, withAttachmentText, } from "./read.js";
 export { FULL_PASS_MS, MBOX_RESUME, mergeRanges, parsePoint, rangesOf, resumeKey, rulesKey, within, } from "./resume.js";
 export { ruleInput, STORE_ACTION } from "./rule-input.js";
-export { storedMailRule, storedMailRules } from "./rule-stored.js";
+export { storedMailRule, storedMailRuleSet, storedMailRules } from "./rule-stored.js";
 export { mapProposedTags, ruleTagger, settleRuleTags } from "./rule-tags.js";
 export { conditionKeys, decide, describeMatch, ENVELOPE, envelopeBox, envelopeBoxOf, matches, sameMatch, tagsOf, } from "./rules.js";
 export { FRAUD_SIGNALS, FREE_MAIL, registrableOf, SCORE_RULE, scoreGroup, WEIGHTS, } from "./score.js";

package/dist/mail/labels.d.ts

@@ -1,5 +1,10 @@
 /** IMAP's modified UTF-7 (RFC 3501 §5.1.3): `&` opens base64 of UTF-16BE, `,` stands for `/`, `-` closes. */
 export declare const decodeMailboxName: (name: string) => string;
 export declare const systemLabel: (name: string) => string;
-/** A label as people read it: `\\Important` and `Important` are one label, and names are decoded. */
+/**
+ * A label as people read it, from a name already decoded (imapflow decodes X-GM-LABELS): `\\Important` and
+ * `Important` are one label. Decoding twice would turn `R&D-team` into `Rteam`.
+ */
+export declare const decodedLabelName: (name: string) => string;
+/** The same from X-GM-LABELS as the server sends it, in modified UTF-7. */
 export declare const labelName: (raw: string) => string;

package/dist/mail/labels.js

@@ -20,8 +20,13 @@ export const decodeMailboxName = (name) => name.replace(/&([^-]*)-/g, (_, run) =
     return text;
 });
 export const systemLabel = (name) => SYSTEM_LABELS[name.toLowerCase()] ?? name;
-/** A label as people read it: `\\Important` and `Important` are one label, and names are decoded. */
-export const labelName = (raw) => {
-    const system = raw.startsWith("\\") ? raw.slice(1) : raw;
-    return SYSTEM_LABELS[system.toLowerCase()] ?? decodeMailboxName(system);
+/**
+ * A label as people read it, from a name already decoded (imapflow decodes X-GM-LABELS): `\\Important` and
+ * `Important` are one label. Decoding twice would turn `R&D-team` into `Rteam`.
+ */
+export const decodedLabelName = (name) => {
+    const system = name.startsWith("\\") ? name.slice(1) : name;
+    return SYSTEM_LABELS[system.toLowerCase()] ?? system;
 };
+/** The same from X-GM-LABELS as the server sends it, in modified UTF-7. */
+export const labelName = (raw) => decodedLabelName(decodeMailboxName(raw));

package/dist/mail/rule-stored.d.ts

@@ -3,7 +3,21 @@ import type { MessageStore, MailRule as StoredRule } from "../store/index.js";
 import type { MailRule } from "./rules.js";
 /** A stored rule as the sync reads it; `undefined` for one this build cannot read, so it is left to the build that can. */
 export declare const storedMailRule: (stored: StoredRule) => MailRule | undefined;
+export interface MailRuleSet {
+    rules: MailRule[];
+    /**
+     * Stored rules this build cannot read, each with what it does not know. The sync leaves them out, and a build that
+     * reads them decides mail differently, so a sync reports them rather than drop them silently.
+     */
+    unreadable: {
+        id: number;
+        why: string;
+    }[];
+}
 /** One account's rules from the store, for `account.rules` of the sync; none when the store has not seen the account. */
+export declare const storedMailRuleSet: (store: MessageStore, account: {
+    address: string;
+}, query?: QueryAst) => Promise<MailRuleSet>;
 export declare const storedMailRules: (store: MessageStore, account: {
     address: string;
 }, query?: QueryAst) => Promise<MailRule[]>;

package/dist/mail/rule-stored.js

@@ -17,15 +17,24 @@ const KINDS = {
     score_at_least: "number",
     preset: "string",
 };
+/** Why this build cannot read a stored rule, or undefined when it can. */
+const unreadable = (stored) => {
+    if (ACTION_OF[String(stored.actions.store)] === undefined)
+        return `action ${String(stored.actions.store)}`;
+    const entries = Object.entries(stored.conditions);
+    if (entries.length === 0)
+        return "no condition";
+    const unknown = entries.find(([key, value]) => !(key in KINDS) ||
+        typeof value !== KINDS[key] ||
+        (key === "preset" && !PRESET_NAMES.includes(value)));
+    return unknown && `condition ${unknown[0]}`;
+};
 /** A stored rule as the sync reads it; `undefined` for one this build cannot read, so it is left to the build that can. */
 export const storedMailRule = (stored) => {
+    if (unreadable(stored) !== undefined)
+        return undefined;
     const action = ACTION_OF[String(stored.actions.store)];
     const entries = Object.entries(stored.conditions);
-    const known = entries.every(([key, value]) => key in KINDS &&
-        typeof value === KINDS[key] &&
-        !(key === "preset" && !PRESET_NAMES.includes(value)));
-    if (action === undefined || !known || entries.length === 0)
-        return undefined;
     const tags = Array.isArray(stored.actions.tags) ? stored.actions.tags.filter((tag) => typeof tag === "string") : [];
     const skipped = stored.actions.tags_skipped;
     const tagsSkipped = skipped !== null && typeof skipped === "object" && !Array.isArray(skipped)
@@ -44,14 +53,25 @@ export const storedMailRule = (stored) => {
     };
 };
 /** One account's rules from the store, for `account.rules` of the sync; none when the store has not seen the account. */
-export const storedMailRules = async (store, account, query) => {
+export const storedMailRuleSet = async (store, account, query) => {
+    let stored;
     try {
         const { id } = await store.accounts.storedAccount({ provider: "email", account: account.address.toLowerCase() });
-        return (await store.mail.rules.list(id, query)).flatMap((stored) => storedMailRule(stored) ?? []);
+        stored = await store.mail.rules.list(id, query);
     }
     catch (error) {
         if (error instanceof CliError && error.code === "not_found")
-            return [];
+            return { rules: [], unreadable: [] };
         throw error;
     }
+    const set = { rules: [], unreadable: [] };
+    for (const one of stored) {
+        const why = unreadable(one);
+        if (why === undefined)
+            set.rules.push(storedMailRule(one));
+        else
+            set.unreadable.push({ id: one.id, why });
+    }
+    return set;
 };
+export const storedMailRules = async (store, account, query) => (await storedMailRuleSet(store, account, query)).rules;

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

@@ -194,13 +194,16 @@ export interface EventFilter {
     /** Events `eventChange` finds new, moved or cancelled at or after this instant. */
     changedSince?: number;
     /**
-     * Events whose time overlaps another's. Only timed events that take the owner's time count: not cancelled, and with
-     * a live copy the owner did not decline or mark free.
+     * `true`: events whose time overlaps another's; `false`: every other event. Only timed events that take the owner's
+     * time count: not cancelled, and with a live copy, in the accounts read, that the owner did not decline or mark
+     * free and that is no working-location marker. Back-to-back events do not overlap.
      */
     overlapping?: boolean;
     /** All-day events starting before this local day (exclusive); `to` without it. */
     toDate?: string;
     accountId?: number;
+    /** Several accounts' events at once, in place of `accountId`. */
+    accountIds?: readonly number[];
     calendarId?: number;
     /** Events whose entries list one of this person's contacts. */
     personId?: number;

package/dist/meetings/read-answers.d.ts

@@ -195,7 +195,12 @@ export declare const event: 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>;
-    /** On a calendar CLI's `events list overlapping`: the events it clashes with, as `event:<id>`. */
+    /**
+     * Whether its time overlaps another event's, in the accounts read: a timed event, not cancelled, not declined, not
+     * free and no working-location block. On a calendar CLI's `events list` when the query names it.
+     */
+    readonly overlapping: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    /** With `overlapping:true`: the events it overlaps, as `event:<id>`. */
     readonly overlaps: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;
 export declare const eventItem: (one: Event) => v.InferOutput<typeof event>;

package/dist/meetings/read-answers.js

@@ -207,7 +207,12 @@ export const event = v.strictObject({
     changed_at: v.optional(v.nullable(isoTime)),
     /** The times a moved event had at that date. */
     was: v.optional(v.strictObject({ starts_at: v.nullable(isoTime), ends_at: v.nullable(isoTime) })),
-    /** On a calendar CLI's `events list overlapping`: the events it clashes with, as `event:<id>`. */
+    /**
+     * Whether its time overlaps another event's, in the accounts read: a timed event, not cancelled, not declined, not
+     * free and no working-location block. On a calendar CLI's `events list` when the query names it.
+     */
+    overlapping: v.optional(v.boolean()),
+    /** With `overlapping:true`: the events it overlaps, as `event:<id>`. */
     overlaps: v.optional(v.array(text)),
 });
 export const eventItem = (one) => ({

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

@@ -1,9 +1,10 @@
 import { type EventStore } from "../event-store.js";
 import type { ContractCase } from "../store.js";
-/** A fresh, empty store and one calendar account in it. */
+/** A fresh, empty store and two calendar accounts in it. */
 export interface EventStoreFixture {
     store: EventStore;
     accountId: number;
+    otherAccountId: number;
 }
 /** "Now" in every case: entries before it have happened. */
 export declare const CONTRACT_NOW: number;

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

@@ -354,6 +354,34 @@ export const eventStoreContract = (make) => {
             const ids = new Set(found.map(({ id }) => id));
             for (const externalId of ["first", "second"])
                 assert.ok(ids.has((await store.entry(calendar, externalId))?.eventId), externalId);
+            const all = await store.events({ from: at - HOUR, to: at + 8 * HOUR });
+            const rest = await store.events({ overlapping: false, from: at - HOUR, to: at + 8 * HOUR });
+            assert.deepEqual(rest.map(({ id }) => id), all.filter(({ id }) => !ids.has(id)).map(({ id }) => id));
+        }),
+        test("a working-location block overlaps nothing; a meeting in another account overlaps when both are read", async ({ store, calendar, ...fixture }) => {
+            const at = later;
+            const [other] = await store.saveCalendars(fixture.otherAccountId, [
+                {
+                    externalId: "other-primary",
+                    title: "Home",
+                    timezone: "UTC",
+                    accessRole: "owner",
+                    primary: true,
+                    syncByDefault: true,
+                },
+            ], 1);
+            await store.saveEntries(calendar, [single("office", at, { eventType: "working-location", endsAt: at + 8 * HOUR }), single("work", at + HOUR)], 2);
+            await store.saveEntries(other.id, [single("dentist", at + HOUR + HOUR / 2)], 2);
+            const window = { from: at - HOUR, to: at + 8 * HOUR };
+            assert.equal((await store.events({ ...window, overlapping: true, accountId: fixture.accountId })).length, 0);
+            const both = await store.events({
+                ...window,
+                overlapping: true,
+                accountIds: [fixture.accountId, fixture.otherAccountId],
+            });
+            assert.equal(both.length, 2);
+            assert.equal((await store.events({ ...window, accountIds: [fixture.accountId, fixture.otherAccountId] })).length, 3);
+            assert.equal((await store.events({ ...window, accountIds: [fixture.otherAccountId] })).length, 1);
         }),
         test("participants are kept by address; a room is listed and is no contact", async ({ store, calendar }) => {
             const [entry] = await store.saveEntries(calendar, [

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

@@ -1,6 +1,13 @@
 import { CliError } from "@wirecat/cli-base";
 import { eventOf } from "./events.js";
 const DAY = 86_400_000;
+const accountsOf = (filter) => {
+    if (filter.accountIds !== undefined && filter.accountId !== undefined)
+        throw new CliError("validation_error", "an event filter takes accountId or accountIds, not both");
+    if (filter.accountIds?.length === 0)
+        throw new CliError("validation_error", "accountIds names no account");
+    return filter.accountIds ?? (filter.accountId === undefined ? undefined : [filter.accountId]);
+};
 /** The events of a filter, earliest first (`EventStore.events`). */
 export const listEvents = (database, filter) => {
     const clauses = ["e.deleted_at IS NULL"];
@@ -40,21 +47,22 @@ export const listEvents = (database, filter) => {
         clauses.push(entries("ce.calendar_id = ?"));
         params.push(filter.calendarId);
     }
-    if (filter.accountId !== undefined) {
-        clauses.push(entries("c.account_id = ?"));
-        params.push(filter.accountId);
-    }
+    const accounts = accountsOf(filter);
+    const inAccounts = (column) => {
+        if (accounts === undefined)
+            return "";
+        for (const id of accounts)
+            params.push(id);
+        return `${column} IN (${accounts.map(() => "?").join(", ")})`;
+    };
+    if (accounts !== undefined)
+        clauses.push(entries(inAccounts("c.account_id")));
     if (filter.personId !== undefined) {
         clauses.push(entries("EXISTS (SELECT 1 FROM calendar_entry_participants p JOIN identity_links il ON il.identity_id = p.identity_id " +
             "WHERE p.entry_id = ce.id AND il.person_id = ?)"));
         params.push(filter.personId);
     }
-    const account = (alias) => {
-        if (filter.accountId === undefined)
-            return "";
-        params.push(filter.accountId);
-        return ` AND ${alias}.account_id = ?`;
-    };
+    const account = (alias) => (accounts === undefined ? "" : ` AND ${inAccounts(`${alias}.account_id`)}`);
     if (filter.changedSince !== undefined) {
         // The SQL form of eventChange: first stored since, cancelled since, or a live copy's time changed since.
         const since = filter.changedSince;
@@ -72,16 +80,18 @@ export const listEvents = (database, filter) => {
              OR r.ends_at IS NOT ce.ends_at FROM calendar_entry_revisions r WHERE r.entry_id = ce.id AND r.created_at >= ?
              ORDER BY r.created_at, r.id LIMIT 1) = 1)))`);
     }
-    if (filter.overlapping) {
+    if (filter.overlapping !== undefined) {
         const busy = (event) => `${event}.deleted_at IS NULL AND ${event}.status <> 'cancelled' AND ${event}.all_day = 0
          AND ${event}.starts_at IS NOT NULL AND ${event}.ends_at IS NOT NULL AND EXISTS (SELECT 1 FROM calendar_entries
            bce JOIN calendars bc ON bc.id = bce.calendar_id WHERE bce.event_id = ${event}.id${account("bc")}
            AND bce.deleted_at IS NULL AND bce.status <> 'cancelled' AND coalesce(bce.own_response, '') <> 'declined'
-           AND coalesce(bce.transparency, '') <> 'transparent')`;
+           AND coalesce(bce.transparency, '') <> 'transparent'
+           AND coalesce(bce.event_type, '') <> 'working-location')`;
         const own = busy("e");
         params.push(longest());
-        clauses.push(`${own} AND EXISTS (SELECT 1 FROM events e2 WHERE e2.id <> e.id AND e2.starts_at < e.ends_at
-         AND e2.ends_at > e.starts_at AND e2.starts_at >= e.starts_at - ? AND ${busy("e2")})`);
+        const clash = `${own} AND EXISTS (SELECT 1 FROM events e2 WHERE e2.id <> e.id AND e2.starts_at < e.ends_at
+         AND e2.ends_at > e.starts_at AND e2.starts_at >= e.starts_at - ? AND ${busy("e2")})`;
+        clauses.push(filter.overlapping ? clash : `NOT (${clash})`);
     }
     const limit = filter.limit ?? 100;
     const offset = filter.offset ?? 0;

package/package.json

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