@wirecat/cli-core 0.551.0 → 0.553.0

package/dist/services/stored-project-gathering.d.ts

@@ -1,7 +1,8 @@
 import type { ContextSource } from "../context/evidence.js";
-import type { MessageStore } from "../store/store.js";
+import type { AccountKey, MessageStore } from "../store/store.js";
 import { gatherProjectEvidence, type ProjectChatFetcher, type ProjectGatheringPorts } from "./project-gathering.js";
 import { type EvidenceMentions } from "./project-gathering-mentions.js";
+import { type PurposeConfig } from "./project-purposes.js";
 export interface StoredProjectInput {
     project: string;
     /** The sources the host resolved from its `--source`, and those it could not read. */
@@ -31,19 +32,81 @@ export interface StoredProjectInput {
     maxFetchMs?: number;
     onFetchProgress?: ProjectGatheringPorts["onFetchProgress"];
     signal?: AbortSignal;
+    /** The linked chats' purposes to read; `["all"]` reads every one. Left out, the config's defaults. */
+    purposes?: readonly string[];
+    /** The host's purposes; core's built-in ones when left out. */
+    purposeConfig?: PurposeConfig;
+    /** Proposed `member-of` links count as linked chats and members too, after the confirmed ones, every item marked. */
+    includeProposed?: boolean;
+    /** How many messages a left-out chat holds in the window; the store's own count when left out. */
+    count?: ChatCounter;
 }
+export interface ChatCount {
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
+}
+export type ChatCounter = (account: AccountKey, chatId: string, window: {
+    since: number;
+    until: number;
+}) => Promise<ChatCount>;
+/** The store's count of one chat's messages in a window, `until` exclusive, and the first and last of them. */
+export declare const storedChatCount: (store: MessageStore) => ChatCounter;
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export declare const canonicalProjectRef: (store: MessageStore, reference: string) => Promise<string>;
+export interface ProjectMember {
+    person: string;
+    state: "read" | "member-limit" | "no-identity";
+    /** The proposal that names this person a member; read only with `includeProposed`. */
+    proposed?: string;
+    score?: number;
+}
 export interface LinkedChat {
     provider: string;
     account: string;
     chat: string;
     /** The link's free role (`source report`, `what worked`), if the owner set one. */
     role: string | null;
+    /** What the chat is for in the project; `null` means `work`. */
+    purpose: string | null;
+    /** The confirmed link's id; null for a proposed one. */
+    relationship: string | null;
+    /** The proposal that links the chat; only with `includeProposed`. */
+    proposed?: string;
+    score?: number;
+}
+/**
+ * Links the owner confirmed, then, when asked, the proposed ones: a suggestion would put a whole chat into the
+ * evidence on a guess, so it is read only on request and marked.
+ */
+export declare const linkedChatsOf: (store: MessageStore, project: string | null, options?: {
+    includeProposed?: boolean;
+}) => Promise<LinkedChat[]>;
+/** A linked chat whose purpose this run did not read: counted, never listed. */
+export interface LeftOutChat {
+    ref: string;
+    provider: string;
+    account: string;
+    chat: string;
+    title: string | null;
+    purpose: string;
+    relationship: string | null;
+    proposed?: string;
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
 }
-/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-export declare const linkedChatsOf: (store: MessageStore, project: string | null) => Promise<LinkedChat[]>;
-export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvidence>> & {
+type Gathered = Awaited<ReturnType<typeof gatherProjectEvidence>>;
+export type StoredProjectGathering = Omit<Gathered, "items" | "linkedChats"> & {
+    /** `proposed`: the proposal whose link alone brought the item in; only with `includeProposed`. */
+    items: (Gathered["items"][number] & {
+        proposed?: string;
+    })[];
+    linkedChats: (Gathered["linkedChats"][number] & {
+        purpose: string;
+        proposed?: string;
+        score?: number;
+    })[];
     projectRef: string | null;
     unreadSources: {
         source: string;
@@ -51,9 +114,21 @@ export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvid
         reason?: "out-of-scope" | "linked-chat-limit" | "member-limit" | "no-identity" | "unknown-provider";
     }[];
     mentions: EvidenceMentions;
+    /** The purposes read: `all`, or the list. */
+    purposes: "all" | string[];
+    leftOut: LeftOutChat[];
+    members: ProjectMember[];
+    /** One linked chat with no purpose set gave most of this run's items; a first run only, so it is said once. */
+    purposeHint: {
+        chat: string;
+        relationship: string;
+        items: number;
+        of: number;
+    } | null;
 };
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
  * confirmed person members and its confirmed linked chats, in the sources the host resolved.
  */
 export declare const gatherStoredProject: (store: MessageStore, input: StoredProjectInput) => Promise<StoredProjectGathering>;
+export {};

package/dist/services/stored-project-gathering.js

@@ -4,6 +4,21 @@ import { chatCoverage } from "./chat-coverage.js";
 import { gatherProjectEvidence } from "./project-gathering.js";
 import { storedNeighbours } from "./project-gathering-around.js";
 import { findEvidenceMentions } from "./project-gathering-mentions.js";
+import { LINK_PURPOSE, purposeRead, purposesOf } from "./project-purposes.js";
+/** The store's count of one chat's messages in a window, `until` exclusive, and the first and last of them. */
+export const storedChatCount = (store) => async (account, chatId, { since, until }) => {
+    const window = { since: new Date(since).toISOString(), until: new Date(until - 1).toISOString() };
+    const [messages, newest, oldest] = await Promise.all([
+        store.messages.countMessages(account, chatId, window),
+        store.messages.messages(account, chatId, { limit: 1, since: window.since, until: until - 1 }),
+        store.messages.messages(account, chatId, { limit: 1, after: { time: since - 1 }, until: until - 1 }),
+    ]);
+    return {
+        messages,
+        firstAt: oldest.items[0]?.timestamp ?? null,
+        lastAt: newest.items.at(-1)?.timestamp ?? null,
+    };
+};
 const PROJECT_ID = /^project:[1-9]\d*$/;
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export const canonicalProjectRef = async (store, reference) => {
@@ -85,59 +100,122 @@ const contactOf = async (store, contact) => {
 };
 const LINKED_CHATS = 16;
 const CORE_LIMIT = 16;
-/** Confirmed `person` members, in a stable order, so a cut at the lane limit always drops the same ones. */
-const memberRefsOf = async (store, project) => {
+/** Pending `member-of` proposals to the project, oldest first, so a cut at a limit always drops the same ones. */
+const proposedLinksOf = async (store, project) => {
+    const stored = await store.proposedActions.list({ kinds: ["relationship"], status: "proposed", project, limit: 500 });
+    const proposals = stored
+        .flatMap((action) => {
+        const payload = action.payload;
+        const { purpose, score } = action.payload;
+        if (payload?.kind !== "member-of" || payload.to !== project || typeof payload.from !== "string")
+            return [];
+        return [
+            {
+                from: payload.from,
+                id: action.id,
+                role: typeof payload.role === "string" ? payload.role : null,
+                purpose: typeof purpose === "string" ? purpose : null,
+                ...(typeof score === "number" ? { score } : {}),
+            },
+        ];
+    })
+        .sort((a, b) => Number(a.id) - Number(b.id));
+    const legacy = (await store.knowledge.relations(null, project))
+        .filter((one) => !one.confirmed && one.kind === "member-of" && one.to === project)
+        .map((one) => ({ from: one.from, id: `link:${one.id}`, role: one.role, purpose: one.purpose }));
+    return [...proposals, ...legacy];
+};
+/** Confirmed `person` members in a stable order, then proposed ones when asked, so a cut drops the same ones. */
+const memberRefsOf = async (store, project, includeProposed) => {
     if (!project)
         return [];
-    const refs = [];
+    const confirmed = new Set();
     for (const relation of await store.knowledge.relations(null, project))
         if (relation.confirmed &&
             relation.kind === "member-of" &&
             relation.to === project &&
             /^person:.+/.test(relation.from))
-            refs.push(relation.from);
-    return [...new Set(refs)].sort();
+            confirmed.add(relation.from);
+    const members = [...confirmed].sort().map((ref) => ({ ref }));
+    if (!includeProposed)
+        return members;
+    for (const one of await proposedLinksOf(store, project))
+        if (/^person:.+/.test(one.from) && !members.some((member) => member.ref === one.from))
+            members.push({ ref: one.from, proposed: one.id, ...(one.score === undefined ? {} : { score: one.score }) });
+    return members;
 };
 /**
  * Members are read by what their identities wrote, like `--contact person:<id>` but without the owner's aliases:
  * a short alias would add a text lane that matches mentions, and membership is about who wrote, not who was named.
  */
-const memberLanesOf = async (store, project, given, room) => {
+const memberLanesOf = async (store, project, given, room, includeProposed) => {
     const lanes = [];
     const left = [];
-    for (const reference of (await memberRefsOf(store, project)).filter((one) => !given.has(one))) {
+    const rows = [];
+    for (const member of (await memberRefsOf(store, project, includeProposed)).filter((one) => !given.has(one.ref))) {
+        const { ref: reference, ...marks } = member;
         const person = await store.people.personByUid(reference.slice("person:".length));
         const senders = person ? sendersOf(person) : [];
-        if (!senders.length)
-            left.push({ source: reference, kind: "member", reason: "no-identity" });
-        else if (lanes.length >= room)
-            left.push({ source: reference, kind: "member", reason: "member-limit" });
-        else
+        const state = !senders.length ? "no-identity" : lanes.length >= room ? "member-limit" : "read";
+        if (state === "read")
             lanes.push({ reference, senders });
+        else
+            left.push({ source: reference, kind: "member", reason: state });
+        rows.push({ person: reference, state, ...marks });
     }
-    return { lanes, left };
+    return { lanes, left, rows };
 };
-/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-export const linkedChatsOf = async (store, project) => {
+const chatOf = (from) => {
+    if (!from.startsWith("chat:"))
+        return undefined;
+    const reference = parseReference(from);
+    return reference.type === "chat" ? reference : undefined;
+};
+/**
+ * Links the owner confirmed, then, when asked, the proposed ones: a suggestion would put a whole chat into the
+ * evidence on a guess, so it is read only on request and marked.
+ */
+export const linkedChatsOf = async (store, project, options = {}) => {
     if (!project)
         return [];
     const chats = [];
     for (const relation of await store.knowledge.relations(null, project)) {
         if (!relation.confirmed || relation.kind !== "member-of" || relation.to !== project)
             continue;
-        if (!relation.from.startsWith("chat:"))
-            continue;
-        const reference = parseReference(relation.from);
-        if (reference.type === "chat")
+        const reference = chatOf(relation.from);
+        if (reference)
             chats.push({
                 provider: reference.provider,
                 account: reference.account,
                 chat: reference.chat,
                 role: relation.role,
+                purpose: relation.purpose,
+                relationship: relation.id,
             });
     }
+    if (!options.includeProposed)
+        return chats;
+    for (const one of await proposedLinksOf(store, project)) {
+        const reference = chatOf(one.from);
+        if (!reference)
+            continue;
+        if (chats.some((chat) => chat.provider === reference.provider && chat.account === reference.account && chat.chat === reference.chat))
+            continue;
+        chats.push({
+            provider: reference.provider,
+            account: reference.account,
+            chat: reference.chat,
+            role: one.role,
+            purpose: one.purpose,
+            relationship: null,
+            proposed: one.id,
+            ...(one.score === undefined ? {} : { score: one.score }),
+        });
+    }
     return chats;
 };
+/** Over half the items and at least this many, from one chat's membership alone: worth asking what the chat is for. */
+const HINT_ITEMS = 20;
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
  * confirmed person members and its confirmed linked chats, in the sources the host resolved.
@@ -160,9 +238,12 @@ export const gatherStoredProject = async (store, input) => {
         (input.keywords?.length ?? 0) +
         contacts.filter((one) => one.name).length;
     const room = Math.min(CORE_LIMIT - contacts.length, CORE_LIMIT - searchLanes - contacts.filter((one) => one.senders).length);
-    const members = await memberLanesOf(store, project.ref, new Set(contacts.flatMap((one) => one.reference ?? [])), room);
+    const includeProposed = input.includeProposed === true;
+    const purposes = purposesOf(input.purposes, input.purposeConfig, project);
+    const members = await memberLanesOf(store, project.ref, new Set(contacts.flatMap((one) => one.reference ?? [])), room, includeProposed);
     const people = [...contacts, ...members.lanes];
-    const linked = await linkedChatsOf(store, project.ref);
+    const all = await linkedChatsOf(store, project.ref, { includeProposed });
+    const linked = all.filter((one) => purposeRead(purposes, one.purpose));
     const linkedChats = linked.slice(0, LINKED_CHATS).map(({ provider, account, chat }) => ({ provider, account, chat }));
     const budgets = {
         ...(input.maxReads === undefined ? {} : { maxReads: input.maxReads }),
@@ -208,5 +289,73 @@ export const gatherStoredProject = async (store, input) => {
             reason: "linked-chat-limit",
         })),
     ];
-    return { projectRef: project.ref, unreadSources: [...unread, ...unreadChats, ...members.left], ...gathered, mentions };
+    const refOf = (one) => formatReference({ type: "chat", ...one });
+    const byRef = new Map(linked.map((one) => [refOf(one), one]));
+    const proposedLanes = new Map();
+    for (const row of gathered.linkedChats) {
+        const proposed = byRef.get(row.ref)?.proposed;
+        if (proposed && row.lane !== null)
+            proposedLanes.set(row.lane, proposed);
+    }
+    for (const lane of gathered.lanes) {
+        const proposed = members.rows.find((one) => one.proposed && lane.people.includes(one.person))?.proposed;
+        if (proposed && lane.kinds.includes("sender"))
+            proposedLanes.set(lane.id, proposed);
+    }
+    // Marked only when nothing but proposed links found it: an item a word or a confirmed link found is evidence anyway.
+    const items = gathered.items.map((item) => {
+        const proposed = item.lanes.every((lane) => proposedLanes.has(lane))
+            ? proposedLanes.get(item.lanes[0] ?? "")
+            : undefined;
+        return proposed ? { ...item, proposed } : item;
+    });
+    const linkedRows = gathered.linkedChats.map((row) => {
+        const link = byRef.get(row.ref);
+        return {
+            ...row,
+            purpose: link?.purpose ?? LINK_PURPOSE,
+            ...(link?.proposed ? { proposed: link.proposed } : {}),
+            ...(link?.score === undefined ? {} : { score: link.score }),
+        };
+    });
+    const count = input.count ?? storedChatCount(store);
+    const leftOut = [];
+    for (const one of all.filter((chat) => !purposeRead(purposes, chat.purpose))) {
+        const account = { provider: one.provider, account: one.account };
+        const [counted, [held]] = await Promise.all([
+            count(account, one.chat, { since: gathered.window.after, until: gathered.window.before }),
+            chatCoverage(store, account, [one.chat]),
+        ]);
+        leftOut.push({
+            ref: refOf(one),
+            provider: one.provider,
+            account: one.account,
+            chat: one.chat,
+            title: held?.title ?? null,
+            purpose: one.purpose ?? LINK_PURPOSE,
+            relationship: one.relationship,
+            ...(one.proposed ? { proposed: one.proposed } : {}),
+            ...counted,
+        });
+    }
+    return {
+        projectRef: project.ref,
+        unreadSources: [...unread, ...unreadChats, ...members.left],
+        ...gathered,
+        items,
+        linkedChats: linkedRows,
+        mentions,
+        purposes: purposes === "all" ? "all" : [...purposes],
+        leftOut,
+        members: members.rows,
+        purposeHint: gathered.resumed ? null : purposeHintOf(linked, linkedRows, items.length),
+    };
+};
+const purposeHintOf = (linked, rows, of) => {
+    const [top] = [...rows].sort((a, b) => (b.items ?? 0) - (a.items ?? 0));
+    const items = top?.items ?? 0;
+    const link = linked.find((one) => formatReference({ type: "chat", ...one }) === top?.ref);
+    if (!top || !link?.relationship || link.purpose !== null || items < HINT_ITEMS || items * 2 <= of)
+        return null;
+    return { chat: top.ref, relationship: link.relationship, items, of };
 };

package/dist/speech/local.d.ts

@@ -5,6 +5,8 @@ export interface LocalSpeechRecognitionModel {
     engine: "sherpa-onnx";
     model: string;
     version: string;
+    /** The one language the model writes; absent for a multilingual model. */
+    language?: string;
     sampleRate: 16000;
     maxChunkSamples: 480000;
 }

package/dist/speech/local.js

@@ -23,7 +23,14 @@ export const localSpeechRecognitionModel = (id) => {
         featureDim: model.featureDim,
     }))
         .digest("hex");
-    return Object.freeze({ engine: "sherpa-onnx", model: model.id, version, sampleRate: 16000, maxChunkSamples: 480000 });
+    return Object.freeze({
+        engine: "sherpa-onnx",
+        model: model.id,
+        version,
+        ...(model.language === undefined ? {} : { language: model.language }),
+        sampleRate: 16000,
+        maxChunkSamples: 480000,
+    });
 };
 const notInstalled = (id) => new CliError("not_found", `speech model ${id} is not installed; download it explicitly with a WireCat messenger's models download command`, { reason: "model.not-downloaded", model: id });
 /**

package/dist/speech/models.d.ts

@@ -18,6 +18,8 @@ export interface SpeechModel {
     id: string;
     title: string;
     languages: string;
+    /** The one language the model writes, so its transcripts need no guessing; absent for multilingual models. */
+    language?: string;
     files: ModelFile[];
     /** The part of sherpa-onnx's `modelConfig` that names the files, given where they are. */
     config: (path: (name: string) => string) => Record<string, unknown>;

package/dist/speech/models.js

@@ -8,6 +8,7 @@ export const MODELS = [
         id: "gigaam-v3",
         title: "GigaAM v3, with punctuation",
         languages: "Russian — the best of the three for Russian",
+        language: "ru",
         featureDim: 64,
         files: [
             {
@@ -45,6 +46,7 @@ export const MODELS = [
         id: "gigaam-v3-ctc",
         title: "GigaAM v3 CTC, with punctuation — a little faster",
         languages: "Russian — a little faster, rougher with capital letters",
+        language: "ru",
         featureDim: 64,
         files: [
             {

package/dist/store/driver.d.ts

@@ -23,7 +23,18 @@ export interface CacheDatabase {
     exec(sql: string): void;
     prepare(sql: string): CacheStatement;
     close(): void;
+    /**
+     * Set when the connection has `TIME_LIMIT_FUNCTION`. A statement runs to its end before any timer can fire, so a
+     * long one is stopped from inside: `WHERE … AND wc_time_limit(<epoch ms>)` throws `TimeLimitReached` once past it.
+     */
+    timeLimit?: true;
 }
+export declare const TIME_LIMIT_FUNCTION = "wc_time_limit";
+export declare class TimeLimitReached extends Error {
+    constructor();
+}
+/** The SQL function's body: 1 until `until` (epoch milliseconds) has passed. */
+export declare const beforeTimeLimit: (until: unknown) => number;
 export type OpenDatabase = (path: string) => CacheDatabase;
 /**
  * **Write-ahead mode, and a timeout rather than an instant failure.**

package/dist/store/driver.js

@@ -9,6 +9,19 @@
  * The surface is deliberately tiny. Everything above it is ordinary SQL, so replacing the driver —
  * or adding a third — is writing thirty lines, not learning an abstraction.
  */
+export const TIME_LIMIT_FUNCTION = "wc_time_limit";
+export class TimeLimitReached extends Error {
+    constructor() {
+        super("the statement ran past its time limit");
+        this.name = "TimeLimitReached";
+    }
+}
+/** The SQL function's body: 1 until `until` (epoch milliseconds) has passed. */
+export const beforeTimeLimit = (until) => {
+    if (Date.now() > Number(until))
+        throw new TimeLimitReached();
+    return 1;
+};
 /**
  * **Write-ahead mode, and a timeout rather than an instant failure.**
  *

package/dist/store/drivers/node-sqlite.d.ts

@@ -1,5 +1,5 @@
 import { DatabaseSync } from "node:sqlite";
-import type { CacheDatabase } from "../driver.js";
+import { type CacheDatabase } from "../driver.js";
 /**
  * Import this module only through a dynamic import that follows `quietSqliteWarning()`: a static import loads
  * `node:sqlite`, and on Node 22 its ExperimentalWarning, before the filter can run.

package/dist/store/drivers/node-sqlite.js

@@ -1,5 +1,6 @@
 // biome-ignore-all lint/plugin/no-sqlite-driver: cli-core owns the store, so it opens the driver itself
 import { DatabaseSync } from "node:sqlite";
+import { beforeTimeLimit, TIME_LIMIT_FUNCTION, } from "../driver.js";
 import { loadVectorExtension, vectorExtension } from "../vector-extension.js";
 /**
  * Import this module only through a dynamic import that follows `quietSqliteWarning()`: a static import loads
@@ -29,6 +30,7 @@ export const nodeClient = async (path, { readOnly = false } = {}) => {
 export const STATEMENT_CACHE_SIZE = 1000;
 export const cacheOverNodeSqlite = (database, cacheSize = STATEMENT_CACHE_SIZE) => {
     const statements = new Map();
+    database.function(TIME_LIMIT_FUNCTION, { deterministic: false, directOnly: true }, beforeTimeLimit);
     const prepare = (sql) => {
         const statement = database.prepare(sql);
         return {
@@ -38,6 +40,7 @@ export const cacheOverNodeSqlite = (database, cacheSize = STATEMENT_CACHE_SIZE)
         };
     };
     return {
+        timeLimit: true,
         exec: (sql) => database.exec(sql),
         prepare: (sql) => {
             const cached = statements.get(sql);

package/dist/store/messages.d.ts

@@ -45,9 +45,10 @@ export interface AccountMessages {
      * ends the window; `reads.MessagePageWindow` says how.
      */
     messages(key: AccountKey, chatId: Id, window: reads.MessagePageWindow): Promise<Page<Message>>;
-    /** How many stored messages the chat has, sent at `since` or later when it is given. */
+    /** How many stored messages the chat has, sent at `since` or later and at `until` or earlier when given. */
     countMessages(key: AccountKey, chatId: Id, options?: {
         since?: string;
+        until?: string;
     }): Promise<number>;
     /** Saved or edited after `at` (ISO, this machine's clock), oldest first, and the ids deleted after it. */
     changes(key: AccountKey, chatId: Id, at: string): Promise<{

package/dist/store/messages.js

@@ -32,9 +32,9 @@ export const accountMessagesOver = (context) => {
             const chatKey = chatKeyOf(key, chatId);
             return chatKey === undefined ? { items: [], hasMore: false } : reads.messagePage(context, chatKey, window);
         },
-        countMessages: async (key, chatId, { since } = {}) => {
+        countMessages: async (key, chatId, { since, until } = {}) => {
             const chatKey = chatKeyOf(key, chatId);
-            return chatKey === undefined ? 0 : reads.countMessages(context, chatKey, since);
+            return chatKey === undefined ? 0 : reads.countMessages(context, chatKey, since, until);
         },
         changes: async (key, chatId, at) => {
             const chatKey = chatKeyOf(key, chatId);

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

@@ -1,6 +1,6 @@
 import type { Page } from "../../domain/models.js";
 import type { QueryExecution } from "../../search/lucene/resolved.js";
-import type { SqlValue } from "../driver.js";
+import { type SqlValue } from "../driver.js";
 import type { StoreContext } from "./open.js";
 import type { ScoredHit } from "./words.js";
 export { type Corpus, prefixOf } from "./lucene-fields.js";

package/dist/store/sqlite/lucene.js

@@ -1,7 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
 import { compileAutomaton } from "../../search/lucene/automaton.js";
 import { isStemmed } from "../../search/lucene/resolved.js";
-import { exhausted, QUERY_LIMITS, searchError } from "../../search/lucene/types.js";
+import { exhausted, outOfTime, QUERY_LIMITS, searchError } from "../../search/lucene/types.js";
+import { TIME_LIMIT_FUNCTION, TimeLimitReached } from "../driver.js";
 import { emailHitsByPk } from "./emails.js";
 import { placeHits } from "./hit-places.js";
 import { combine, FIELD_COMPILERS, ftsMatch, SPEECH, } from "./lucene-fields.js";
@@ -54,7 +55,7 @@ export const countMatches = (context, execution, cap) => matchingPks(context, ex
  * The keys of the messages that match, no more than `cap + 1`: one SQL query, unranked. `undefined` when a leaf is
  * checked row by row (a preset, a pattern), where it would cost as much as the search itself.
  */
-export const matchingPks = (context, execution, cap) => {
+export const matchingPks = (context, execution, cap) => inTime(() => {
     const { database, check, where, from, withRanking, ranked, leaves } = compileQuery(context, {
         ...execution,
         newest: true,
@@ -66,6 +67,19 @@ export const matchingPks = (context, execution, cap) => {
         .all(...ranked.params, ...where.params, cap + 1);
     check();
     return rows.map(({ id }) => Number(id));
+});
+const timeLimited = (error) => {
+    if (error instanceof TimeLimitReached)
+        outOfTime();
+    throw error;
+};
+const inTime = (work) => {
+    try {
+        return work();
+    }
+    catch (error) {
+        return timeLimited(error);
+    }
 };
 const compileQuery = (context, execution, boundedAttachments = false) => {
     const { database } = context;
@@ -74,6 +88,7 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
     if (mail && (execution.conversationIds || execution.conversationSince !== undefined))
         throw new CliError("validation_error", "mail has no conversations to search within");
     const started = context.now();
+    const until = Date.now() + QUERY_LIMITS.milliseconds;
     const budget = { work: 0 };
     let states = 0, expansions = 0;
     const patterns = new Map();
@@ -82,7 +97,7 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
         if (execution.signal?.aborted)
             throw new CliError("validation_error", "search was aborted", { reason: "query.aborted", complete: false });
         if (context.now() - started > QUERY_LIMITS.milliseconds)
-            exhausted("time");
+            outOfTime();
     };
     const patternOf = (pattern, node) => {
         check();
@@ -197,7 +212,10 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
                 exact: true,
             })), "OR"),
         ], "AND");
-    let where = combine([{ sql: "m.deleted_at IS NULL", params: [], exact: true }, scope, expression], "AND");
+    const timeLimit = database.timeLimit
+        ? [{ sql: `${TIME_LIMIT_FUNCTION}(?)`, params: [until], exact: true }]
+        : [];
+    let where = combine([{ sql: "m.deleted_at IS NULL", params: [], exact: true }, scope, expression, ...timeLimit], "AND");
     if (execution.conversationIds !== undefined || execution.conversationSince !== undefined) {
         const ids = execution.conversationIds;
         where = combine([
@@ -404,7 +422,7 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
 /** The matcher and its consumer run synchronously in one read snapshot; exact keys stay in SQL. */
 export const withQuerySelection = (context, execution, consume) => {
     const { database } = context;
-    return read(database, () => {
+    return inTime(() => read(database, () => {
         const query = compileQuery(context, execution, true);
         const { check, leaves, where, from, withRanking, ranked } = query;
         check();
@@ -448,9 +466,17 @@ export const withQuerySelection = (context, execution, consume) => {
             throw new Error("query selection consumers must run synchronously");
         check();
         return result;
-    });
+    }));
+};
+const runQuery = (context, execution, by) => {
+    try {
+        return runCompiled(context, execution, by).catch(timeLimited);
+    }
+    catch (error) {
+        return timeLimited(error);
+    }
 };
-const runQuery = async (context, execution, by) => {
+const runCompiled = async (context, execution, by) => {
     const { corpus, rowsFrom, hits, database, check, grouped, where, from, withRanking, ranked, leaves, stemmed, exactTier, driver, baseFrom, filtered, ranking, relevance, rankedFrom, exactColumn, order, placeTier, projection, projectionParams, joinedFrom, evaluate, } = compileQuery(context, execution);
     if (by === "pks" && leaves.every(({ test }) => !test)) {
         const rows = database

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

@@ -121,9 +121,9 @@ export function meetingHitSearchOver({ database }) {
                 if (after)
                     params.push(after.tier, after.tier, after.started, after.started, after.meeting, after.meeting, after.kind, after.kind, after.id);
                 const sql = `WITH matches AS (${matching}), matching AS (SELECT rid,tier FROM matches h WHERE NOT EXISTS(SELECT 1 FROM meeting_index_pending p WHERE p.id=h.rid/4 AND p.indexable_type=CASE h.rid%4 WHEN 1 THEN 'meeting_transcript_row' WHEN 2 THEN 'meeting_chat_message' ELSE 'meeting_summary' END)), selected AS (SELECT m.id,coalesce(m.started_at,0) AS started FROM meetings m WHERE ${clauses.join(" AND ")}), hits AS (
-        SELECT h.tier,m.started,m.id AS meeting_id,0 AS kind,r.id,r.start_ms,${bytes("r", ["text"])} AS bytes,t.id AS transcript_id,r.position FROM matching h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4 JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id AND t.superseded_at IS NULL AND t.deleted_at IS NULL JOIN selected m ON m.id=t.meeting_id
-        UNION ALL SELECT h.tier,m.started,m.id,1,c.id,NULL,${bytes("c", ["text"])},NULL,NULL FROM matching h JOIN meeting_chat_messages c ON h.rid%4=2 AND c.id=h.rid/4 JOIN selected m ON m.id=c.meeting_id
-        UNION ALL SELECT h.tier,m.started,m.id,2,s.id,NULL,${bytes("s", fields)},NULL,NULL FROM matching h JOIN meeting_summaries s ON h.rid%4=3 AND s.id=h.rid/4 JOIN selected m ON m.id=s.meeting_id)
+        SELECT h.tier,m.started,m.id AS meeting_id,0 AS kind,r.id,r.start_ms,${bytes("r", ["text"])} AS bytes,t.id AS transcript_id,r.position,t.language,(SELECT count(*) FROM meeting_transcript_rows n WHERE n.meeting_transcript_id=t.id) AS lines_total FROM matching h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4 JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id AND t.superseded_at IS NULL AND t.deleted_at IS NULL JOIN selected m ON m.id=t.meeting_id
+        UNION ALL SELECT h.tier,m.started,m.id,1,c.id,NULL,${bytes("c", ["text"])},NULL,NULL,NULL,NULL FROM matching h JOIN meeting_chat_messages c ON h.rid%4=2 AND c.id=h.rid/4 JOIN selected m ON m.id=c.meeting_id
+        UNION ALL SELECT h.tier,m.started,m.id,2,s.id,NULL,${bytes("s", fields)},NULL,NULL,NULL,NULL FROM matching h JOIN meeting_summaries s ON h.rid%4=3 AND s.id=h.rid/4 JOIN selected m ON m.id=s.meeting_id)
         SELECT h.*,${bytes("m", ["title"])}+${bytes("s", ["doc_url"])} AS context_bytes FROM hits h
         JOIN meetings m ON m.id=h.meeting_id LEFT JOIN meeting_summaries s ON h.kind=2 AND s.id=h.id
         ${seek} ORDER BY h.tier,h.started DESC,h.meeting_id,h.kind,h.id LIMIT ?`;
@@ -176,6 +176,13 @@ export function meetingHitSearchOver({ database }) {
                         id: Number(row.id),
                         text,
                         startMs: row.start_ms === null ? null : Number(row.start_ms),
+                        ...(kind === 0
+                            ? {
+                                language: row.language === null ? null : String(row.language),
+                                line: Number(row.position) + 1,
+                                linesTotal: Number(row.lines_total),
+                            }
+                            : {}),
                     };
                 });
                 const fresh = items.flatMap((item) => {