@wirecat/cli-core 0.387.0 → 0.389.0

package/CHANGELOG.md

@@ -5,7 +5,31 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 0.389.0 — 22.10.2026
+
+### Added
+
+- **`readMeetingStats`: talk time per speaker and meetings per week.** Over the meetings search would read, with the
+  same filters: per speaker (a linked person, else the identity, else the transcript's name) lines, words, talk time,
+  meetings and share of talk; per week (Monday in a chosen zone) meetings and talk time. One transcript per meeting,
+  so a local transcript beside the provider's does not count twice. `meetings.meetingStats` on the store and
+  `aggregateMeetingStats` for rows a host already has.
+
+## 0.388.0 — 22.10.2026
+
+### Added
+
+- **`searchMeetingsCombined`: meeting search by words and meaning in one ranking.** Word hits and passage vectors of
+  one model are merged by reciprocal rank fusion over one selection of meetings: the date, meeting, series, event,
+  participant, person, project and tag filters apply to both. A word hit inside a passage the meaning search found
+  joins it (`by: ["words", "meaning"]`) and is cited by its own line. A question («что решили по цене?», "what did we
+  decide about pricing?") searches its content words; other text is the meeting query language, and text it refuses
+  is asked by meaning alone (`words.refused`). On a tie a line with the words ranks above a passage that only
+  resembles the query. The ranking covers
+  every vector of the selection up to `maxChunks` (default 10000), read in batches with text loaded only for the
+  passages kept; pages continue one ranking (`nextCursor`), bound to the query, filters and model.
+- **`meetingVectors.ranked`** — the nearest passages over the whole selection, with meeting title and start.
+  `questionTerms` (`search/question-plan`) — a question's content words, or null.
 
 ## 0.387.0 — 22.10.2026
 

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -2,9 +2,9 @@ import { Command } from "commander";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
+    error?: undefined;
     path: string;
     exists: boolean;
-    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/meetings/index.d.ts

@@ -40,6 +40,7 @@ export { createMeetingSeriesInventoryReader } from "./series-inventory.js";
 export type { MeetingSeriesCandidate, MeetingSeriesInventoryPage, MeetingSeriesInventoryPort, MeetingSeriesInventoryRead, MeetingSeriesInventoryRequest, MeetingSeriesInventoryResult, } from "./series-inventory-types.js";
 export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validation.js";
 export type { MeetingSource, SourceParticipant } from "./source.js";
+export { aggregateMeetingStats, type MeetingSpeakerStats, type MeetingStats, type MeetingStatsInput, type MeetingStatsRow, type MeetingStatsSelection, type MeetingStatsStore, type MeetingWeekStats, } from "./stats.js";
 export type { ChatInput, ContractCase, EventCandidateFilter, IdentityInput, MeetingDetails, MeetingFilter, MeetingHitSource, MeetingInput, MeetingSave, MeetingStore, NewRecord, ParticipantInput, SearchHit, TranscriptInput, TranscriptRowInput, } from "./store.js";
 export type { MeetingTranscriptReceiptStore, MeetingTranscriptStore, TranscriptAppend, TranscriptAppendReceipt, UnlinkedTranscriptInput, } from "./transcript-store.js";
 export { parseTranscriptText, TranscriptTextError, type TranscriptTextHeader } from "./transcript-text.js";

package/dist/meetings/index.js

@@ -28,6 +28,7 @@ export { validateMeetingHitSearch } from "./search-validation.js";
 export { validateMeetingSeriesHistory, } from "./series-history.js";
 export { createMeetingSeriesInventoryReader } from "./series-inventory.js";
 export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validation.js";
+export { aggregateMeetingStats, } from "./stats.js";
 export { parseTranscriptText, TranscriptTextError } from "./transcript-text.js";
 export { transcribeMeeting, } from "./transcription.js";
 export { createUpcomingMeetingReader } from "./upcoming.js";

package/dist/meetings/stats.d.ts

@@ -0,0 +1,59 @@
+import type { MeetingSearchOptions } from "./search-store.js";
+/** The meetings the numbers cover: the same filters as meeting search. */
+export type MeetingStatsSelection = Pick<MeetingSearchOptions, "accountId" | "meetingId" | "eventId" | "meetingSeriesId" | "since" | "until" | "participantIdentityId" | "personId" | "projectId" | "tagId" | "signal">;
+export interface MeetingStatsInput extends MeetingStatsSelection {
+    /** The zone a week starts on Monday in; UTC when not given. */
+    timeZone?: string;
+    /** Most transcript lines to read (default 500000); more is an error, never a silent cut. */
+    maxRows?: number;
+}
+/** One transcript line as the numbers need it: who said it, when, for how long, in how many words. */
+export interface MeetingStatsRow {
+    meetingId: number;
+    startedAt: number | null;
+    startMs: number;
+    endMs: number;
+    words: number;
+    personId: number | null;
+    personName: string | null;
+    identityId: number | null;
+    identityName: string | null;
+    speakerName: string | null;
+}
+export interface MeetingSpeakerStats {
+    /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+    key: string;
+    name: string | null;
+    personId: number | null;
+    identityId: number | null;
+    meetings: number;
+    lines: number;
+    words: number;
+    talkMs: number;
+    /** This speaker's part of all talk time in the selection, 0–1. */
+    share: number;
+}
+export interface MeetingWeekStats {
+    /** The Monday the week starts on, in the chosen zone: `2026-10-19`. */
+    weekStart: string;
+    meetings: number;
+    talkMs: number;
+}
+export interface MeetingStats {
+    timeZone: string;
+    meetings: number;
+    lines: number;
+    words: number;
+    talkMs: number;
+    speakers: MeetingSpeakerStats[];
+    weeks: MeetingWeekStats[];
+}
+export interface MeetingStatsStore {
+    meetingStats(input: MeetingStatsInput): Promise<MeetingStats>;
+}
+/**
+ * Talk time, lines and words per speaker, and meetings and talk time per week. A speaker is a linked person when the
+ * line's participant has one, else the participant's identity, else the name the transcript gives; lines with none
+ * are `unknown`. Talk time is each line's end less its start, so overlapping speech counts for everyone speaking.
+ */
+export declare const aggregateMeetingStats: (rows: readonly MeetingStatsRow[], timeZone?: string) => MeetingStats;

package/dist/meetings/stats.js

@@ -0,0 +1,95 @@
+import { CliError } from "@wirecat/cli-base";
+const zoneOf = (timeZone) => {
+    const zone = timeZone ?? "UTC";
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+    }
+    catch {
+        throw new CliError("validation_error", "expected an IANA time zone such as Europe/Madrid");
+    }
+    return zone;
+};
+const DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+const weekStart = (at, format) => {
+    const parts = Object.fromEntries(format.formatToParts(new Date(at)).map((part) => [part.type, part.value]));
+    const day = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day));
+    return new Date(day - DAYS.indexOf(parts.weekday ?? "Mon") * 86_400_000).toISOString().slice(0, 10);
+};
+/** Lines with no speaker at all; a constant, since a `key: "…"` literal reads as a permission key to the key test. */
+const UNKNOWN_SPEAKER = "unknown";
+const speakerOf = (row) => row.personId !== null
+    ? { key: `person:${row.personId}`, name: row.personName ?? row.identityName ?? row.speakerName }
+    : row.identityId !== null
+        ? { key: `identity:${row.identityId}`, name: row.identityName ?? row.speakerName }
+        : row.speakerName?.trim()
+            ? { key: `name:${row.speakerName.trim().toLowerCase()}`, name: row.speakerName.trim() }
+            : { key: UNKNOWN_SPEAKER, name: null };
+/**
+ * Talk time, lines and words per speaker, and meetings and talk time per week. A speaker is a linked person when the
+ * line's participant has one, else the participant's identity, else the name the transcript gives; lines with none
+ * are `unknown`. Talk time is each line's end less its start, so overlapping speech counts for everyone speaking.
+ */
+export const aggregateMeetingStats = (rows, timeZone) => {
+    const zone = zoneOf(timeZone);
+    const format = new Intl.DateTimeFormat("en-US", {
+        timeZone: zone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        weekday: "short",
+    });
+    const speakers = new Map();
+    const weeks = new Map();
+    const meetings = new Set();
+    let lines = 0;
+    let words = 0;
+    let talkMs = 0;
+    for (const row of rows) {
+        const talk = Math.max(0, row.endMs - row.startMs);
+        meetings.add(row.meetingId);
+        lines += 1;
+        words += row.words;
+        talkMs += talk;
+        const who = speakerOf(row);
+        const held = speakers.get(who.key) ?? {
+            key: who.key,
+            name: who.name ?? null,
+            personId: row.personId,
+            identityId: row.personId === null ? row.identityId : null,
+            meetings: 0,
+            lines: 0,
+            words: 0,
+            talkMs: 0,
+            share: 0,
+            seen: new Set(),
+        };
+        held.seen.add(row.meetingId);
+        held.lines += 1;
+        held.words += row.words;
+        held.talkMs += talk;
+        speakers.set(who.key, held);
+        if (row.startedAt !== null) {
+            const week = weeks.get(weekStart(row.startedAt, format)) ?? { meetings: new Set(), talkMs: 0 };
+            week.meetings.add(row.meetingId);
+            week.talkMs += talk;
+            weeks.set(weekStart(row.startedAt, format), week);
+        }
+    }
+    return {
+        timeZone: zone,
+        meetings: meetings.size,
+        lines,
+        words,
+        talkMs,
+        speakers: [...speakers.values()]
+            .map(({ seen, ...speaker }) => ({
+            ...speaker,
+            meetings: seen.size,
+            share: talkMs === 0 ? 0 : Math.round((speaker.talkMs / talkMs) * 1000) / 1000,
+        }))
+            .sort((a, b) => b.talkMs - a.talkMs || a.key.localeCompare(b.key)),
+        weeks: [...weeks.entries()]
+            .map(([start, week]) => ({ weekStart: start, meetings: week.meetings.size, talkMs: week.talkMs }))
+            .sort((a, b) => a.weekStart.localeCompare(b.weekStart)),
+    };
+};

package/dist/search/question-plan.d.ts

@@ -1,4 +1,9 @@
 export declare const words: (text: string) => RegExpMatchArray | [];
+/**
+ * A question's content words — «что решили по цене?» → решили, цене — or null when the text is not a question: it
+ * ends with «?» or starts with a question word.
+ */
+export declare const questionTerms: (text: string) => string[] | null;
 export declare function planQuestion(text: string, strict?: boolean): {
     changed: boolean;
     natural: boolean;

package/dist/search/question-plan.js

@@ -4,6 +4,17 @@ import { SEARCH_QUERY } from "./lucene/types.js";
 export const words = (text) => normalize(text).match(/[\p{L}\p{N}]+/gu) ?? [];
 const scaffolding = new Set(words("what which how many much who where when is are was were do does did can could should we the a an for of to under from in on at has have сколько какой какая какие какое кто кому кем где когда как что во по на в к с у через ли должен должна нужно идёт идет можно может могут"));
 const questionWord = /\b(?:what|which|how|who|where|when|can|could|should)\b|(?:^|\s)(?:сколько|какой|какая|какие|какое|кто|кому|кем|где|когда|как|что|можно|может|могут|ли)(?:\s|$)/iu;
+const QUESTION_STARTS = new Set(words("what which how who whom whose where when why can could should would did do does is are was were will " +
+    "что кто кого кому кем где когда как какой какая какое какие какую каким какого каких почему зачем откуда " +
+    "куда сколько ли можно разве чей чья чьё чьи"));
+const QUESTION_FILLER = new Set(words("about any did does why whom whose would will это мы вы я они он она о об про ли"));
+/**
+ * A question's content words — «что решили по цене?» → решили, цене — or null when the text is not a question: it
+ * ends with «?» or starts with a question word.
+ */
+export const questionTerms = (text) => /\?\s*$/u.test(text) || QUESTION_STARTS.has(words(text)[0] ?? "")
+    ? words(text).filter((word) => !scaffolding.has(word) && !QUESTION_STARTS.has(word) && !QUESTION_FILLER.has(word))
+    : null;
 export function planQuestion(text, strict = false) {
     if (strict)
         return {

package/dist/services/index.d.ts

@@ -67,6 +67,7 @@ export { readMail } from "./mail-search.js";
 export { type MeetingHitSearchRequest, refreshMeetingIndex, searchMeetingHits } from "./meeting-hit-search.js";
 export { createMeetingProjectCandidateReader } from "./meeting-project-candidates.js";
 export { readMeetingProjectDiscovery } from "./meeting-project-discovery.js";
+export { type MeetingStatsRequest, readMeetingStats } from "./meeting-stats.js";
 export { chatIdIn, storedChatId } from "./message-resolution.js";
 export type { AroundWindow, FoundMessage, ListWindow, MessagesService, MessageTarget, Pinned, Reacted, SearchFound, SearchQuery, SendRequest, Starred, } from "./messages.js";
 export { DELETE_AT_ONCE, messagesService } from "./messages.js";
@@ -139,6 +140,7 @@ export { countersService } from "./counters.js";
 export { type DocumentTarget, openPictureEmbedderFor, type PictureOptions, removePicture, savePicture, } from "./document-pictures.js";
 export type { ModelChoice } from "./embeddings.js";
 export { createMeetingBatchReader } from "./meeting-batch.js";
+export { type MeetingCombinedHit, type MeetingCombinedRequest, searchMeetingsCombined, } from "./meeting-combined.js";
 export type { MeetingCommunicationCoverage, MeetingCommunicationExcerpt, MeetingCommunications, MeetingCommunicationsPort, MeetingCommunicationsRequest, } from "./meeting-communications-types.js";
 export { createMeetingContextService, type MeetingContextService, type MeetingContextServiceStore, } from "./meeting-context.js";
 export { type MeetingEvidenceCue, type MeetingEvidenceOptions, type MeetingEvidencePacket, readMeetingEvidence, } from "./meeting-evidence.js";

package/dist/services/index.js

@@ -48,6 +48,7 @@ export { readMail } from "./mail-search.js";
 export { refreshMeetingIndex, searchMeetingHits } from "./meeting-hit-search.js";
 export { createMeetingProjectCandidateReader } from "./meeting-project-candidates.js";
 export { readMeetingProjectDiscovery } from "./meeting-project-discovery.js";
+export { readMeetingStats } from "./meeting-stats.js";
 export { chatIdIn, storedChatId } from "./message-resolution.js";
 export { DELETE_AT_ONCE, messagesService } from "./messages.js";
 export { searchStore } from "./messages-archive-search.js";
@@ -105,6 +106,7 @@ export { GAP_BOUNDS, gapsService } from "./archive-gaps.js";
 export { countersService } from "./counters.js";
 export { openPictureEmbedderFor, removePicture, savePicture, } from "./document-pictures.js";
 export { createMeetingBatchReader } from "./meeting-batch.js";
+export { searchMeetingsCombined, } from "./meeting-combined.js";
 export { createMeetingContextService, } from "./meeting-context.js";
 export { readMeetingEvidence, } from "./meeting-evidence.js";
 export { meetingHitContextLimits, readMeetingHitContext, } from "./meeting-hit-context.js";

package/dist/services/meeting-combined.d.ts

@@ -0,0 +1,95 @@
+import { type MeetingHitSearchRequest, type SearchHit } from "../meetings/index.js";
+import type { MessageStore } from "../store/store.js";
+import type { MeetingEmbedder } from "./meeting-model.js";
+export interface MeetingCombinedRequest extends MeetingHitSearchRequest {
+    /** Most stored passage vectors to compare, 1 through 100000 (default 10000). */
+    maxChunks?: number;
+    maxRows?: number;
+    maxTextBytes?: number;
+}
+export interface MeetingCombinedHit {
+    /** A transcript line to cite: the best word hit in the passage, else the passage's first line. */
+    ref: string;
+    meetingId: number;
+    scope: SearchHit["scope"];
+    text: string;
+    startMs: number | null;
+    source: {
+        title: string | null;
+        startedAt: number | null;
+        url: string | null;
+    };
+    /** Which searches found it: `words`, `meaning` or both. */
+    by: ("words" | "meaning")[];
+    /** Similarity in meaning, when the meaning search found it. */
+    score: number | null;
+    /** The passage the meaning search matched, as its first and last line. */
+    passage?: {
+        first: string;
+        last: string;
+    };
+    match?: SearchHit["match"];
+    corrections?: SearchHit["corrections"];
+}
+/**
+ * Words and meaning, ranked together by reciprocal rank fusion over one selection of meetings. A question
+ * («что решили по цене?») searches its content words; other text is the meeting query language. A word hit inside
+ * a passage the meaning search found joins it, so one discussion found both ways ranks first.
+ */
+export declare const searchMeetingsCombined: (store: Pick<MessageStore, "meetings" | "meetingVectors"> & {
+    knowledge?: MessageStore["knowledge"];
+}, embedder: MeetingEmbedder, query: string, request: MeetingCombinedRequest) => Promise<{
+    items: {
+        /** A transcript line to cite: the best word hit in the passage, else the passage's first line. */
+        ref: string;
+        meetingId: number;
+        scope: SearchHit["scope"];
+        text: string;
+        startMs: number | null;
+        source: {
+            title: string | null;
+            startedAt: number | null;
+            url: string | null;
+        };
+        /** Which searches found it: `words`, `meaning` or both. */
+        by: ("words" | "meaning")[];
+        /** Similarity in meaning, when the meaning search found it. */
+        score: number | null;
+        /** The passage the meaning search matched, as its first and last line. */
+        passage?: {
+            first: string;
+            last: string;
+        };
+        match?: SearchHit["match"];
+        corrections?: SearchHit["corrections"];
+    }[];
+    hasMore: boolean;
+    nextCursor: string | null;
+    selection: {
+        kind: import("../store/index.js").VocabularyKind;
+        id: number;
+        name: string;
+        by: "explicit-link";
+    }[];
+    words: {
+        query: string;
+        from?: "question" | undefined;
+        refused?: string | undefined;
+    };
+    model: {
+        key: string;
+        model: string;
+        kind: "local" | "remote";
+        dims: number;
+    };
+    coverage: {
+        archiveCompleteness: "unknown";
+        indexCompleteness: "unknown";
+        indexing: "pending" | "ready";
+        /** Every vector of the selection was compared; false when `maxChunks` stopped the scan. */
+        meaningScanComplete: boolean;
+        scanned: number;
+        /** Each side ranks this many at most; pages past them hold nothing more. */
+        depth: number;
+    };
+}>;

package/dist/services/meeting-combined.js

@@ -0,0 +1,163 @@
+import { createHash } from "node:crypto";
+import { CliError } from "@wirecat/cli-base";
+import { meaningFloor } from "../embeddings/models.js";
+import { formatMeetingReference, parseMeetingReference, } from "../meetings/index.js";
+import { questionTerms } from "../search/question-plan.js";
+import { refreshMeetingIndex, resolveMeetingSelection } from "./meeting-hit-search.js";
+import { validateVector } from "./meeting-semantic.js";
+import { RRF_K } from "./notes-search.js";
+/** How many hits each side ranks before they are merged; a page past it has nothing more to show. */
+const DEPTH = 200;
+const cursorOf = (value, key) => {
+    if (value === undefined)
+        return 0;
+    let cursor;
+    try {
+        cursor = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new CliError("validation_error", "the cursor is not from a combined meeting search; search again");
+    }
+    if (cursor?.version !== 1 || cursor.key !== key || !Number.isSafeInteger(cursor.offset) || cursor.offset < 0)
+        throw new CliError("validation_error", "the cursor belongs to another query, filter or model; search again");
+    return cursor.offset;
+};
+/**
+ * Words and meaning, ranked together by reciprocal rank fusion over one selection of meetings. A question
+ * («что решили по цене?») searches its content words; other text is the meeting query language. A word hit inside
+ * a passage the meaning search found joins it, so one discussion found both ways ranks first.
+ */
+export const searchMeetingsCombined = async (store, embedder, query, request) => {
+    const { maxChunks, maxRows, maxTextBytes, ...words } = request;
+    const { input, selection } = await resolveMeetingSelection(store, words);
+    const { after, limit = 20, maxReadBytes, ...filters } = input;
+    const terms = questionTerms(query);
+    const wordQuery = terms === null ? query : terms.join(" ");
+    const key = createHash("sha256")
+        .update(JSON.stringify([query, embedder.key, Object.entries(filters).filter(([name]) => name !== "signal")]))
+        .digest("base64url");
+    const offset = cursorOf(after, key);
+    let byWords = [];
+    let indexing = "ready";
+    let refused;
+    if (wordQuery.trim()) {
+        await refreshMeetingIndex(store.meetings, input.accountId, input.signal);
+        try {
+            const page = await store.meetings.searchHits(wordQuery, { ...filters, limit: DEPTH, maxReadBytes });
+            byWords = page.items;
+            indexing = page.coverage.indexing;
+        }
+        catch (error) {
+            // Text the query language refuses is still a question to ask by meaning.
+            if (!(error instanceof CliError) || error.code !== "validation_error")
+                throw error;
+            refused = error.message;
+        }
+    }
+    input.signal?.throwIfAborted();
+    const vectors = await embedder.embed([query], "query");
+    if (vectors.length !== 1)
+        throw new CliError("invalid_response", "Meeting query model returned another vector count");
+    const vector = vectors[0];
+    const ranked = await store.meetingVectors.ranked(embedder.key, validateVector(vector, embedder.dims), {
+        ...filters,
+        limit: DEPTH,
+        ...(maxChunks === undefined ? {} : { maxChunks }),
+        ...(maxRows === undefined ? {} : { maxRows }),
+        ...(maxTextBytes === undefined ? {} : { maxTextBytes }),
+    });
+    const floor = meaningFloor(embedder.key);
+    const byMeaning = ranked.items.filter(({ score }) => score > floor);
+    const merged = new Map();
+    byMeaning.forEach((hit, rank) => {
+        const reference = { type: "meeting", accountId: input.accountId, meetingId: hit.meetingId };
+        const first = formatMeetingReference({
+            ...reference,
+            transcriptId: hit.transcriptId,
+            cuePosition: hit.firstPosition,
+        });
+        merged.set(`${hit.transcriptId}:${hit.firstPosition}`, {
+            ref: first,
+            meetingId: hit.meetingId,
+            scope: "transcript",
+            text: hit.text,
+            startMs: null,
+            source: { title: hit.title, startedAt: hit.startedAt, url: null },
+            by: ["meaning"],
+            score: hit.score,
+            passage: {
+                first,
+                last: formatMeetingReference({ ...reference, transcriptId: hit.transcriptId, cuePosition: hit.lastPosition }),
+            },
+            fused: 1 / (RRF_K + rank + 1),
+        });
+    });
+    byWords.forEach((hit, rank) => {
+        const share = 1 / (RRF_K + rank + 1);
+        const cue = hit.scope === "transcript" ? parseMeetingReference(hit.ref) : undefined;
+        const within = cue?.cuePosition === undefined
+            ? undefined
+            : byMeaning.find((passage) => passage.transcriptId === cue.transcriptId &&
+                passage.firstPosition <= cue.cuePosition &&
+                cue.cuePosition <= passage.lastPosition);
+        const held = within && merged.get(`${within.transcriptId}:${within.firstPosition}`);
+        const found = {
+            ref: hit.ref,
+            text: hit.text,
+            startMs: hit.startMs,
+            ...(hit.match === undefined ? {} : { match: hit.match }),
+            ...(hit.corrections === undefined ? {} : { corrections: hit.corrections }),
+        };
+        if (held && !held.by.includes("words")) {
+            Object.assign(held, found, { by: ["words", "meaning"], fused: held.fused + share });
+            if (hit.source?.url)
+                held.source.url = hit.source.url;
+        }
+        else if (held)
+            held.fused += share;
+        else
+            merged.set(`w:${hit.ref}:${hit.scope}:${hit.id}`, {
+                ...found,
+                meetingId: hit.meetingId,
+                scope: hit.scope,
+                source: {
+                    title: hit.source?.title ?? null,
+                    startedAt: hit.source?.startedAt ?? null,
+                    url: hit.source?.url ?? null,
+                },
+                by: ["words"],
+                score: null,
+                fused: share,
+            });
+    });
+    // On a tie a line that has the words outranks a passage that only resembles the query.
+    const ordered = [...merged.values()].sort((a, b) => b.fused - a.fused ||
+        Number(b.by.includes("words")) - Number(a.by.includes("words")) ||
+        (b.score ?? -2) - (a.score ?? -2));
+    const items = ordered.slice(offset, offset + limit).map(({ fused: _, ...hit }) => hit);
+    const hasMore = ordered.length > offset + limit;
+    return {
+        items,
+        hasMore,
+        nextCursor: hasMore
+            ? Buffer.from(JSON.stringify({ version: 1, key, offset: offset + limit })).toString("base64url")
+            : null,
+        selection,
+        words: {
+            query: wordQuery,
+            ...(terms === null ? {} : { from: "question" }),
+            ...(refused === undefined ? {} : { refused }),
+        },
+        model: { key: embedder.key, model: embedder.model, kind: embedder.kind, dims: embedder.dims },
+        coverage: {
+            archiveCompleteness: "unknown",
+            indexCompleteness: "unknown",
+            indexing,
+            /** Every vector of the selection was compared; false when `maxChunks` stopped the scan. */
+            meaningScanComplete: ranked.complete,
+            scanned: ranked.scanned,
+            /** Each side ranks this many at most; pages past them hold nothing more. */
+            depth: DEPTH,
+        },
+    };
+};

package/dist/services/meeting-hit-search.d.ts

@@ -5,6 +5,32 @@ export type { MeetingHitSearchRequest } from "../meetings/index.js";
 /** Each batch commits on its own, so a search cut short by its deadline keeps the progress it made. */
 export declare const refreshMeetingIndex: (meetings: Pick<MessageStore["meetings"], "indexSearch">, accountId: number, signal?: AbortSignal) => Promise<void>;
 /** Name resolution changes selection only; it never assigns projects or labels from transcript words. */
+export declare const resolveMeetingSelection: (store: {
+    knowledge?: MessageStore["knowledge"];
+}, request: MeetingHitSearchRequest) => Promise<{
+    input: {
+        accountId: number;
+        meetingId?: number;
+        participantIdentityId?: number;
+        personId?: number;
+        projectId?: number;
+        tagId?: number;
+        eventId?: number;
+        meetingSeriesId?: number;
+        since?: number;
+        until?: number;
+        limit?: number;
+        after?: string;
+        maxReadBytes?: number;
+        signal?: AbortSignal;
+    };
+    selection: {
+        kind: VocabularyKind;
+        id: number;
+        name: string;
+        by: "explicit-link";
+    }[];
+}>;
 export declare const searchMeetingHits: (store: Pick<MessageStore, "meetings"> & {
     knowledge?: MessageStore["knowledge"];
 }, query: string, request: MeetingHitSearchRequest, options?: {

package/dist/services/meeting-hit-search.js

@@ -16,7 +16,7 @@ export const refreshMeetingIndex = async (meetings, accountId, signal) => {
     }
 };
 /** Name resolution changes selection only; it never assigns projects or labels from transcript words. */
-export const searchMeetingHits = async (store, query, request, options = {}) => {
+export const resolveMeetingSelection = async (store, request) => {
     const { project, tag, topic, ...input } = request;
     input.signal?.throwIfAborted();
     if ((project !== undefined && input.projectId !== undefined) ||
@@ -51,6 +51,10 @@ export const searchMeetingHits = async (store, query, request, options = {}) =>
             input.tagId = id;
         selection.push({ kind, id, name: entry.name, by: "explicit-link" });
     }
+    return { input, selection };
+};
+export const searchMeetingHits = async (store, query, request, options = {}) => {
+    const { input, selection } = await resolveMeetingSelection(store, request);
     if (options.refreshIndex !== false)
         await refreshMeetingIndex(store.meetings, input.accountId, input.signal);
     const result = await store.meetings.searchHits(query, input);

package/dist/services/meeting-semantic.d.ts

@@ -16,6 +16,7 @@ export interface MeetingEmbeddingApplyOptions {
     maxVectorBytes?: number;
     signal?: AbortSignal;
 }
+export declare const validateVector: (vector: Float32Array | undefined, dims: number) => Float32Array;
 /** Embeds only this explicit query; never rebuilds chunks or generates stored vectors. */
 export declare const readMeetingSemantic: (store: Pick<MeetingVectors, "nearest">, accountId: number, query: string, embedder: MeetingEmbedder, options?: MeetingSemanticOptions) => Promise<{
     ranking: "scanned-candidates";

package/dist/services/meeting-semantic.js

@@ -25,7 +25,7 @@ const textBudget = (options) => ({
     maxRows: positive(options.maxRows ?? 10000, "transcript row budget", 100000),
     maxTextBytes: positive(options.maxTextBytes ?? 4 * 1024 * 1024, "transcript text byte budget", 64 * 1024 * 1024),
 });
-const validateVector = (vector, dims) => {
+export const validateVector = (vector, dims) => {
     if (!(vector instanceof Float32Array) ||
         vector.length !== dims ||
         !vector.some((value) => value !== 0) ||

package/dist/services/meeting-stats.d.ts

@@ -0,0 +1,13 @@
+import type { MeetingHitSearchRequest, MeetingStats } from "../meetings/index.js";
+import type { MessageStore } from "../store/store.js";
+import { resolveMeetingSelection } from "./meeting-hit-search.js";
+export type MeetingStatsRequest = Omit<MeetingHitSearchRequest, "limit" | "after" | "maxReadBytes"> & {
+    timeZone?: string;
+    maxRows?: number;
+};
+/** Talk time and lines per speaker and meetings per week over the meetings search would read, names resolved alike. */
+export declare const readMeetingStats: (store: Pick<MessageStore, "meetings"> & {
+    knowledge?: MessageStore["knowledge"];
+}, request: MeetingStatsRequest) => Promise<MeetingStats & {
+    selection: Awaited<ReturnType<typeof resolveMeetingSelection>>["selection"];
+}>;

package/dist/services/meeting-stats.js

@@ -0,0 +1,12 @@
+import { resolveMeetingSelection } from "./meeting-hit-search.js";
+/** Talk time and lines per speaker and meetings per week over the meetings search would read, names resolved alike. */
+export const readMeetingStats = async (store, request) => {
+    const { timeZone, maxRows, ...selecting } = request;
+    const { input, selection } = await resolveMeetingSelection(store, selecting);
+    const stats = await store.meetings.meetingStats({
+        ...input,
+        ...(timeZone === undefined ? {} : { timeZone }),
+        ...(maxRows === undefined ? {} : { maxRows }),
+    });
+    return { ...stats, selection };
+};

package/dist/store/sqlite/meeting-hit-search.js

@@ -5,6 +5,7 @@ import { matchMeetingText, meetingQuerySql, resolveMeetingQuery } from "./meetin
 import { indexedText } from "./meeting-index-values.js";
 import { checkMeetingCancelled } from "./meeting-operation.js";
 import { positiveReadInteger } from "./meeting-reads.js";
+import { meetingSelectionSql } from "./meeting-selection.js";
 import { meetingStemState } from "./meeting-stem-state.js";
 import { read } from "./transaction.js";
 const fail = (message) => {
@@ -112,45 +113,8 @@ export function meetingHitSearchOver({ database }) {
                     indexing: pending || !state.stemmer || state.through < state.watermark ? "pending" : "ready",
                     indexCompleteness: "unknown",
                 };
-                const clauses = ["m.account_id=?", "m.deleted_at IS NULL"];
                 const { sql: matching, params: queryParams } = meetingQuerySql(tree, state);
-                const params = [input.accountId];
-                if (input.meetingId !== undefined) {
-                    clauses.push("m.id=?");
-                    params.push(input.meetingId);
-                }
-                if (input.eventId !== undefined) {
-                    clauses.push("m.event_id=?");
-                    params.push(input.eventId);
-                }
-                if (input.meetingSeriesId !== undefined) {
-                    clauses.push("m.meeting_series_id=?");
-                    params.push(input.meetingSeriesId);
-                }
-                if (input.since !== undefined) {
-                    clauses.push("m.started_at>=?");
-                    params.push(input.since);
-                }
-                if (input.until !== undefined) {
-                    clauses.push("m.started_at<=?");
-                    params.push(input.until);
-                }
-                if (input.participantIdentityId !== undefined) {
-                    clauses.push("EXISTS (SELECT 1 FROM meeting_participants p WHERE p.meeting_id=m.id AND p.identity_id=?)");
-                    params.push(input.participantIdentityId);
-                }
-                if (input.personId !== undefined) {
-                    clauses.push("EXISTS (SELECT 1 FROM meeting_participants p JOIN identity_links i ON i.identity_id=p.identity_id JOIN persons person ON person.id=i.person_id WHERE p.meeting_id=m.id AND person.id=?)");
-                    params.push(input.personId);
-                }
-                if (input.projectId !== undefined) {
-                    clauses.push("EXISTS (SELECT 1 FROM links l JOIN projects p ON p.id=l.to_id WHERE l.from_type='meeting' AND l.from_id=m.id AND l.to_type='project' AND l.kind='member-of' AND l.anchor IS NULL AND l.confirmed=1 AND p.id=? AND p.account_id IS NULL AND p.deleted_at IS NULL)");
-                    params.push(input.projectId);
-                }
-                if (input.tagId !== undefined) {
-                    clauses.push("EXISTS (SELECT 1 FROM taggings g JOIN tags t ON t.id=g.tag_id WHERE g.taggable_type='meeting' AND g.taggable_id=m.id AND t.id=?)");
-                    params.push(input.tagId);
-                }
+                const { clauses, params } = meetingSelectionSql(input);
                 const seek = after
                     ? "WHERE h.tier>? OR (h.tier=? AND (h.started<? OR (h.started=? AND (h.meeting_id>? OR (h.meeting_id=? AND (h.kind>? OR (h.kind=? AND h.id>?)))))))"
                     : "";

package/dist/store/sqlite/meeting-selection.d.ts

@@ -0,0 +1,8 @@
+import type { MeetingSearchOptions } from "../../meetings/index.js";
+import type { SqlValue } from "../driver.js";
+export type MeetingSelection = Pick<MeetingSearchOptions, "accountId" | "meetingId" | "eventId" | "meetingSeriesId" | "since" | "until" | "participantIdentityId" | "personId" | "projectId" | "tagId">;
+/** The meetings a search may read, over `meetings m`: the same filters for words and for meaning. */
+export declare const meetingSelectionSql: (input: MeetingSelection) => {
+    clauses: string[];
+    params: SqlValue[];
+};

package/dist/store/sqlite/meeting-selection.js

@@ -0,0 +1,42 @@
+/** The meetings a search may read, over `meetings m`: the same filters for words and for meaning. */
+export const meetingSelectionSql = (input) => {
+    const clauses = ["m.account_id=?", "m.deleted_at IS NULL"];
+    const params = [input.accountId];
+    if (input.meetingId !== undefined) {
+        clauses.push("m.id=?");
+        params.push(input.meetingId);
+    }
+    if (input.eventId !== undefined) {
+        clauses.push("m.event_id=?");
+        params.push(input.eventId);
+    }
+    if (input.meetingSeriesId !== undefined) {
+        clauses.push("m.meeting_series_id=?");
+        params.push(input.meetingSeriesId);
+    }
+    if (input.since !== undefined) {
+        clauses.push("m.started_at>=?");
+        params.push(input.since);
+    }
+    if (input.until !== undefined) {
+        clauses.push("m.started_at<=?");
+        params.push(input.until);
+    }
+    if (input.participantIdentityId !== undefined) {
+        clauses.push("EXISTS (SELECT 1 FROM meeting_participants p WHERE p.meeting_id=m.id AND p.identity_id=?)");
+        params.push(input.participantIdentityId);
+    }
+    if (input.personId !== undefined) {
+        clauses.push("EXISTS (SELECT 1 FROM meeting_participants p JOIN identity_links i ON i.identity_id=p.identity_id JOIN persons person ON person.id=i.person_id WHERE p.meeting_id=m.id AND person.id=?)");
+        params.push(input.personId);
+    }
+    if (input.projectId !== undefined) {
+        clauses.push("EXISTS (SELECT 1 FROM links l JOIN projects p ON p.id=l.to_id WHERE l.from_type='meeting' AND l.from_id=m.id AND l.to_type='project' AND l.kind='member-of' AND l.anchor IS NULL AND l.confirmed=1 AND p.id=? AND p.account_id IS NULL AND p.deleted_at IS NULL)");
+        params.push(input.projectId);
+    }
+    if (input.tagId !== undefined) {
+        clauses.push("EXISTS (SELECT 1 FROM taggings g JOIN tags t ON t.id=g.tag_id WHERE g.taggable_type='meeting' AND g.taggable_id=m.id AND t.id=?)");
+        params.push(input.tagId);
+    }
+    return { clauses, params };
+};

package/dist/store/sqlite/meeting-stats.d.ts

@@ -0,0 +1,7 @@
+import { type MeetingStatsStore } from "../../meetings/index.js";
+import type { StoreContext } from "./open.js";
+/**
+ * One transcript per meeting — its earliest current one — so a local transcript beside the provider's does not count
+ * the talk twice. Words are counted from spaces in SQL, so no transcript text leaves the database.
+ */
+export declare const meetingStatsOver: ({ database }: StoreContext) => MeetingStatsStore;

package/dist/store/sqlite/meeting-stats.js

@@ -0,0 +1,55 @@
+import { CliError } from "@wirecat/cli-base";
+import { aggregateMeetingStats } from "../../meetings/index.js";
+import { checkMeetingCancelled } from "./meeting-operation.js";
+import { positiveReadInteger } from "./meeting-reads.js";
+import { meetingSelectionSql } from "./meeting-selection.js";
+import { read } from "./transaction.js";
+const MOST_ROWS = 500_000;
+/**
+ * One transcript per meeting — its earliest current one — so a local transcript beside the provider's does not count
+ * the talk twice. Words are counted from spaces in SQL, so no transcript text leaves the database.
+ */
+export const meetingStatsOver = ({ database }) => ({
+    async meetingStats(input) {
+        checkMeetingCancelled(input.signal);
+        positiveReadInteger(input.accountId, "accountId");
+        const maxRows = input.maxRows ?? MOST_ROWS;
+        if (!Number.isSafeInteger(maxRows) || maxRows < 1 || maxRows > MOST_ROWS)
+            throw new CliError("validation_error", `meeting stats read 1 through ${MOST_ROWS} transcript lines`);
+        return read(database, () => {
+            const { clauses, params } = meetingSelectionSql(input);
+            const sql = `WITH selected AS (SELECT m.id, m.started_at FROM meetings m WHERE ${clauses.join(" AND ")}),
+        chosen AS (SELECT min(t.id) AS id, t.meeting_id FROM meeting_transcripts t JOIN selected s ON s.id = t.meeting_id
+          WHERE t.deleted_at IS NULL AND t.superseded_at IS NULL GROUP BY t.meeting_id)
+        SELECT c.meeting_id, s.started_at, r.start_ms, r.end_ms,
+          length(trim(r.text)) - length(replace(trim(r.text), ' ', '')) + (length(trim(r.text)) > 0) AS words,
+          l.person_id, person.name AS person_name, p.identity_id, i.name AS identity_name,
+          coalesce(r.speaker_name, p.display_name) AS speaker_name
+        FROM chosen c JOIN selected s ON s.id = c.meeting_id
+        JOIN meeting_transcript_rows r ON r.meeting_transcript_id = c.id
+        LEFT JOIN meeting_participants p ON p.id = r.speaker_participant_id
+        LEFT JOIN identities i ON i.id = p.identity_id
+        LEFT JOIN identity_links l ON l.identity_id = p.identity_id
+        LEFT JOIN persons person ON person.id = l.person_id
+        LIMIT ?`;
+            const rows = database.prepare(sql).all(...params, maxRows + 1);
+            if (rows.length > maxRows)
+                throw new CliError("validation_error", `the selection has more than ${maxRows} transcript lines; narrow it`);
+            checkMeetingCancelled(input.signal);
+            const nullable = (value) => (value === null || value === undefined ? null : Number(value));
+            const text = (value) => (value === null || value === undefined ? null : String(value));
+            return aggregateMeetingStats(rows.map((row) => ({
+                meetingId: Number(row.meeting_id),
+                startedAt: nullable(row.started_at),
+                startMs: Number(row.start_ms),
+                endMs: Number(row.end_ms),
+                words: Number(row.words),
+                personId: nullable(row.person_id),
+                personName: text(row.person_name),
+                identityId: nullable(row.identity_id),
+                identityName: text(row.identity_name),
+                speakerName: text(row.speaker_name),
+            })), input.timeZone);
+        });
+    },
+});

package/dist/store/sqlite/meeting-vectors.d.ts

@@ -1,3 +1,4 @@
+import { type MeetingSelection } from "./meeting-selection.js";
 import type { StoreContext } from "./open.js";
 interface Scope {
     accountId: number;
@@ -61,6 +62,22 @@ export interface MeetingVectors {
         chunks: number;
         embedded: number;
     }>;
+    /**
+     * The `limit` passages nearest to `query` among every vector of `model` in the selected meetings, up to
+     * `maxChunks` of them: one ranking over the whole selection, with text read only for the passages kept.
+     */
+    ranked(model: string, query: Float32Array, input: MeetingSelection & Scope & TextBudget & {
+        limit: number;
+        maxChunks?: number;
+    }): Promise<{
+        items: (MeetingVectorHit & {
+            text: string;
+            title: string | null;
+            startedAt: number | null;
+        })[];
+        scanned: number;
+        complete: boolean;
+    }>;
 }
 export declare const meetingVectorsOver: (context: StoreContext) => MeetingVectors;
 export {};

package/dist/store/sqlite/meeting-vectors.js

@@ -1,8 +1,11 @@
 import { CliError } from "@wirecat/cli-base";
 import { chunkHash, cutChunks } from "../../conversations/chunks.js";
 import { positiveReadInteger } from "./meeting-reads.js";
+import { meetingSelectionSql } from "./meeting-selection.js";
 import { read, write } from "./transaction.js";
 import { dot, saveVectors } from "./vectors.js";
+/** Vectors read per query while ranking, so a store of any size stays within a few megabytes at a time. */
+const RANK_BATCH = 512;
 const LIVE = "FROM chunks k JOIN meeting_transcripts t ON k.chunkable_type = 'meeting_transcript' AND t.id = k.chunkable_id JOIN meetings m ON m.id = t.meeting_id WHERE m.account_id = ? AND m.deleted_at IS NULL AND t.deleted_at IS NULL AND t.superseded_at IS NULL";
 const limitOf = (value, name, max = 1000) => {
     positiveReadInteger(value, name);
@@ -233,6 +236,69 @@ export const meetingVectorsOver = (context) => ({
             };
         });
     },
+    async ranked(model, query, input) {
+        scope(input);
+        modelOf(model);
+        const limit = limitOf(input.limit, "limit"), maxChunks = limitOf(input.maxChunks ?? 10000, "maxChunks", 100000);
+        if (!query.length || query.length > 65536 || Array.from(query).some((value) => !Number.isFinite(value)))
+            throw new CliError("validation_error", "Query vector must have finite dimensions");
+        return read(context.database, () => {
+            const { clauses, params } = meetingSelectionSql(input);
+            const batch = context.database.prepare(`SELECT k.id,k.chunkable_id,k.content_hash,k.start_offset,k.end_offset,e.dims,e.vector FROM chunks k JOIN meeting_transcripts t ON k.chunkable_type='meeting_transcript' AND t.id=k.chunkable_id JOIN meetings m ON m.id=t.meeting_id JOIN embeddings e ON e.content_hash=k.content_hash AND e.model=? WHERE ${clauses.join(" AND ")} AND t.deleted_at IS NULL AND t.superseded_at IS NULL AND k.id>? ORDER BY k.id LIMIT ?`);
+            const best = [];
+            let scanned = 0;
+            let after = 0;
+            let complete = true;
+            for (;;) {
+                input.signal?.throwIfAborted();
+                const take = Math.min(RANK_BATCH, maxChunks - scanned);
+                if (take <= 0) {
+                    complete = !batch.get(model, ...params, after, 1);
+                    break;
+                }
+                const rows = batch.all(model, ...params, after, take);
+                for (const row of rows) {
+                    if (Number(row.dims) !== query.length ||
+                        !(row.vector instanceof Uint8Array) ||
+                        row.vector.byteLength !== query.length * 4)
+                        throw new CliError("validation_error", "Stored vector dimensions do not match query");
+                    const score = dot(query, row.vector);
+                    if (!Number.isFinite(score))
+                        throw new CliError("invalid_response", "Stored vector contains non-finite values");
+                    if (best.length < limit || score > (best.at(-1)?.score ?? Number.NEGATIVE_INFINITY)) {
+                        const { vector: _, ...kept } = row;
+                        const at = best.findIndex((held) => held.score < score);
+                        best.splice(at < 0 ? best.length : at, 0, { row: kept, score });
+                        if (best.length > limit)
+                            best.pop();
+                    }
+                }
+                scanned += rows.length;
+                after = Number(rows.at(-1)?.id ?? after);
+                if (rows.length < take)
+                    break;
+            }
+            const load = textLoader(context, input);
+            const meeting = context.database.prepare("SELECT title,started_at FROM meetings WHERE id=?");
+            const items = best.map(({ row, score }) => {
+                input.signal?.throwIfAborted();
+                const text = chunkText(context, input.accountId, row, input, input.signal, load(Number(row.chunkable_id)));
+                const about = meeting.get(text.meetingId);
+                return {
+                    title: about?.title == null ? null : String(about.title),
+                    startedAt: about?.started_at == null ? null : Number(about.started_at),
+                    meetingId: text.meetingId,
+                    transcriptId: Number(row.chunkable_id),
+                    firstPosition: text.firstPosition,
+                    lastPosition: text.lastPosition,
+                    hash: String(row.content_hash),
+                    score,
+                    text: text.text,
+                };
+            });
+            return { items, scanned, complete };
+        });
+    },
     async status(input) {
         scope(input);
         modelOf(input.model);

package/dist/store/sqlite/meetings.d.ts

@@ -1,4 +1,4 @@
-import type { Attachment, MeetingContextStore, MeetingParticipantSearchStore, MeetingPreparationContextStore, MeetingPreparationKnowledgeStore, MeetingPreparationNotesStore, MeetingRelatedHistoryStore, MeetingSearchIndexStore, MeetingSearchStore, MeetingSeriesHistoryStore, MeetingStore, MeetingTranscriptReceiptStore, MeetingTranscriptStore, NewRecord } from "../../meetings/index.js";
+import type { Attachment, MeetingContextStore, MeetingParticipantSearchStore, MeetingPreparationContextStore, MeetingPreparationKnowledgeStore, MeetingPreparationNotesStore, MeetingRelatedHistoryStore, MeetingSearchIndexStore, MeetingSearchStore, MeetingSeriesHistoryStore, MeetingStatsStore, MeetingStore, MeetingTranscriptReceiptStore, MeetingTranscriptStore, NewRecord } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 import { type MeetingContextReadCapabilities, type MeetingReadCapabilities } from "./meeting-reads.js";
 import type { StoreContext } from "./open.js";
@@ -11,7 +11,7 @@ export declare const saveAttachment: (database: CacheDatabase, type: string, par
 export declare const drainMeetingIndex: (database: CacheDatabase, batch?: number) => number;
 /** Each word of the query, as a prefix, all required. */
 export declare const wordsQuery: (query: string) => string | null;
-export type StoredMeetings = MeetingStore & MeetingPreparationContextStore & MeetingPreparationKnowledgeStore & MeetingPreparationNotesStore & MeetingRelatedHistoryStore & MeetingSeriesHistoryStore & MeetingTranscriptStore & MeetingReadCapabilities & MeetingContextReadCapabilities & MeetingParticipantSearchStore & MeetingSearchStore & MeetingTranscriptReceiptStore & MeetingContextStore & MeetingSearchIndexStore;
+export type StoredMeetings = MeetingStore & MeetingPreparationContextStore & MeetingPreparationKnowledgeStore & MeetingPreparationNotesStore & MeetingRelatedHistoryStore & MeetingSeriesHistoryStore & MeetingTranscriptStore & MeetingReadCapabilities & MeetingContextReadCapabilities & MeetingParticipantSearchStore & MeetingSearchStore & MeetingTranscriptReceiptStore & MeetingContextStore & MeetingSearchIndexStore & MeetingStatsStore;
 /** The `MeetingStore` of `src/meetings/` over the shared store. */
 export declare const meetingStoreOver: (context: StoreContext) => StoredMeetings;
 export {};

package/dist/store/sqlite/meetings.js

@@ -16,6 +16,7 @@ import { meetingPreparationNotesOver } from "./meeting-preparation-notes.js";
 import { meetingReadsOver } from "./meeting-reads.js";
 import { meetingRelatedHistoryOver } from "./meeting-related-history.js";
 import { meetingSeriesHistoryOver } from "./meeting-series-history.js";
+import { meetingStatsOver } from "./meeting-stats.js";
 import { invalidateMeetingStems } from "./meeting-stem-state.js";
 import { meetingOf, transcriptOf, transcriptRowOf } from "./meeting-values.js";
 import { queryFilter } from "./query-filter.js";
@@ -571,6 +572,7 @@ export const meetingStoreOver = (context) => {
         ...meetingPreparationNotesOver(context),
         ...meetingRelatedHistoryOver(context),
         ...meetingHitSearchOver(context),
+        ...meetingStatsOver(context),
         ...meetingParticipantSearchOver(context),
         ...meetingHitIndexOver(context),
         ...meetingContextLinksOver(context),

package/package.json

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