@wirecat/cli-core 0.550.0 → 0.552.0

package/dist/services/project-status/signals/coverage.js

@@ -0,0 +1,30 @@
+/** What the store holds of a chat it does not hold whole; the answer adds the line that syncs it. */
+export const coverage = {
+    id: "coverage",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        if (!chat || chat.coverage.completeness.state === "complete")
+            return [];
+        const { completeness, held } = chat.coverage;
+        const oldest = held.oldestAt === null ? null : Date.parse(held.oldestAt);
+        return [
+            {
+                signal: "coverage",
+                chat: chat.ref,
+                at: completeness.fetchedAt,
+                who: null,
+                evidence: [],
+                basis: "store",
+                data: {
+                    state: completeness.state,
+                    held,
+                    beforeHeld: completeness.state !== "complete" && (oldest === null || context.since < oldest),
+                },
+            },
+        ];
+    },
+    attention: (items) => items.flatMap((item) => item.chat !== null && item.data.state !== "complete" && item.data.beforeHeld
+        ? [{ chat: item.chat, weight: 3, why: "held in part" }]
+        : []),
+};

package/dist/services/project-status/signals/index.d.ts

@@ -0,0 +1,3 @@
+import type { StatusSignal } from "../types.js";
+/** The registry; its order is the answer's order. A new signal is one file here and its row in the CLI. */
+export declare const STATUS_SIGNALS: readonly StatusSignal[];

package/dist/services/project-status/signals/index.js

@@ -0,0 +1,21 @@
+import { amounts } from "./amounts.js";
+import { children } from "./children.js";
+import { coverage } from "./coverage.js";
+import { lastMessage } from "./last-message.js";
+import { payments } from "./payments.js";
+import { promises } from "./promises.js";
+import { questions } from "./questions.js";
+import { replyNext } from "./reply-next.js";
+import { topics } from "./topics.js";
+/** The registry; its order is the answer's order. A new signal is one file here and its row in the CLI. */
+export const STATUS_SIGNALS = [
+    lastMessage,
+    replyNext,
+    questions,
+    promises,
+    amounts,
+    payments,
+    topics,
+    coverage,
+    children,
+];

package/dist/services/project-status/signals/last-message.d.ts

@@ -0,0 +1,4 @@
+import type { StatusSignal } from "../types.js";
+export type LastMessageData = Record<string, never>;
+/** The newest stored message in the window: when, and who wrote it. A chat held in part says so through `coverage`. */
+export declare const lastMessage: StatusSignal<LastMessageData>;

package/dist/services/project-status/signals/last-message.js

@@ -0,0 +1,22 @@
+import { evidenceOf, whoOf } from "../items.js";
+/** The newest stored message in the window: when, and who wrote it. A chat held in part says so through `coverage`. */
+export const lastMessage = {
+    id: "last-message",
+    version: 1,
+    scope: "chat",
+    read: async (_context, chat) => {
+        const last = chat?.messages.at(-1);
+        if (!chat || !last)
+            return [];
+        const item = {
+            signal: "last-message",
+            chat: chat.ref,
+            at: last.timestamp,
+            who: whoOf(last),
+            evidence: evidenceOf(chat, last),
+            basis: "store",
+            data: {},
+        };
+        return [item];
+    },
+};

package/dist/services/project-status/signals/payments.d.ts

@@ -0,0 +1,9 @@
+import { type Payment } from "../../../meetings/index.js";
+import type { StatusSignal } from "../types.js";
+export interface PaymentsData extends Payment {
+    title: string;
+    /** The fact's review status: proposed or accepted. */
+    status: string;
+}
+/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+export declare const payments: StatusSignal<PaymentsData>;

package/dist/services/project-status/signals/payments.js

@@ -0,0 +1,24 @@
+import { paymentTitle } from "../../../meetings/index.js";
+const HOLDING = new Set(["proposed", "accepted"]);
+/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+export const payments = {
+    id: "payments",
+    version: 2,
+    scope: "project",
+    read: async (context) => {
+        const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
+        const facts = (await Promise.all(projects.map((project) => context.store.facts.list({ project, type: "payment", limit: 500 })))).flat();
+        return facts
+            .filter((fact) => fact.payment !== null && HOLDING.has(fact.status))
+            .map((fact) => ({
+            signal: "payments",
+            chat: null,
+            at: fact.occurredAt ?? fact.createdAt,
+            who: null,
+            // The fact first, then what it cites, so an amount read from a cited message is not counted twice.
+            evidence: [fact.ref, ...fact.evidence].map((ref) => ({ ref, fingerprint: null })),
+            basis: "fact",
+            data: { ...fact.payment, title: paymentTitle(fact), status: fact.status },
+        }));
+    },
+};

package/dist/services/project-status/signals/promises.d.ts

@@ -0,0 +1,17 @@
+import type { StatusSignal } from "../types.js";
+export interface PromisesData {
+    /** Where it came from: a stored task, a recorded fact, or a word match in a message (a guess). */
+    source: "task" | "fact" | "pattern";
+    /** `promise` or `request` for a task; a fact's and a pattern's are promises. */
+    kind: string;
+    title: string;
+    /** Who promised, for a pattern: the owner (`yours`) or the other side. */
+    side: "yours" | "theirs" | null;
+    due: string | null;
+    status: string;
+}
+/**
+ * Open promise and request tasks of the project or from its chats, promise facts proposed or accepted, and up to
+ * three promises per chat found by first person future words ("сделаю", "I'll send"), marked as patterns.
+ */
+export declare const promises: StatusSignal<PromisesData>;

package/dist/services/project-status/signals/promises.js

@@ -0,0 +1,109 @@
+import { CliError } from "@wirecat/cli-base";
+import { isLocator, parseLocator } from "../../../domain/locator.js";
+import { PROMISE_FORMS } from "../../../domain/status-words.js";
+import { dueDayOf } from "../../../search/task-signature.js";
+import { normalize } from "../../../store/normalize.js";
+import { inboxKey } from "../../../store/store.js";
+import { taskAccount } from "../../task-rules.js";
+import { day, evidenceOf, excerpt, fromOwner, whoOf } from "../items.js";
+const PATTERNS_PER_CHAT = 3;
+const DAY = 86_400_000;
+const KINDS = new Set(["promise", "request"]);
+const OPEN = new Set(["open", "todo", "in_progress"]);
+const chatOfSource = (context, source) => {
+    if (source === null || !isLocator(source))
+        return undefined;
+    const { provider, account, chat } = parseLocator(source);
+    return context.chats.find((one) => one.account.provider === provider && one.account.account === account && one.chatId === chat);
+};
+// An account that never had a task has no inbox project yet.
+const orNone = (error) => {
+    if (error instanceof CliError && error.code === "not_found")
+        return [];
+    throw error;
+};
+const tasksOf = async (context) => {
+    const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
+    const accounts = new Map(context.chats.map((chat) => [taskAccount(chat.account), chat.account]));
+    const inboxes = [...accounts.keys()].map(inboxKey);
+    const found = await Promise.all([...projects, ...inboxes].map((project) => context.store.tasks.find({ project, limit: 500 }).catch(orNone)));
+    const projectRefs = new Set(projects);
+    return found
+        .flat()
+        .filter((task) => KINDS.has(task.type) && OPEN.has(task.status))
+        .filter((task) => projectRefs.has(task.project) || chatOfSource(context, task.source) !== undefined);
+};
+const taskItem = (context, task) => ({
+    signal: "promises",
+    chat: chatOfSource(context, task.source)?.ref ?? null,
+    at: task.createdAt,
+    who: null,
+    evidence: [{ ref: task.ref, fingerprint: null }, ...(task.source ? [{ ref: task.source, fingerprint: null }] : [])],
+    basis: "task",
+    data: {
+        source: "task",
+        kind: task.type,
+        title: excerpt(task.title),
+        side: null,
+        due: task.dueAt === null ? null : day(task.dueAt),
+        status: task.status,
+    },
+});
+const patternItems = (chat) => chat.messages
+    .filter((message) => !message.text.includes("?") && PROMISE_FORMS.test(message.text))
+    .slice(-PATTERNS_PER_CHAT)
+    .reverse()
+    .map((message) => {
+    const due = dueDayOf(normalize(message.text), Date.parse(message.timestamp));
+    return {
+        signal: "promises",
+        chat: chat.ref,
+        at: message.timestamp,
+        who: whoOf(message),
+        evidence: evidenceOf(chat, message),
+        basis: "pattern",
+        data: {
+            source: "pattern",
+            kind: "promise",
+            title: excerpt(message.text),
+            side: fromOwner(message) ? "yours" : "theirs",
+            due: due === null ? null : day(due * DAY),
+            status: "open",
+        },
+    };
+});
+/**
+ * Open promise and request tasks of the project or from its chats, promise facts proposed or accepted, and up to
+ * three promises per chat found by first person future words ("сделаю", "I'll send"), marked as patterns.
+ */
+export const promises = {
+    id: "promises",
+    version: 1,
+    scope: "project",
+    read: async (context) => {
+        const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
+        const facts = (await Promise.all(projects.map((project) => context.store.facts.list({ type: "promise", project }))))
+            .flat()
+            .filter((fact) => fact.status === "proposed" || fact.status === "accepted");
+        return [
+            ...(await tasksOf(context)).map((task) => taskItem(context, task)),
+            ...facts.map((fact) => ({
+                signal: "promises",
+                chat: null,
+                at: fact.occurredAt ?? fact.createdAt,
+                who: null,
+                evidence: [{ ref: fact.ref, fingerprint: null }],
+                basis: "fact",
+                data: {
+                    source: "fact",
+                    kind: "promise",
+                    title: excerpt(fact.statement),
+                    side: null,
+                    due: null,
+                    status: fact.status,
+                },
+            })),
+            ...context.chats.flatMap(patternItems),
+        ];
+    },
+};

package/dist/services/project-status/signals/questions.d.ts

@@ -0,0 +1,8 @@
+import type { StatusSignal } from "../types.js";
+export interface QuestionsData {
+    /** `theirs`: someone asked and the owner has not answered; `yours`: the owner asked and nobody answered. */
+    side: "theirs" | "yours";
+    excerpt: string;
+}
+/** Open questions both ways, newest first, at most five a side. A question answered in another chat stays open. */
+export declare const questions: StatusSignal<QuestionsData>;

package/dist/services/project-status/signals/questions.js

@@ -0,0 +1,38 @@
+import { questions as questionsOf } from "../../questions.js";
+import { evidenceOf, excerpt, whoOf } from "../items.js";
+const PER_SIDE = 5;
+const WEEK = 7 * 86_400_000;
+const NOBODY = new Set();
+/** Open questions both ways, newest first, at most five a side. A question answered in another chat stays open. */
+export const questions = {
+    id: "questions",
+    version: 1,
+    scope: "chat",
+    read: async (_context, chat) => {
+        if (!chat)
+            return [];
+        const open = (asker) => questionsOf(chat.messages, { answerers: NOBODY, asker })
+            .filter(({ answer }) => answer === undefined)
+            .map(({ question }) => question)
+            .reverse()
+            .slice(0, PER_SIDE);
+        return [
+            ["theirs", open("others")],
+            ["yours", open("owner")],
+        ].flatMap(([side, asked]) => asked.map((question) => ({
+            signal: "questions",
+            chat: chat.ref,
+            at: question.timestamp,
+            who: whoOf(question),
+            evidence: evidenceOf(chat, question),
+            basis: "store",
+            data: { side, excerpt: excerpt(question.text) },
+        })));
+    },
+    attention: (items, context) => {
+        const stale = new Set(items.flatMap((item) => item.chat !== null && item.data.side === "yours" && item.at && context.now - Date.parse(item.at) > WEEK
+            ? [item.chat]
+            : []));
+        return [...stale].map((chat) => ({ chat, weight: 1, why: "your question unanswered for a week" }));
+    },
+};

package/dist/services/project-status/signals/reply-next.d.ts

@@ -0,0 +1,19 @@
+import type { StatusSignal } from "../types.js";
+export interface ReplyNextData {
+    next: "owner" | "them" | "named" | "nobody";
+    /** Since when the one named has been the one to answer. */
+    waitingSince: string | null;
+    /** In a group: the person the newest message replies to or mentions. */
+    addressed: {
+        ref: string | null;
+        name: string | null;
+    } | null;
+    /** Waited longer than `tasks agenda` does before it lists the chat (a day for you, a week for them). */
+    overdue: boolean;
+}
+/**
+ * Whose move it is, by five rules in order: the owner wrote last → them; a dialog → the owner; in a group a message
+ * that replies to or mentions the owner, or a question right after the owner spoke → the owner; one that names
+ * another member → that member; else nobody. A name typed without a mention is not seen.
+ */
+export declare const replyNext: StatusSignal<ReplyNextData>;

package/dist/services/project-status/signals/reply-next.js

@@ -0,0 +1,75 @@
+import { AGENDA_DEFAULTS } from "../../agenda.js";
+import { evidenceOf, fromOwner, whoOf } from "../items.js";
+/** Whom a message answers or names: the quoted message's sender first, then the first mention. */
+const targetOf = (message, chat, owners) => {
+    const byId = (id) => chat.messages.find((one) => one.id === id);
+    const quoted = message.replyTo ?? (message.replyToId === undefined ? undefined : byId(message.replyToId));
+    if (quoted)
+        return {
+            owner: quoted.outgoing === true || (quoted.senderId !== null && owners.has(quoted.senderId)),
+            id: quoted.senderId,
+            name: quoted.senderName,
+        };
+    const [mentioned] = message.mentions ?? [];
+    if (mentioned === undefined)
+        return undefined;
+    if (owners.has(mentioned))
+        return { owner: true, id: mentioned, name: null };
+    const named = chat.messages.find((one) => one.senderId === mentioned);
+    return { owner: false, id: mentioned, name: named?.senderName ?? null };
+};
+const asksSomething = (message) => message.text.includes("?");
+/**
+ * Whose move it is, by five rules in order: the owner wrote last → them; a dialog → the owner; in a group a message
+ * that replies to or mentions the owner, or a question right after the owner spoke → the owner; one that names
+ * another member → that member; else nobody. A name typed without a mention is not seen.
+ */
+export const replyNext = {
+    id: "reply-next",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        const last = chat?.messages.at(-1);
+        if (!chat || !last)
+            return [];
+        const { messages } = chat;
+        const owners = new Set(messages.flatMap((one) => (fromOwner(one) && one.senderId !== null ? [one.senderId] : [])));
+        const lastOwn = messages.findLastIndex(fromOwner);
+        const firstAfterOwn = messages[lastOwn + 1] ?? messages[0];
+        const target = targetOf(last, chat, owners);
+        const decide = () => {
+            if (last.outgoing === null)
+                return { next: "nobody", addressed: null, since: null };
+            if (fromOwner(last))
+                return {
+                    next: "them",
+                    addressed: chat.kind !== "dialog" && target && !target.owner ? { ref: null, name: target.name } : null,
+                    since: last.timestamp,
+                };
+            const since = firstAfterOwn?.timestamp ?? last.timestamp;
+            if (chat.kind === "dialog")
+                return { next: "owner", addressed: null, since };
+            if (target?.owner || (asksSomething(last) && lastOwn === messages.length - 2))
+                return { next: "owner", addressed: null, since };
+            if (target)
+                return { next: "named", addressed: { ref: null, name: target.name }, since };
+            return { next: "nobody", addressed: null, since };
+        };
+        const { next, addressed, since } = decide();
+        const waited = since === null ? 0 : context.now - Date.parse(since);
+        const overdue = (next === "owner" && waited >= AGENDA_DEFAULTS.unanswered) ||
+            (next === "them" && waited >= AGENDA_DEFAULTS.waiting);
+        return [
+            {
+                signal: "reply-next",
+                chat: chat.ref,
+                at: last.timestamp,
+                who: whoOf(last),
+                evidence: evidenceOf(chat, last),
+                basis: "store",
+                data: { next, waitingSince: since, addressed, overdue },
+            },
+        ];
+    },
+    attention: (items) => items.flatMap((item) => item.chat !== null && item.data.next === "owner" ? [{ chat: item.chat, weight: 2, why: "your move" }] : []),
+};

package/dist/services/project-status/signals/topics.d.ts

@@ -0,0 +1,10 @@
+import type { StatusSignal } from "../types.js";
+export interface TopicsData {
+    query: string;
+    yoursLast: string | null;
+    theirsLast: string | null;
+    /** Their newest mention, when the owner spoke of it later: the other side went quiet on it. */
+    silentSince: string | null;
+}
+/** Per `--context-query`, the newest message of each side that holds every one of its words, in the window. */
+export declare const topics: StatusSignal<TopicsData>;

package/dist/services/project-status/signals/topics.js

@@ -0,0 +1,50 @@
+import { normalize } from "../../../store/normalize.js";
+import { evidenceOf, fromOwner } from "../items.js";
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const wholeWord = (word) => new RegExp(`(?<![\\p{L}\\p{N}])${escaped(word)}(?![\\p{L}\\p{N}])`, "u");
+/** Every word of the query, folded, as a whole word somewhere in the text: `projects evidence`'s reading. */
+const matcherOf = (query) => {
+    const words = normalize(query).split(" ").filter(Boolean).map(wholeWord);
+    return (text) => {
+        const folded = normalize(text);
+        return words.length > 0 && words.every((word) => word.test(folded));
+    };
+};
+/** Per `--context-query`, the newest message of each side that holds every one of its words, in the window. */
+export const topics = {
+    id: "topics",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        if (!chat)
+            return [];
+        return context.contextQueries.flatMap((query) => {
+            const matches = matcherOf(query);
+            const naming = chat.messages.filter((message) => matches(message.text));
+            const yours = naming.findLast(fromOwner);
+            const theirs = naming.findLast((message) => !fromOwner(message));
+            if (!yours && !theirs)
+                return [];
+            const silent = theirs && yours && Date.parse(yours.timestamp) > Date.parse(theirs.timestamp);
+            const newest = [yours, theirs]
+                .filter((one) => one !== undefined)
+                .sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+            return [
+                {
+                    signal: "topics",
+                    chat: chat.ref,
+                    at: newest[0]?.timestamp ?? null,
+                    who: null,
+                    evidence: evidenceOf(chat, ...newest),
+                    basis: "store",
+                    data: {
+                        query,
+                        yoursLast: yours?.timestamp ?? null,
+                        theirsLast: theirs?.timestamp ?? null,
+                        silentSince: silent ? theirs.timestamp : null,
+                    },
+                },
+            ];
+        });
+    },
+};

package/dist/services/project-status/types.d.ts

@@ -0,0 +1,84 @@
+import type { ChatKind, Id, Message } from "../../domain/models.js";
+import type { AccountKey, MessageStore } from "../../store/store.js";
+import type { ChatCoverage } from "../chat-coverage.js";
+/** What every chat signal reads; loaded once per chat by the pipeline. Never printed. */
+export interface StatusChat {
+    /** `chat:<provider>/<account>/<chat>` */
+    ref: string;
+    account: AccountKey;
+    chatId: Id;
+    title: string | null;
+    kind: ChatKind;
+    /** The link's role: "client", "contractor", or null. */
+    role: string | null;
+    /** The chat's purpose in the project; `work` until links carry one. */
+    purpose: string;
+    /** `project:<id>`; a child's id when rolled up. */
+    project: string;
+    coverage: ChatCoverage;
+    /** Oldest first, the window, at most `STATUS_WINDOW`. */
+    messages: Message[];
+}
+export interface StatusProject {
+    ref: string;
+    key: string | null;
+    name: string;
+}
+export interface StatusChild extends StatusProject {
+    parent: string;
+    depth: number;
+}
+export interface StatusContext {
+    now: number;
+    /** Window start, ms. */
+    since: number;
+    chats: StatusChat[];
+    project: StatusProject & {
+        children: StatusChild[];
+        /** Children not read: too deep, seen twice, or past the limit. */
+        cut: {
+            ref: string;
+            reason: "depth" | "cycle" | "limit";
+        }[];
+    };
+    /** Read only: facts, tasks, chats. */
+    store: MessageStore;
+    /** `--context-query` texts: every word of one must appear in one message. */
+    contextQueries: string[];
+}
+export interface StatusWho {
+    ref: string | null;
+    name: string | null;
+    owner: boolean;
+}
+/** One finding of a signal. Stable keys; the signal adds its own under `data`. */
+export interface StatusItem<D = Record<string, unknown>> {
+    signal: string;
+    /** Null for a project level finding. */
+    chat: string | null;
+    /** ISO, when it happened. */
+    at: string | null;
+    who: StatusWho | null;
+    /** `msg:`, `fact:`, `task:` refs. */
+    evidence: {
+        ref: string;
+        fingerprint: string | null;
+    }[];
+    /** How sure: `pattern` is a word match, to check before it is trusted. */
+    basis: "store" | "fact" | "task" | "pattern";
+    data: D;
+}
+export interface StatusAttention {
+    chat: string;
+    weight: number;
+    why: string;
+}
+export interface StatusSignal<D = Record<string, unknown>> {
+    id: string;
+    /** Bumped when the logic changes, so a saved answer says which rules made it. */
+    version: number;
+    scope: "chat" | "project";
+    read(context: StatusContext, chat?: StatusChat): Promise<StatusItem<D>[]>;
+    /** Why a chat should be read next, weight 0 to 3; the pipeline sums them per chat. */
+    attention?(items: StatusItem<D>[], context: StatusContext): StatusAttention[];
+}

package/dist/services/project-status/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/proposals/index.d.ts

@@ -1,3 +1,4 @@
 export { parseProposalIds } from "./ids.js";
+export { FACT_SUMMARIES } from "./kinds/findings.js";
 export { emptyProposalRegistry, proposalRegistry } from "./registry.js";
 export type { Decided, Decision, ProposalFilter, ProposalKind, ProposalRegistry, ProposalRow } from "./types.js";

package/dist/services/proposals/index.js

@@ -1,2 +1,3 @@
 export { parseProposalIds } from "./ids.js";
+export { FACT_SUMMARIES } from "./kinds/findings.js";
 export { emptyProposalRegistry, proposalRegistry } from "./registry.js";

package/dist/services/proposals/kinds/findings.d.ts

@@ -1,5 +1,8 @@
+import type { Finding } from "../../../meetings/index.js";
 import { type MessageStore } from "../../../store/index.js";
 import type { ProposalKind } from "../types.js";
+/** A finding's one line in the inbox, per kind; a new fact kind adds its row here. */
+export declare const FACT_SUMMARIES: Record<string, (finding: Finding) => string>;
 /**
  * An agent's batch of cited facts and tasks from stored messages, mail and documents. Confirming accepts the parts
  * named, or every finding not rejected before; the rest are rejected. Meeting findings stay with their meeting.

package/dist/services/proposals/kinds/findings.js

@@ -1,5 +1,12 @@
+import { paymentTitle } from "../../../meetings/index.js";
 import { EVIDENCE_FINDINGS_KIND } from "../../../store/index.js";
 import { kept, proposerOfAuthor } from "./shared.js";
+/** A finding's one line in the inbox, per kind; a new fact kind adds its row here. */
+export const FACT_SUMMARIES = {
+    fact: (finding) => finding.statement,
+    task: (finding) => finding.title,
+    payment: (finding) => paymentTitle(finding),
+};
 const statusOf = (batch) => batch.status === "proposed" ? "proposed" : batch.receipt?.accepted.length ? "confirmed" : "rejected";
 const rowOf = (batch, createdAt) => {
     const findings = batch.input.findings;
@@ -20,7 +27,7 @@ const rowOf = (batch, createdAt) => {
         parts: findings.map((finding) => ({
             id: finding.id,
             kind: finding.kind,
-            summary: finding.kind === "fact" ? finding.statement : finding.title,
+            summary: FACT_SUMMARIES[finding.kind]?.(finding) ?? finding.kind,
             outcome: outcome(finding.id),
         })),
         createdAt,

package/dist/services/search-all-meetings.d.ts

@@ -22,6 +22,9 @@ export interface MeetingSearchItem {
     /** A transcript hit's cue, `meeting:<account>/<meeting>/<transcript>/<cue>`, which `meetings passage` opens. */
     cueRef?: string;
     speakerName?: string | null;
+    language?: string | null;
+    line?: number;
+    linesTotal?: number;
 }
 export interface MeetingSearchCursor {
     accountId: number;

package/dist/services/search-all-meetings.js

@@ -105,7 +105,12 @@ const collectMeetings = async (store, account, request, query) => {
                     id: hit.id,
                     startMs: hit.startMs,
                     ...(hit.scope === "transcript" && hit.ref !== undefined
-                        ? { cueRef: hit.ref, speakerName: hit.speakerName ?? null }
+                        ? {
+                            cueRef: hit.ref,
+                            speakerName: hit.speakerName ?? null,
+                            language: hit.language ?? null,
+                            ...(hit.line === undefined ? {} : { line: hit.line, linesTotal: hit.linesTotal }),
+                        }
                         : {}),
                 },
             });

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>;