@wirecat/cli-core 0.526.0 → 0.528.0

package/CHANGELOG.md

@@ -7,6 +7,41 @@ shape of this file.
 
 ## Unreleased
 
+## 0.528.0 — 01.11.2026
+
+### Added
+
+- **Every profile keeps its messenger library's warnings, and `doctor` counts the last day's.** A message the
+  library could not decrypt used to leave no trace unless the CLI's own log variable was set. `providerLogPathFor(app,
+  profile, env)` names `<state>/provider-log/<profile>.jsonl`; `openProviderLog(path)` makes it private (mode 600)
+  and keeps it under 1 MB with one older file, so an engine in another process can append to the path it is given;
+  `writeProviderWarning(path, kind, message)` appends from Node. A line is `{"time","level","kind"?,"message"}`, the
+  shape zerolog writes; `kind` is the adapter's tag. The adapter masks phone numbers, ids of people and text before
+  writing. `doctor` answers `provider_log: { path, last_day: { total, kinds } }` and checks the file is private.
+
+## 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

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/index.d.ts

@@ -23,6 +23,7 @@ export { NO_RULES, NO_TASKS, NOT_ALLOWED, ONLY_TASK, type Replied, type Replier,
 export { repliesStatePathFor } from "../replies/state.js";
 export { type CacheEvent, type DiagnosticEvent, type EventSink, providerErrorKey, type RequestEvent, renderEvent, type WarningEvent, } from "../runs/events.js";
 export { CORE_LOG_EVENTS } from "../runs/log-events.js";
+export { openProviderLog, PROVIDER_LOG_BYTES, type ProviderWarnings, providerLogPathFor, providerWarnings, writeProviderWarning, } from "../runs/provider-log.js";
 export { crashOf, type Recording, type RecordingOptions, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, type RunContext, type RunMetadata, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
 export { runContextOf, secretInput } from "../runs/run-context.js";

package/dist/cli/index.js

@@ -19,6 +19,7 @@ export { NO_RULES, NO_TASKS, NOT_ALLOWED, ONLY_TASK, replyTo } from "../replies/
 export { repliesStatePathFor } from "../replies/state.js";
 export { providerErrorKey, renderEvent, } from "../runs/events.js";
 export { CORE_LOG_EVENTS } from "../runs/log-events.js";
+export { openProviderLog, PROVIDER_LOG_BYTES, providerLogPathFor, providerWarnings, writeProviderWarning, } from "../runs/provider-log.js";
 export { crashOf, recorded, startRecording, wasSettled, } from "../runs/recording.js";
 export { findRun, KEEP_RUNS_FOR_DAYS, listRuns, pruneRuns, readEvents, runsDirFor, runtime, startRun, } from "../runs/run.js";
 export { runContextOf, secretInput } from "../runs/run-context.js";

package/dist/cli/messenger/doctor-command.js

@@ -5,6 +5,7 @@ import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { engineStates } from "../../attachments/extract.js";
 import { providerErrorKey } from "../../runs/events.js";
+import { providerLogPathFor, providerWarnings } from "../../runs/provider-log.js";
 import { listRuns, runsDirFor, runtime } from "../../runs/run.js";
 import { FloodMemory, floodPathFor } from "../../sends/flood.js";
 import { SendJournal, sendsPathFor } from "../../sends/journal.js";
@@ -20,6 +21,7 @@ import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
 import { privateFiles, withSqliteSidecars } from "./private-files.js";
 import { buildReport, reportFileName } from "./report.js";
+import { DAY_MS } from "./serve-members.js";
 import { storeSummary } from "./store-maintenance-command.js";
 /**
  * The state this installation is in, read from disk and **never from the messenger unless
@@ -121,6 +123,7 @@ const rememberedOf = (report) => report.account?.remembered ?? undefined;
  * What `doctor` answers, as data. A configuration that will not load is a field, not an exception:
  * then there is no renderer from the settings, and the caller renders with the defaults.
  */
+const providerLogState = ({ path, total, kinds }) => ({ path, last_day: { total, kinds } });
 const diagnose = async (command, messenger) => {
     const { app, provider } = messenger;
     const env = environmentOf(command).env ?? process.env;
@@ -183,8 +186,9 @@ const diagnose = async (command, messenger) => {
     const store = storePath(env);
     const sends = sendsPathFor(app, profile, env);
     const flood = floodPathFor(app, profile, env);
+    const providerLog = providerLogPathFor(app, profile, env);
     const files = privateFiles({
-        files: [...own.files, ...withSqliteSidecars(store), sends, flood],
+        files: [...own.files, ...withSqliteSidecars(store), sends, flood, providerLog],
         // A folder the owner chose with MESSAGING_STORE may rightly be shared, like the home folder itself.
         dirs: [
             ...own.dirs,
@@ -192,6 +196,7 @@ const diagnose = async (command, messenger) => {
             dirname(sends),
             dirname(flood),
             runsDirFor(app, env),
+            dirname(providerLog),
         ],
     });
     return {
@@ -209,6 +214,7 @@ const diagnose = async (command, messenger) => {
             readers: engineStates(),
             sends: sendsState(new SendJournal(sendsPathFor(app, profile, env))),
             flood: floodState(new FloodMemory(flood)),
+            provider_log: providerLogState(providerWarnings(providerLog, new Date(Date.now() - DAY_MS))),
             runs: { directory: runsDirFor(app, env), kept: listRuns(runsDirFor(app, env)).length },
             // The messenger's own block keeps the keys it gives: some of them are file paths.
             files: filesReport(files),

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/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/runs/provider-log.d.ts

@@ -0,0 +1,22 @@
+import type { AppIdentity } from "../ports/app.js";
+/**
+ * The messenger library's warnings for one profile, always kept: a message it failed to decrypt is lost without a
+ * trace otherwise. One JSON object per line, `{"time","level","kind"?,"message"}` — the shape zerolog writes, so an
+ * engine in another process appends to the file directly. **No phone number, id of a person or message text**: the
+ * adapter or its engine masks before writing. `kind` is the adapter's tag (`decrypt`), counted by `doctor`.
+ */
+export declare const providerLogPathFor: (app: AppIdentity, profile: string, env?: NodeJS.ProcessEnv) => string;
+export declare const PROVIDER_LOG_BYTES: number;
+/**
+ * The file, private and under its cap, ready for an engine to append to. The cap is kept here rather than by the
+ * writer, because an engine in another language appends without knowing it: one older file is kept.
+ */
+export declare const openProviderLog: (path: string, maxBytes?: number) => string;
+export declare const writeProviderWarning: (path: string, kind: string, message: string, now?: Date) => void;
+export interface ProviderWarnings {
+    path: string;
+    total: number;
+    kinds: Record<string, number>;
+}
+/** Warnings since `since`, by kind; a line without one counts as `other`, a line that is not JSON is skipped. */
+export declare const providerWarnings: (path: string, since: Date) => ProviderWarnings;

package/dist/runs/provider-log.js

@@ -0,0 +1,55 @@
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolvePaths } from "@wirecat/cli-base";
+/**
+ * The messenger library's warnings for one profile, always kept: a message it failed to decrypt is lost without a
+ * trace otherwise. One JSON object per line, `{"time","level","kind"?,"message"}` — the shape zerolog writes, so an
+ * engine in another process appends to the file directly. **No phone number, id of a person or message text**: the
+ * adapter or its engine masks before writing. `kind` is the adapter's tag (`decrypt`), counted by `doctor`.
+ */
+export const providerLogPathFor = (app, profile, env = process.env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "provider-log", `${profile}.jsonl`);
+export const PROVIDER_LOG_BYTES = 1024 * 1024;
+const previousOf = (path) => path.replace(/\.jsonl$/, ".1.jsonl");
+/**
+ * The file, private and under its cap, ready for an engine to append to. The cap is kept here rather than by the
+ * writer, because an engine in another language appends without knowing it: one older file is kept.
+ */
+export const openProviderLog = (path, maxBytes = PROVIDER_LOG_BYTES) => {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    if (existsSync(path) && statSync(path).size >= maxBytes)
+        renameSync(path, previousOf(path));
+    closeSync(openSync(path, "a", 0o600));
+    chmodSync(path, 0o600);
+    return path;
+};
+export const writeProviderWarning = (path, kind, message, now = new Date()) => {
+    openProviderLog(path);
+    appendFileSync(path, `${JSON.stringify({ time: now.toISOString(), level: "warn", kind, message })}\n`);
+};
+/** Warnings since `since`, by kind; a line without one counts as `other`, a line that is not JSON is skipped. */
+export const providerWarnings = (path, since) => {
+    const kinds = {};
+    let total = 0;
+    for (const file of [previousOf(path), path]) {
+        if (!existsSync(file))
+            continue;
+        for (const line of readFileSync(file, "utf8").split("\n")) {
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const at = typeof entry.time === "string" ? Date.parse(entry.time) : Number.NaN;
+            if (!(at >= since.getTime()))
+                continue;
+            const kind = typeof entry.kind === "string" && entry.kind ? entry.kind : "other";
+            kinds[kind] = (kinds[kind] ?? 0) + 1;
+            total++;
+        }
+    }
+    return { path, total, kinds };
+};

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.526.0",
+  "version": "0.528.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",