@wirecat/cli-core 0.357.0 → 0.359.0

package/CHANGELOG.md

@@ -7,6 +7,32 @@ shape of this file.
 
 ## Unreleased
 
+## 0.359.0 — 19.10.2026
+
+### Fixed
+
+- **The first `serve` after an upgrade no longer locks other commands out of the store while it re-keys chats.**
+  A pushed batch's `rekeys` were saved one transaction each, back to back, so another command waited for the write
+  lock as long as the re-keys ran: up to 3.4 s for 5,000 re-keys on a synthetic 10,000-chat store. They now go
+  through the new `store.chats.rekeyChats` in passes of one transaction, each holding the lock for about 50 ms with
+  a pause after it. Each re-key keeps its own savepoint, privacy merge and account scope, and a refused one still
+  warns and leaves the others applied. Once the store is about to close (`Saving.closing`, which `connected`
+  aborts) or refuses a whole pass (closed, busy past its timeout), every re-key still queued, in any batch, is given
+  up with one warning: "N chat re-keys not applied yet; the next serve applies them", and one
+  `rekeys_not_applied` event whose new `counts` field (`WarningEvent.counts`) holds N. Before, a messenger that sends
+  each re-key as its own batch (wa) got one `store_not_written` per chat left. `ChatsStore` gains `rekeyChats`, so a
+  hand-written `ChatsStore` must add it.
+
+## 0.358.0 — 19.10.2026
+
+### Added
+
+- **Meeting transcripts in bounded context reads:** `ContextSource.kind` accepts `meeting`; the native
+  reader returns current transcript cue references with `timeKind: "meeting-start"`. Account/time scope,
+  cursor validation, read-only snapshots and pre-hydration byte limits apply. Deleted/superseded and
+  queued cues are excluded; missing indexes and unknown archive coverage remain explicit. Hosts must
+  opt in to meeting sources; the reader does not fetch recordings, fill indexes or infer project links.
+
 ## 0.357.0 — 19.10.2026
 
 ### Added

package/dist/cli/meeting-communications.d.ts

@@ -37,7 +37,7 @@ export declare const mapPreparationCommunications: ({ items, ...section }: Meeti
         title: string | null;
         url: string | null;
         text: string;
-        timeKind: "sent" | "source-modified" | "stored-update";
+        timeKind: "sent" | "source-modified" | "stored-update" | "meeting-start";
         revision: number | null;
         selectionId: string;
         textTruncated: boolean;

package/dist/cli/messenger/context.js

@@ -194,6 +194,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
     const adapter = observed(flooded(connection, memory, { name: name ?? app.command, warn: renderer.warn, pacer }), events);
     const pending = new Set();
     const announcing = new Set();
+    const closing = new AbortController();
     const saving = self === null
         ? adapter
         : stored(adapter, {
@@ -204,6 +205,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             events,
             pending,
             announcing,
+            closing: closing.signal,
             ...(deletedWithoutChat ? { deletedWithoutChat } : {}),
             rekeyed: (from, to) => rekeyRecipients(app, settings.profile, env, renderer.warn, from, to),
             recipientIds: () => (new RecipientList(recipientsPathFor(app, settings.profile, env), app.command).read() ?? []).flatMap((recipient) => [recipient.id, ...(recipient.partnerId ? [recipient.partnerId] : [])]),
@@ -230,6 +232,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
                         renderer.warn(`not saved to the local store: the messenger was still handing on ${what} at exit`);
                     });
                     await settled(new Set([...pending, ...announcing]), SAVES_WAIT_MS);
+                    closing.abort();
                     if (pending.size > 0) {
                         events({ event: "warning", code: "store_not_written", operation: "close" });
                         renderer.warn("not saved to the local store: the last messages were still being written at exit");

package/dist/cli/messenger/stored.d.ts

@@ -21,6 +21,13 @@ export interface Saving {
     };
     /** After a re-key is saved: what outside the store spells the chat id follows it. */
     rekeyed?: (from: Id, to: Id) => void | Promise<void>;
+    /** How long one pass of re-keys may hold the write lock, and the pause after it. */
+    rekeyPacing?: {
+        lockMs: number;
+        pauseMs: number;
+    };
+    /** Aborted just before the store closes: the re-keys still queued are given up, with one warning for them all. */
+    closing?: AbortSignal;
     /**
      * Chat and partner ids this account's recipient list names, told to `storedChats` apart from the stored ones: an
      * entry saved before any chat was stored under its id would otherwise never be re-keyed, and the send guard would
@@ -41,4 +48,4 @@ export interface Saving {
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, namesFromStore, recipientIds, }: Saving) => MessengerAdapter;
+export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing, closing, namesFromStore, recipientIds, }: Saving) => MessengerAdapter;

package/dist/cli/messenger/stored.js

@@ -3,6 +3,7 @@ import { capability, throughWrapper } from "../../ports/messenger.js";
 import { isId, pickPerson } from "../../resolve.js";
 import { codeOf } from "../../sends/guarded.js";
 import { chatIdIn } from "../../services/message-resolution.js";
+const REKEY_PACING = { lockMs: 50, pauseMs: 25 };
 /**
  * The adapter, with what each read answers written to the store. **A failed write never fails the
  * read** — the answer is already here, and it is what was asked for.
@@ -11,9 +12,15 @@ import { chatIdIn } from "../../services/message-resolution.js";
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, namesFromStore, recipientIds, }) => {
+export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing = REKEY_PACING, closing, namesFromStore, recipientIds, }) => {
     let warned = false;
     let recorded = profile === undefined;
+    const notWritten = (operation, error) => {
+        events({ event: "warning", code: "store_not_written", operation });
+        if (!warned)
+            warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`);
+        warned = true;
+    };
     const attempt = async (operation, write) => {
         try {
             const opened = await store();
@@ -28,10 +35,7 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             }
         }
         catch (error) {
-            events({ event: "warning", code: "store_not_written", operation });
-            if (!warned)
-                warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`);
-            warned = true;
+            notWritten(operation, error);
         }
     };
     const save = (operation, writing) => {
@@ -72,6 +76,54 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             return undefined;
         }
     };
+    /**
+     * The first serve after an upgrade re-keys every phone-form chat at once. Back-to-back transactions keep the write
+     * lock so busy that another command waits past `busy_timeout`, so the re-keys go in passes with a pause between.
+     */
+    let rekeysQueued = 0;
+    let rekeyRound = 0;
+    const rekeysOnly = new Set();
+    // wa sends each re-key as its own batch, so a closed store would otherwise refuse, and warn for, every chat left.
+    const giveUpRekeys = () => {
+        rekeyRound += 1;
+        const count = rekeysQueued;
+        rekeysQueued = 0;
+        for (const saving of rekeysOnly)
+            pending?.delete(saving);
+        if (count === 0)
+            return;
+        events({ event: "warning", code: "rekeys_not_applied", operation: "history.rekey", counts: { rekeys: count } });
+        warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`);
+    };
+    closing?.addEventListener("abort", giveUpRekeys, { once: true });
+    const saveRekeys = async (pairs, round) => {
+        let rest = pairs;
+        while (rest.length > 0 && round === rekeyRound) {
+            let pass;
+            try {
+                pass = await (await store())?.chats.rekeyChats(account, rest, rekeyPacing.lockMs);
+            }
+            catch {
+                // Closed at exit or busy past its timeout, the store would refuse every pass after this one too.
+                if (round === rekeyRound)
+                    giveUpRekeys();
+                return;
+            }
+            if (round !== rekeyRound)
+                return;
+            const taken = pass?.taken ?? rest.length;
+            rekeysQueued -= taken;
+            for (const { from, to } of pass?.applied ?? [])
+                await Promise.resolve()
+                    .then(() => rekeyed?.(from, to))
+                    .catch((error) => notWritten("history.rekey", error));
+            for (const { error } of pass?.refused ?? [])
+                notWritten("history.rekey", error);
+            rest = rest.slice(taken);
+            if (rest.length > 0)
+                await new Promise((resolve) => setTimeout(resolve, rekeyPacing.pauseMs));
+        }
+    };
     const saveBatches = (operation, onBatch) => {
         // In order: a batch's messages may belong to chats only an earlier batch named.
         let previous = Promise.resolve();
@@ -87,18 +139,22 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
                     if (chat.title)
                         titles.set(chat.id, chat.title);
             }
-            // Each re-key apart: one refused leaves the chat split, never the batch's history unsaved.
+            const rekeys = batch.rekeys ?? [];
+            const round = rekeyRound;
+            rekeysQueued += rekeys.length;
+            // A refused re-key leaves its chat split, never the others or the batch's history unsaved.
             const saving = previous.then(async () => {
-                for (const { from, to } of batch.rekeys ?? [])
-                    await attempt("history.rekey", async (opened) => {
-                        await opened.chats.rekeyChat(account, from, to);
-                        await rekeyed?.(from, to);
-                    });
+                await saveRekeys(rekeys, round);
                 await attempt(operation, (opened) => fill(opened, account, batch));
             });
             previous = saving;
             pending?.add(saving);
-            void saving.finally(() => pending?.delete(saving));
+            if (onlyRekeys(batch))
+                rekeysOnly.add(saving);
+            void saving.finally(() => {
+                pending?.delete(saving);
+                rekeysOnly.delete(saving);
+            });
             onBatch(batch);
         };
     };
@@ -436,6 +492,7 @@ const titled = (event, titles) => {
     const title = titles.get(event.chatId);
     return title ? { ...event, chatTitle: title } : event;
 };
+const onlyRekeys = (batch) => Object.entries(batch).every(([part, items]) => (part === "rekeys") === (items?.length ?? 0) > 0);
 /**
  * A pushed batch as the store keeps it. No `markChatsLeft`: a push names some chats, never all of them.
  * No `seenAt`: a pushed snapshot may be older than a deletion this store already holds. A chat's votes and stars go

package/dist/context/evidence-response.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator, parseLocator } from "../domain/locator.js";
+import { formatMeetingReference, parseMeetingReference } from "../meetings/index.js";
 import { contextEvidenceRequest, contextSource, } from "./evidence.js";
 export const contextSourceKey = (source) => JSON.stringify([source.kind, source.accountId, source.provider, source.account]);
 export const validateContextEvidencePage = (page, request) => {
@@ -49,9 +50,9 @@ export const validateContextEvidencePage = (page, request) => {
                 fail();
             if (item.revision !== null && (!Number.isSafeInteger(item.revision) || item.revision < 1))
                 fail();
-            if (!["source-modified", "stored-update", "sent"].includes(item.timeKind) ||
-                (source.kind !== "document" && item.timeKind !== "sent") ||
-                (source.kind === "document" && item.timeKind === "sent"))
+            if (source.kind === "document"
+                ? !["source-modified", "stored-update"].includes(item.timeKind)
+                : item.timeKind !== (source.kind === "meeting" ? "meeting-start" : "sent"))
                 fail();
             const text = [item.text, item.title, item.url, item.provider, item.account, item.timeKind];
             if (text.some((value) => value !== null && typeof value !== "string"))
@@ -61,6 +62,15 @@ export const validateContextEvidencePage = (page, request) => {
                 if (!Number.isSafeInteger(id) || id < 1 || item.ref !== `document:${id}`)
                     fail();
             }
+            else if (source.kind === "meeting") {
+                const reference = parseMeetingReference(item.ref);
+                if (reference.accountId !== source.accountId ||
+                    reference.transcriptId === undefined ||
+                    reference.cuePosition === undefined ||
+                    formatMeetingReference(reference) !== item.ref)
+                    fail();
+                text.push(item.ref);
+            }
             else {
                 const locator = parseLocator(item.ref);
                 if (locator.provider !== source.provider ||

package/dist/context/evidence.d.ts

@@ -1,4 +1,4 @@
-export declare const CONTEXT_SOURCE_KINDS: readonly ["message", "mail", "document"];
+export declare const CONTEXT_SOURCE_KINDS: readonly ["message", "mail", "document", "meeting"];
 export interface ContextSource {
     kind: (typeof CONTEXT_SOURCE_KINDS)[number];
     accountId: number;
@@ -27,7 +27,7 @@ export interface ContextEvidenceItem {
     url: string | null;
     text: string;
     at: number;
-    timeKind: "sent" | "source-modified" | "stored-update";
+    timeKind: "sent" | "source-modified" | "stored-update" | "meeting-start";
     updatedAt: number;
     revision: number | null;
 }

package/dist/context/evidence.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
-export const CONTEXT_SOURCE_KINDS = ["message", "mail", "document"];
+export const CONTEXT_SOURCE_KINDS = ["message", "mail", "document", "meeting"];
 export const contextCursorScope = (request) => createHash("sha256")
     .update(JSON.stringify([
     "context-evidence-v1",

package/dist/runs/events.d.ts

@@ -34,6 +34,8 @@ export interface WarningEvent {
     operation?: string;
     /** Field paths and types for an answer of an unexpected shape — built without the values. */
     detail?: string;
+    /** How many things the warning is about, per field: `{ rekeys: 199 }`. */
+    counts?: Record<string, number>;
 }
 /** A read answered locally, without asking the messenger, and why. */
 export interface CacheEvent {

package/dist/runs/events.js

@@ -10,7 +10,8 @@ export const providerErrorKey = (value) => typeof value === "string" && /^[A-Za-
  */
 export const renderEvent = (event) => {
     if (event.event === "warning") {
-        return [`${MARK.warning} ${(event.operation ?? "").padEnd(16)} ${event.code}`, event.detail]
+        const counts = Object.entries(event.counts ?? {}).map(([field, count]) => `${count} ${field}`);
+        return [`${MARK.warning} ${(event.operation ?? "").padEnd(16)} ${event.code}`, ...counts, event.detail]
             .filter(Boolean)
             .join("  ");
     }

package/dist/store/chats.d.ts

@@ -1,6 +1,6 @@
 import type { ChannelTagMatch } from "../domain/channel-tags.js";
 import type { Chat, ChatKind, ChatUpdate, Id, Page } from "../domain/models.js";
-import { type ChatRekey } from "./sqlite/chat-rekey.js";
+import { type ChatRekey, type ChatRekeys } from "./sqlite/chat-rekey.js";
 import type { ChatMetadata, LeftChat } from "./sqlite/chats.js";
 import type { ChatCompleteness } from "./sqlite/completeness.js";
 import type { StoreContext } from "./sqlite/open.js";
@@ -39,6 +39,14 @@ export interface ChatsStore {
      * `to`. Replaying it changes nothing.
      */
     rekeyChat(key: AccountKey, from: Id, to: Id): Promise<ChatRekey>;
+    /**
+     * `rekeyChat` for a run of pairs, in order, in one transaction that ends once it has held the write lock for
+     * `lockMs`: `taken` says how many it got to. A pair refused is in `refused`, and the others still apply.
+     */
+    rekeyChats(key: AccountKey, pairs: readonly {
+        from: Id;
+        to: Id;
+    }[], lockMs: number): Promise<ChatRekeys>;
     /**
      * The chats marked left and the messages they hold, each named in `left`; with `clear`, deletes them and all under
      * them — `left` is then what was deleted.

package/dist/store/chats.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { keysOver } from "./keys.js";
-import { rekeyChat } from "./sqlite/chat-rekey.js";
+import { rekeyChat, rekeyChats } from "./sqlite/chat-rekey.js";
 import * as chatQueries from "./sqlite/chats.js";
 import * as completeness from "./sqlite/completeness.js";
 import * as reads from "./sqlite/reads.js";
@@ -49,6 +49,14 @@ export const chatsStoreOver = (context) => {
                 return { outcome: "unchanged", messages: 0, duplicates: 0 };
             return write(database, () => rekeyChat(context, key, accountKey, from, to));
         },
+        rekeyChats: async (key, pairs, lockMs) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined) {
+                const rekey = { outcome: "unchanged", messages: 0, duplicates: 0 };
+                return { taken: pairs.length, applied: pairs.map((pair) => ({ ...pair, rekey })), refused: [] };
+            }
+            return write(database, () => rekeyChats(context, key, accountKey, pairs, lockMs));
+        },
         leftChats: async (key, { clear = false } = {}) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)

package/dist/store/exports.d.ts

@@ -16,7 +16,7 @@ export { accountGroupsOf } from "./sqlite/account-groups.js";
 export type { AdminStoreRequest, AdminStoreResult } from "./sqlite/admin-statistics.js";
 export { type AttachmentTextEntry, type AttachmentView, attachmentColumns, type FileAttachment, resetAttachmentWords, type TextOrigin, } from "./sqlite/attachment-texts.js";
 export { pendingNormalization } from "./sqlite/backfill.js";
-export type { ChatRekey } from "./sqlite/chat-rekey.js";
+export type { ChatRekey, ChatRekeys } from "./sqlite/chat-rekey.js";
 export { CHAT_COLUMNS, titlePart } from "./sqlite/chats.js";
 export { CHAT_LIST_KEY, type ChatCompleteness, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";

package/dist/store/sqlite/chat-rekey.d.ts

@@ -8,8 +8,30 @@ export interface ChatRekey {
     /** Messages both chats held under one id; the kept chat's copy stays. */
     duplicates: number;
 }
+export interface ChatRekeys {
+    /** How many of the pairs this pass got to, from the first: the rest wait for another pass. */
+    taken: number;
+    applied: {
+        from: Id;
+        to: Id;
+        rekey: ChatRekey;
+    }[];
+    refused: {
+        from: Id;
+        to: Id;
+        error: unknown;
+    }[];
+}
 /**
  * A chat the messenger now names by another id: renamed in place, or merged into the row already stored under the
  * new id's twin. Replaying it, or naming a chat the store does not hold, changes nothing. Runs inside `write`.
  */
 export declare const rekeyChat: (context: StoreContext, key: AccountKey, accountKey: number, from: Id, to: Id) => ChatRekey;
+/**
+ * Re-keys in order, each in its own savepoint so a refused one leaves the others applied, and stops once `lockMs` has
+ * passed: the caller lets the other processes at the write lock before the next pass. Runs inside `write`.
+ */
+export declare const rekeyChats: (context: StoreContext, key: AccountKey, accountKey: number, pairs: readonly {
+    from: Id;
+    to: Id;
+}[], lockMs: number) => ChatRekeys;

package/dist/store/sqlite/chat-rekey.js

@@ -4,6 +4,7 @@ import { purgeChats, stricterPrivacy } from "./chats.js";
 import { pointerPairs } from "./entity-types.js";
 import { tombstone } from "./messages.js";
 import { targetKey } from "./notes.js";
+import { write } from "./transaction.js";
 const chatRow = (context, accountKey, chatId) => context.database.prepare("SELECT * FROM chats WHERE account_id = ? AND external_id = ?").get(accountKey, chatId);
 /**
  * Re-points every `<x>_type = type` pointer from one row to another. A pointer the kept row already has (a unique
@@ -185,3 +186,27 @@ export const rekeyChat = (context, key, accountKey, from, to) => {
     renameText(context, key, accountKey, from, to);
     return { outcome: twin ? "merged" : "renamed", ...moved };
 };
+/**
+ * Re-keys in order, each in its own savepoint so a refused one leaves the others applied, and stops once `lockMs` has
+ * passed: the caller lets the other processes at the write lock before the next pass. Runs inside `write`.
+ */
+export const rekeyChats = (context, key, accountKey, pairs, lockMs) => {
+    const done = { taken: 0, applied: [], refused: [] };
+    const started = performance.now();
+    for (const { from, to } of pairs) {
+        if (done.taken > 0 && performance.now() - started >= lockMs)
+            break;
+        done.taken += 1;
+        try {
+            done.applied.push({
+                from,
+                to,
+                rekey: write(context.database, () => rekeyChat(context, key, accountKey, from, to)),
+            });
+        }
+        catch (error) {
+            done.refused.push({ from, to, error });
+        }
+    }
+    return done;
+};

package/dist/store/sqlite/context-evidence.js

@@ -3,6 +3,7 @@ import { contextCursorScope, contextEvidenceRequest, } from "../../context/evide
 import { formatLocator } from "../../domain/locator.js";
 import { NORMALIZER_VERSION, normalize } from "../normalize.js";
 import { contextDocumentTime, contextDocumentTimeKind, contextDocumentUrl } from "./context-document-source.js";
+import { readMeetingContextEvidence } from "./context-meeting-source.js";
 import { drainEmailIndex } from "./email-index.js";
 import { drainNoteIndex } from "./note-index.js";
 import { read } from "./transaction.js";
@@ -52,10 +53,12 @@ export const contextEvidenceOver = ({ database }) => ({
     async read(original) {
         const request = contextEvidenceRequest(original);
         const { source, words, after, before, limit, maxReadBytes, cursor, signal } = request;
+        if (source.kind === "meeting")
+            return readMeetingContextEvidence(database, request);
+        const corpus = corpora[source.kind];
         const scope = contextCursorScope({ source, query: request.query, after, before });
         signal?.throwIfAborted();
         return read(database, () => {
-            const corpus = corpora[source.kind];
             const coverage = {
                 available: false,
                 index: "unknown",

package/dist/store/sqlite/context-meeting-source.d.ts

@@ -0,0 +1,6 @@
+import { type ContextEvidencePage, type contextEvidenceRequest } from "../../context/evidence.js";
+import type { CacheDatabase } from "../driver.js";
+type Request = ReturnType<typeof contextEvidenceRequest>;
+/** Transcript cues keep their retained revision reference; a meeting title alone is not a transcript match. */
+export declare const readMeetingContextEvidence: (database: CacheDatabase, request: Request) => ContextEvidencePage;
+export {};

package/dist/store/sqlite/context-meeting-source.js

@@ -0,0 +1,97 @@
+import { CliError } from "@wirecat/cli-base";
+import { contextCursorScope } from "../../context/evidence.js";
+import { normalize } from "../normalize.js";
+import { read } from "./transaction.js";
+/** Transcript cues keep their retained revision reference; a meeting title alone is not a transcript match. */
+export const readMeetingContextEvidence = (database, request) => {
+    const { source, words, after, before, limit, maxReadBytes, cursor, signal } = request;
+    signal?.throwIfAborted();
+    return read(database, () => {
+        const coverage = {
+            available: false,
+            index: "unknown",
+            hasMore: false,
+            hasUndated: false,
+            completeness: "unknown",
+            matching: "literal-words",
+            consistency: "snapshot-per-page",
+        };
+        const empty = () => ({ source, items: [], next: null, readBytes: 0, coverage });
+        const scope = [source.accountId, source.provider, source.account];
+        if (!database.prepare("SELECT 1 FROM accounts WHERE id=? AND provider=? AND external_id=?").get(...scope))
+            return empty();
+        coverage.available = true;
+        const base = `FROM meeting_transcript_rows r
+      JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id
+      JOIN meetings m ON m.id=t.meeting_id
+      JOIN accounts a ON a.id=m.account_id
+      WHERE m.account_id=? AND a.provider=? AND a.external_id=?
+      AND m.deleted_at IS NULL AND t.deleted_at IS NULL AND t.superseded_at IS NULL`;
+        coverage.hasUndated = Boolean(database.prepare(`SELECT 1 ${base} AND m.started_at IS NULL LIMIT 1`).get(...scope));
+        if (!database.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='meeting_words'").get()) {
+            coverage.index = "missing";
+            return empty();
+        }
+        coverage.index = database
+            .prepare(`SELECT 1 ${base} AND m.started_at>=? AND m.started_at<?
+        AND EXISTS(SELECT 1 FROM meeting_index_pending p
+        WHERE p.indexable_type='meeting_transcript_row' AND p.id=r.id) LIMIT 1`)
+            .get(...scope, after, before)
+            ? "pending"
+            : "ready";
+        const reference = "'meeting:'||m.account_id||'/'||m.id||'/'||t.id||'/'||r.position";
+        const selection = `SELECT r.id,m.title,r.text,a.provider,a.external_id AS account,
+      m.started_at AS at,max(m.updated_at,t.updated_at,r.created_at) AS updated_at,
+      ${reference} AS ref ${base} AND m.started_at>=? AND m.started_at<?
+      AND (r.id*4+1) IN (SELECT rowid FROM meeting_words WHERE meeting_words MATCH ?)
+      AND NOT EXISTS(SELECT 1 FROM meeting_index_pending p
+        WHERE p.indexable_type='meeting_transcript_row' AND p.id=r.id)
+      ${cursor ? "AND (m.started_at<? OR (m.started_at=? AND r.id<?))" : ""}
+      ORDER BY m.started_at DESC,r.id DESC LIMIT ?`;
+        const params = [
+            ...scope,
+            after,
+            before,
+            words.map((word) => `normalized_text:"${normalize(word)}"`).join(" AND "),
+        ];
+        if (cursor)
+            params.push(cursor.at, cursor.at, cursor.id);
+        params.push(limit + 1);
+        const probe = database
+            .prepare(`SELECT coalesce(sum(length(CAST(coalesce(title,'') AS BLOB))+
+        length(CAST(text AS BLOB))+length(CAST(provider AS BLOB))+
+        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start')),0) AS bytes FROM (${selection})`)
+            .get(...params);
+        const readBytes = Number(probe?.bytes);
+        if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
+            throw new CliError("validation_error", "meeting context evidence exceeds maxReadBytes before hydration", {
+                reason: "context.read-budget",
+            });
+        signal?.throwIfAborted();
+        const rows = database.prepare(selection).all(...params);
+        signal?.throwIfAborted();
+        coverage.hasMore = rows.length > limit;
+        const selected = rows.slice(0, limit);
+        const last = selected.at(-1);
+        return {
+            source,
+            readBytes,
+            coverage,
+            next: coverage.hasMore && last
+                ? { at: Number(last.at), id: Number(last.id), scope: contextCursorScope(request) }
+                : null,
+            items: selected.map((row) => ({
+                ref: String(row.ref),
+                provider: String(row.provider),
+                account: String(row.account),
+                title: row.title === null ? null : String(row.title),
+                url: null,
+                text: String(row.text),
+                at: Number(row.at),
+                timeKind: "meeting-start",
+                updatedAt: Number(row.updated_at),
+                revision: null,
+            })),
+        };
+    });
+};

package/package.json

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