@wirecat/cli-core 0.551.0 → 0.553.0

package/dist/cli/project-evidence.js

@@ -1,7 +1,9 @@
 import { CliError } from "@wirecat/cli-base";
+import { MAX_NEXT_STEPS } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
 import { dateWindow, momentOf } from "../services/moment.js";
 import { coverageGaps, heldPhrase } from "./messenger/search-answers.js";
+import { heldInWindow } from "./project-status.js";
 /** Days back (`90d`) or a start date (`2026-09-01`); either way the run freezes its end, so a resume keeps it. */
 export const projectWindowOf = (value) => {
     const days = /^([1-9]\d{0,2})d$/.exec(value)?.[1];
@@ -33,10 +35,24 @@ const coverageRows = ({ linkedChats }) => linkedChats.flatMap((one) => one.compl
  * The zone a typed start date was read in, and the window the run used, in UTC. `complete` is "the answer is whole":
  * reads finished and every linked chat held in full; the answer's own `complete` stays "reads finished".
  */
-export const projectAnswerParts = (sinceTime, found) => {
+export const projectAnswerParts = (sinceTime, found, hints) => {
     const { window } = found;
     const { timezone } = dateWindow({ sinceTime }).meta;
-    const { next, missing } = coverageGaps(coverageRows(found), 0, new Date(window.after).toISOString());
+    const gaps = coverageGaps(coverageRows(found), 0, new Date(window.after).toISOString());
+    const next = [...gaps.next];
+    const missing = [
+        ...gaps.missing,
+        ...found.leftOut.map((one) => {
+            const read = hints?.read?.(one, day(window.after)) ?? null;
+            return { field: "linked_chats", why: leftOutLine(one, read), ...(read ? { step: "messages.list" } : {}) };
+        }),
+    ];
+    if (found.purposeHint) {
+        const why = purposeHintLine(found.purposeHint);
+        missing.push({ field: "purpose", why });
+        if (next.length < MAX_NEXT_STEPS)
+            next.push({ kind: "user_action", step: "relationships.purpose", why, safe_to_auto_execute: false });
+    }
     return {
         ...(next.length ? { next } : {}),
         ...(missing.length ? { missing } : {}),
@@ -51,19 +67,27 @@ export const projectAnswerParts = (sinceTime, found) => {
  * The gathering with each linked chat's `syncCommand`: the line that syncs a chat held in part back to the window
  * start, or null when it needs none or no command here can. JSON readers get what the text says per chat.
  */
-export const withSyncCommands = (found, sync) => ({
+export const withSyncCommands = (found, sync, read) => ({
     ...found,
     linkedChats: found.linkedChats.map((one) => ({
         ...one,
         syncCommand: one.completeness === null || one.completeness.state === "complete" ? null : sync(one, day(found.window.after)),
     })),
+    leftOut: found.leftOut.map((one) => ({ ...one, readCommand: read?.(one, day(found.window.after)) ?? null })),
 });
+/** One line for a chat left out by its purpose: what it holds in the window and how to read it. */
+const leftOutLine = (one, read) => `${one.title ? `«${one.title}» (${one.ref})` : one.ref}, purpose ${one.purpose}` +
+    `${one.proposed ? `, proposed ${one.proposed}` : ""}, not read: ${heldInWindow(one)}` +
+    (read ? `; read it: ${read}` : `; add --purpose ${one.purpose} to read it here`);
+const purposeHintLine = (hint) => `${hint.chat} gave ${hint.items} of ${hint.of} items by membership alone; if it is not a work chat, ask the owner ` +
+    `to set its purpose: memo relationships update ${hint.relationship} --purpose <purpose>`;
 const LABELS = {
     "person-only": "  [person only]",
     sender: "  [sent by contact]",
     "linked-chat": "  [linked chat]",
 };
 const day = (at) => new Date(at).toISOString().slice(0, 10);
+const PROPOSED = "  [proposed, not confirmed]";
 const FETCH_STATES = {
     complete: "synced",
     partial: "synced in part",
@@ -84,7 +108,7 @@ export const projectEvidenceText = (found, hints) => {
             `${day(found.window.after)} to ${day(found.window.before)}, ${found.scope.sources.length} sources`,
         `as of: ${new Date(found.window.asOf).toISOString()} (exclusive end; reuse --before-time to repeat this window)`,
         `searched: ${[...lanes.values()].join("; ")}`,
-        ...found.items.map((item) => `${day(item.at)}  ${item.ref}${LABELS[item.context] ?? ""}\n    ${item.text}` +
+        ...found.items.map((item) => `${day(item.at)}  ${item.ref}${LABELS[item.context] ?? ""}${item.proposed ? PROPOSED : ""}\n    ${item.text}` +
             (item.around ?? [])
                 .map((one) => `\n      ${one.found ? "(hit) " : ""}${one.sender ? `${one.sender}: ` : ""}${one.text}`)
                 .join("")),
@@ -138,6 +162,16 @@ export const projectEvidenceText = (found, hints) => {
             lines.push(`${one.title ?? one.ref}: ${held}${one.state === "pending" ? ", not read this run" : ""}` +
                 (sync ? ` — sync it: ${sync}` : ""));
         }
+    const proposed = [
+        ...found.linkedChats.flatMap((one) => (one.proposed ? [`${one.title ?? one.ref} (${one.proposed})`] : [])),
+        ...found.members.flatMap((one) => (one.proposed ? [`${one.person} (${one.proposed})`] : [])),
+    ];
+    if (proposed.length)
+        lines.push(`read as proposed, not confirmed: ${proposed.join(", ")}`);
+    for (const one of found.leftOut)
+        lines.push(`left out: ${leftOutLine(one, hints.read?.(one, day(found.window.after)) ?? null)}`);
+    if (found.purposeHint)
+        lines.push(purposeHintLine(found.purposeHint));
     const capped = found.linkedChats.filter((one) => one.capped);
     if (capped.length)
         lines.push(`linked chats with more to read, left for --cursor so one chat does not fill the run: ${capped

package/dist/cli/project-status-rows.js

@@ -97,6 +97,16 @@ export const STATUS_ROWS = {
         ],
     },
     "status.signal": { columns: [{ field: "id" }, { field: "version" }] },
-    "status.out-of-scope": { columns: [{ field: "chat" }, { field: "reason" }, { field: "purpose" }] },
+    "status.out-of-scope": {
+        columns: [
+            { field: "chat" },
+            { field: "reason" },
+            { field: "purpose" },
+            { field: "messages", as: "count", tag: "messages" },
+            { field: "first_at", as: "day" },
+            { field: "last_at", as: "day" },
+            { field: "read_command" },
+        ],
+    },
     "status.failed": { columns: [{ field: "signal" }], text: ["why"] },
 };

package/dist/cli/project-status.d.ts

@@ -1,6 +1,8 @@
 import type { NextStep } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
+import type { Id } from "../domain/models.js";
 import type { ProjectStatus, StatusChatSummary } from "../services/project-status/index.js";
+import type { AccountKey } from "../store/store.js";
 import type { RowShape } from "./compact.js";
 export interface ProjectStatusHints {
     /** The step that syncs a chat held in part back to `since` (`YYYY-MM-DD`); null when no command here can. */
@@ -9,6 +11,12 @@ export interface ProjectStatusHints {
     read: (chat: StatusChatSummary, since: string) => NextStep | null;
     /** The command line a step runs, for the text form. */
     line: (step: NextStep) => string;
+    /** The step that reads a chat left out by its purpose from `since`; null when no command here can. */
+    readChat?: (chat: {
+        ref: string;
+        account: AccountKey;
+        chatId: Id;
+    }, since: string) => NextStep | null;
 }
 /** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
 export declare const projectStatusRow: (signals: readonly {
@@ -44,10 +52,15 @@ export declare const projectStatusSchema: v.LooseObjectSchema<{
         readonly attention: v.NumberSchema<undefined>;
         readonly why: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>, undefined>;
+    readonly purposes: v.UnionSchema<[v.LiteralSchema<"all", undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
     readonly out_of_scope: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly chat: v.StringSchema<undefined>;
         readonly reason: v.StringSchema<undefined>;
         readonly purpose: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly messages: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly first_at: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly last_at: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly read_command: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     }, undefined>, undefined>, undefined>;
     readonly failed: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly signal: v.StringSchema<undefined>;
@@ -55,6 +68,12 @@ export declare const projectStatusSchema: v.LooseObjectSchema<{
     }, undefined>, undefined>, undefined>;
 }, undefined>;
 export type ProjectStatusItem = v.InferOutput<typeof projectStatusSchema>;
+/** `12 messages 2026-10-03…2026-11-01`, or that the window holds none. */
+export declare const heldInWindow: (one: {
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
+}) => string;
 /** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
 export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectStatusHints) => {
     item: {
@@ -86,10 +105,15 @@ export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectS
             attention: number;
             why: string | null;
         }[];
+        purposes: "all" | string[];
         out_of_scope?: {
             chat: string;
             reason: string;
             purpose?: string | undefined;
+            messages?: number | undefined;
+            first_at?: string | null | undefined;
+            last_at?: string | null | undefined;
+            read_command?: string | null | undefined;
         }[] | undefined;
         failed?: {
             signal: string;

package/dist/cli/project-status.js

@@ -49,7 +49,16 @@ export const projectStatusSchema = v.looseObject({
         attention: v.number(),
         why: v.nullable(v.string()),
     })),
-    out_of_scope: v.optional(v.array(v.strictObject({ chat: v.string(), reason: v.string(), purpose: v.optional(v.string()) }))),
+    purposes: v.union([v.literal("all"), v.array(v.string())]),
+    out_of_scope: v.optional(v.array(v.strictObject({
+        chat: v.string(),
+        reason: v.string(),
+        purpose: v.optional(v.string()),
+        messages: v.optional(v.number()),
+        first_at: v.optional(v.nullable(v.string())),
+        last_at: v.optional(v.nullable(v.string())),
+        read_command: v.optional(v.nullable(v.string())),
+    }))),
     failed: v.optional(v.array(v.strictObject({ signal: v.string(), why: v.string() }))),
     ...Object.fromEntries(Object.keys(STATUS_SIGNAL_ROWS).map((name) => [listKey(name.slice(7)), v.optional(v.array(statusItem))])),
 });
@@ -78,9 +87,21 @@ const nextOf = (found, hints) => {
     const reads = top.flatMap(({ chat, why }) => partial(found, chat) ? [] : because(hints.read(chat, readFrom(found, chat.ref)), why));
     return [...syncs, ...reads].slice(0, 2);
 };
-const missingOf = (found) => {
+const leftOutOf = (found) => found.outOfScope.filter((one) => one.reason === "purpose");
+const readLine = (found, one, hints) => {
+    const step = hints.readChat?.({ ref: one.chat, account: one.account, chatId: one.chatId }, day(found.window.since));
+    return step ? hints.line(step) : null;
+};
+/** `12 messages 2026-10-03…2026-11-01`, or that the window holds none. */
+export const heldInWindow = (one) => one.messages && one.firstAt && one.lastAt
+    ? `${one.messages} message${one.messages === 1 ? "" : "s"} ${day(one.firstAt)}…${day(one.lastAt)}`
+    : "no messages in the window";
+const leftOutWhy = (one, read) => `${one.chat}, purpose ${one.purpose}, not read: ${heldInWindow(one)}` +
+    (read ? `; read it: ${read}` : "; add its purpose to --purpose to read it");
+const missingOf = (found, hints) => {
     const held = found.chats.filter((chat) => partial(found, chat));
     const [first] = held;
+    const others = found.outOfScope.filter((one) => one.reason !== "purpose");
     return [
         ...(first
             ? [
@@ -92,16 +113,20 @@ const missingOf = (found) => {
                 },
             ]
             : []),
-        ...(found.outOfScope.length
+        ...(others.length
             ? [
                 {
                     field: "chats",
-                    why: `${found.outOfScope.length} linked chats were not read here (${[
-                        ...new Set(found.outOfScope.map((one) => one.reason)),
+                    why: `${others.length} linked chats were not read here (${[
+                        ...new Set(others.map((one) => one.reason)),
                     ].join(", ")}); memo projects status reads every account`,
                 },
             ]
             : []),
+        ...leftOutOf(found).map((one) => {
+            const read = readLine(found, one, hints);
+            return { field: "chats", why: leftOutWhy(one, read), ...(read ? { step: "messages.list" } : {}) };
+        }),
         ...found.failed.map((one) => ({ field: `signal:${one.signal}`, why: one.why })),
     ];
 };
@@ -145,11 +170,26 @@ export const projectStatusAnswer = (found, hints) => {
             attention: weights.get(chat.ref)?.weight ?? 0,
             why: weights.get(chat.ref)?.why ?? null,
         })),
-        ...(found.outOfScope.length ? { outOfScope: found.outOfScope } : {}),
+        purposes: found.purposes,
+        ...(found.outOfScope.length
+            ? {
+                outOfScope: found.outOfScope.map((one) => one.reason === "purpose"
+                    ? {
+                        chat: one.chat,
+                        reason: one.reason,
+                        purpose: one.purpose,
+                        messages: one.messages,
+                        firstAt: one.firstAt,
+                        lastAt: one.lastAt,
+                        readCommand: readLine(found, one, hints),
+                    }
+                    : one),
+            }
+            : {}),
         ...(found.failed.length ? { failed: found.failed } : {}),
         ...lists,
     });
-    const missing = missingOf(found);
+    const missing = missingOf(found, hints);
     const complete = found.failed.length === 0 && !found.chats.some((chat) => partial(found, chat));
     return {
         item,
@@ -235,8 +275,11 @@ export const projectStatusText = (found, hints) => {
         const cut = one.data.cut;
         lines.push(`  ${cut ? `${data.child} not read (${cut})` : `${data.key ?? data.child} · ${data.name} · ${data.chats} chats`}`);
     }
-    if (found.outOfScope.length)
-        lines.push(`Not read here: ${found.outOfScope.map((one) => `${one.chat} (${one.reason})`).join(", ")}`);
+    const others = found.outOfScope.filter((one) => one.reason !== "purpose");
+    if (others.length)
+        lines.push(`Not read here: ${others.map((one) => `${one.chat} (${one.reason})`).join(", ")}`);
+    for (const one of leftOutOf(found))
+        lines.push(`Left out: ${leftOutWhy(one, readLine(found, one, hints))}`);
     for (const one of found.failed)
         lines.push(`Signal ${one.signal} failed: ${one.why}`);
     if (next.length)

package/dist/cli/schedule/schedule-command.js

@@ -268,7 +268,11 @@ export const scheduleCommandFor = ({ app, context: contextOf }) => {
         .action(async function (file) {
         // A timer starts it with no profile named; the schedule's own environment carries the profile.
         const { context, system, timer } = prepare(this, { needsProfile: false });
-        const last = await untilChildEnds(this, (signal) => runSchedule(app, system, context.env, file, { timer: timer(), ...(signal ? { signal } : {}) }));
+        const last = await untilChildEnds(this, (signal) => runSchedule(app, system, context.env, file, {
+            timer: timer(),
+            untilUnlocked: true,
+            ...(signal ? { signal } : {}),
+        }));
         if (last.exitCode !== 0)
             setExitCode(this, 1);
     });

package/dist/entities/hit.d.ts

@@ -24,6 +24,11 @@ export declare const hit: v.StrictObjectSchema<{
     readonly scope: v.OptionalSchema<v.PicklistSchema<["transcript", "chat", "summary"], undefined>, undefined>;
     /** A meeting transcript hit's cue, which `meetings passage` opens with the lines around it. */
     readonly cue_ref: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** A meeting transcript hit's transcript language (`ru`, `en`…), `null` when unknown. */
+    readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /** A meeting transcript hit's line, from 1, of `lines_total` lines in its transcript. */
+    readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
     /** A message's files; absent when it has none. */

package/dist/entities/hit.js

@@ -26,6 +26,11 @@ export const hit = v.strictObject({
     scope: v.optional(v.picklist(["transcript", "chat", "summary"])),
     /** A meeting transcript hit's cue, which `meetings passage` opens with the lines around it. */
     cue_ref: v.optional(reference),
+    /** A meeting transcript hit's transcript language (`ru`, `en`…), `null` when unknown. */
+    language: v.optional(v.nullable(text)),
+    /** A meeting transcript hit's line, from 1, of `lines_total` lines in its transcript. */
+    line: v.optional(v.pipe(count, v.minValue(1))),
+    lines_total: v.optional(count),
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     id: v.optional(v.pipe(v.string(), v.minLength(1))),
     /** A message's files; absent when it has none. */

package/dist/entities/index.d.ts

@@ -214,6 +214,15 @@ export declare const ENTITIES: {
             readonly next_transcript_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
         }, undefined>;
     }, undefined>], undefined>;
+    readonly meeting_repair: v.StrictObjectSchema<{
+        readonly account_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly applied: v.BooleanSchema<undefined>;
+        readonly transcripts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly languages: v.ArraySchema<v.StrictObjectSchema<{
+            readonly language: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly transcripts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
+    }, undefined>;
     readonly sync_progress: v.StrictObjectSchema<{
         readonly job: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly profile: v.StringSchema<undefined>;
@@ -4575,6 +4584,9 @@ export declare const ENTITIES: {
         readonly offset_ms: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
         readonly scope: v.OptionalSchema<v.PicklistSchema<["transcript", "chat", "summary"], undefined>, undefined>;
         readonly cue_ref: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
         readonly attachments: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
             readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -5625,6 +5637,9 @@ export declare const ENTITIES: {
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly excerpt: v.StringSchema<undefined>;
         readonly offset_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly match: v.OptionalSchema<v.PicklistSchema<["words", "corrected"], undefined>, undefined>;
         readonly corrections: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
             readonly from: v.StringSchema<undefined>;
@@ -5790,6 +5805,9 @@ export declare const ENTITIES: {
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly excerpt: v.StringSchema<undefined>;
             readonly offset_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+            readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             readonly match: v.OptionalSchema<v.PicklistSchema<["words", "corrected"], undefined>, undefined>;
             readonly corrections: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
                 readonly from: v.StringSchema<undefined>;
@@ -6161,6 +6179,9 @@ export declare const ENTITIES: {
                     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
                     readonly excerpt: v.StringSchema<undefined>;
                     readonly offset_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                    readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+                    readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
                     readonly match: v.OptionalSchema<v.PicklistSchema<["words", "corrected"], undefined>, undefined>;
                     readonly corrections: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
                         readonly from: v.StringSchema<undefined>;
@@ -8812,6 +8833,12 @@ export declare const ENTITIES: {
         readonly stems: v.OptionalSchema<v.StrictObjectSchema<{
             readonly stemmed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         }, undefined>, undefined>;
+        readonly caught_up: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly fetched: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly stopped: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
         readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
             readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             readonly closed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/listener.d.ts

@@ -2266,6 +2266,12 @@ export declare const serveSummary: v.StrictObjectSchema<{
     readonly stems: v.OptionalSchema<v.StrictObjectSchema<{
         readonly stemmed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>;
+    readonly caught_up: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly fetched: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly failed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly stopped: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
     readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
         readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly closed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/listener.js

@@ -42,5 +42,6 @@ export const serveSummary = v.strictObject({
     replies: v.optional(v.strictObject({ sent: totals, skipped: totals, tasks: v.optional(totals) })),
     members: v.optional(v.strictObject({ fetched: count, failed: count })),
     stems: v.optional(v.strictObject({ stemmed: count })),
+    caught_up: v.optional(v.strictObject({ chats: count, fetched: count, failed: count, stopped: v.boolean() })),
     tasks: v.optional(v.strictObject({ added: count, closed: count, review: count })),
 });

package/dist/entities/meeting-preparation.d.ts

@@ -309,6 +309,9 @@ export declare const meetingPreparation: v.StrictObjectSchema<{
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
                 readonly excerpt: v.StringSchema<undefined>;
                 readonly offset_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+                readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+                readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
                 readonly match: v.OptionalSchema<v.PicklistSchema<["words", "corrected"], undefined>, undefined>;
                 readonly corrections: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
                     readonly from: v.StringSchema<undefined>;

package/dist/errors/reasons.js

@@ -33,6 +33,7 @@ const SIGN_IN = [
     ["sign-in.client-file-invalid", "configuration_error", "the file is not a Desktop app OAuth client JSON"],
 ];
 const OTHERS = [
+    ["query.time-limit", "timeout", "the search took longer than its time limit; the query itself is valid"],
     ["model.offline", "permission_error", "downloading a model needs the network; --offline was requested"],
     [
         "contract.unacknowledged-override",

package/dist/mcp/meeting-preparation.d.ts

@@ -376,6 +376,9 @@ export declare const callMeetingPreparationTool: (read: MeetingPreparationReader
                     id: string;
                     excerpt: string;
                     offset_ms: number | null;
+                    language?: string | null | undefined;
+                    line?: number | undefined;
+                    lines_total?: number | undefined;
                     match?: "corrected" | "words" | undefined;
                     corrections?: {
                         from: string;

package/dist/meetings/answers.d.ts

@@ -15,6 +15,11 @@ export declare const meetingHit: v.StrictObjectSchema<{
     readonly excerpt: v.StringSchema<undefined>;
     /** How far into the meeting the passage is. */
     readonly offset_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    /** A transcript passage's transcript language (`ru`, `en`…), `null` when unknown. */
+    readonly language: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /** A transcript passage's line, from 1, of `lines_total`. */
+    readonly line: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly lines_total: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     /** `corrected`: a query word matched only a garbled form of itself, listed in `corrections`. */
     readonly match: v.OptionalSchema<v.PicklistSchema<["words", "corrected"], undefined>, undefined>;
     readonly corrections: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{

package/dist/meetings/answers.js

@@ -16,6 +16,11 @@ export const meetingHit = v.strictObject({
     excerpt: text,
     /** How far into the meeting the passage is. */
     offset_ms: v.nullable(count),
+    /** A transcript passage's transcript language (`ru`, `en`…), `null` when unknown. */
+    language: v.optional(v.nullable(text)),
+    /** A transcript passage's line, from 1, of `lines_total`. */
+    line: v.optional(v.pipe(count, v.minValue(1))),
+    lines_total: v.optional(count),
     /** `corrected`: a query word matched only a garbled form of itself, listed in `corrections`. */
     match: v.optional(v.picklist(["words", "corrected"])),
     corrections: v.optional(v.array(v.strictObject({ from: text, to: v.array(text) }))),
@@ -190,6 +195,9 @@ export const meetingHitItem = (hit) => ({
     id: String(hit.id),
     excerpt: hit.text,
     offset_ms: hit.startMs,
+    ...(hit.language === undefined ? {} : { language: hit.language }),
+    ...(hit.line === undefined ? {} : { line: hit.line }),
+    ...(hit.linesTotal === undefined ? {} : { lines_total: hit.linesTotal }),
     untrusted: hit.source === undefined ? ["excerpt"] : ["excerpt", "source.title"],
     ...(hit.match === undefined ? {} : { match: hit.match }),
     ...(hit.corrections === undefined ? {} : { corrections: hit.corrections }),

package/dist/meetings/cli/index.js

@@ -146,6 +146,20 @@ const addMeetingCommandsDefinition = (program, deps) => {
             throw new MeetingError("validation_error", "file account differs from selected account");
         print(await importFiles(files, deps.store, deps.now?.()), command);
     });
+    output(annotate(group.command("repair"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "meeting_repair" },
+    }).description("preview filling in what older builds left out of stored transcripts (their language); --yes stores it"))
+        .option("--yes", "store the detected languages; otherwise only preview")
+        .action(async (opts, command) => {
+        if (!deps.store.fillTranscriptLanguages)
+            throw new MeetingError("configuration_error", "this store cannot fill transcript languages");
+        print(await deps.store.fillTranscriptLanguages({
+            accountId: deps.accountId,
+            apply: opts.yes === true,
+            now: deps.now?.() ?? Date.now(),
+        }), command);
+    });
     const eventList = queryWordsAfterOptions(annotate(program.command("events").description("the owner's stored events"), {
         effects: { remote: "none", local: "none" },
     }).command("list"))

package/dist/meetings/index.d.ts

@@ -14,6 +14,7 @@ export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQu
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, type MeetingIssue, type MeetingItem, type MeetingOwner, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
 export { joinKeyOf, joinUrlWithoutQuery } from "./join-key.js";
+export { transcriptLanguage } from "./language.js";
 export { CHAT_MESSAGES_READ, type MeetingChatLine, type MeetingChatLinesInput, type MeetingChatLinesStore, type MeetingLink, } from "./links.js";
 export { createMeetingContext, type MeetingContextAction, type MeetingContextChange, type MeetingContextOperation, type MeetingContextPorts, type MeetingContextReceipt, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, type ManagedMeeting, type ManagedMeetingChange, type MeetingManagement, type MeetingManagementPorts, type MeetingMutationOptions, type MeetingMutationProposal, type MeetingMutationReceipt, type MeetingOperationOptions, type MeetingProviderContext, validateMeetingChange, } from "./meeting-management.js";
@@ -51,7 +52,7 @@ export type { MeetingSeriesCandidate, MeetingSeriesInventoryPage, MeetingSeriesI
 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 { ChatInput, ContractCase, EventCandidateFilter, IdentityInput, MeetingDetails, MeetingFilter, MeetingHitSource, MeetingInput, MeetingSave, MeetingStore, NewRecord, ParticipantInput, SearchHit, TranscriptInput, TranscriptLanguageFill, TranscriptRowInput, } from "./store.js";
 export type { MeetingTranscriptReceiptStore, MeetingTranscriptStore, TranscriptAppend, TranscriptAppendReceipt, UnlinkedTranscriptInput, } from "./transcript-store.js";
 export { parseTranscriptText, TranscriptTextError, type TranscriptTextHeader } from "./transcript-text.js";
 export { type MeetingMediaDescriptor, type MeetingRecognitionSegment, type MeetingTranscriptionContext, type MeetingTranscriptionOptions, type MeetingTranscriptionReceipt, type MeetingTranscriptionSource, transcribeMeeting, } from "./transcription.js";

package/dist/meetings/index.js

@@ -11,6 +11,7 @@ export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQu
 export { importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
 export { joinKeyOf, joinUrlWithoutQuery } from "./join-key.js";
+export { transcriptLanguage } from "./language.js";
 export { CHAT_MESSAGES_READ, } from "./links.js";
 export { createMeetingContext, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, validateMeetingChange, } from "./meeting-management.js";

package/dist/meetings/ingest.js

@@ -1,3 +1,4 @@
+import { transcriptLanguage } from "./language.js";
 export const contentHash = async (text) => {
     const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
     return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -11,7 +12,7 @@ export const speakerPosition = (name, participants) => {
 export const transcriptInput = async (lines, participants, source, hashText = JSON.stringify(lines), format = null) => ({
     source,
     format,
-    language: null,
+    language: transcriptLanguage(lines.map((line) => line.text)),
     contentHash: await contentHash(hashText),
     externalCreatedAt: null,
     metadata: null,

package/dist/meetings/language.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The language most of a transcript is in, from its letters: Cyrillic is Russian (Ukrainian when its own letters
+ * show), Latin is decided by frequent words. `null` when the text is too short, mixed, or in neither script.
+ */
+export declare const transcriptLanguage: (texts: Iterable<string>) => string | null;

package/dist/meetings/language.js

@@ -0,0 +1,57 @@
+/**
+ * Words frequent in one Latin-script language and rare in the others here. Letters alone cannot tell Spanish from
+ * English, and calling a Spanish meeting English is worse than calling it nothing.
+ */
+const LATIN_WORDS = {
+    en: ["the", "and", "is", "that", "you", "this", "what", "have", "with", "are"],
+    es: ["el", "los", "las", "por", "pero", "para", "está", "muy", "también", "hay"],
+    de: ["der", "und", "ist", "nicht", "das", "ich", "wir", "mit", "auch", "ein"],
+    fr: ["le", "les", "est", "une", "pas", "je", "vous", "nous", "avec", "mais"],
+    it: ["gli", "della", "sono", "perché", "anche", "questo", "molto", "che", "di", "è"],
+    pt: ["não", "você", "isso", "muito", "então", "com", "uma", "também", "mas", "eu"],
+};
+const LATIN_LANGUAGE = new Map(Object.entries(LATIN_WORDS).flatMap(([language, words]) => words.map((word) => [word, language])));
+/** Letters Ukrainian writes and Russian does not. */
+const UKRAINIAN = /[іїєґ]/giu;
+const CYRILLIC = /\p{Script=Cyrillic}/gu;
+const LATIN = /\p{Script=Latin}/gu;
+const MIN_LETTERS = 20;
+/** A meeting in one language keeps a few lines of another; a share below this is a mixed meeting. */
+const DOMINANT = 0.75;
+const countOf = (text, pattern) => text.match(pattern)?.length ?? 0;
+const latinLanguage = (texts) => {
+    const votes = new Map();
+    for (const text of texts)
+        for (const word of text.toLowerCase().split(/[^\p{L}]+/u)) {
+            const language = LATIN_LANGUAGE.get(word);
+            if (language)
+                votes.set(language, (votes.get(language) ?? 0) + 1);
+        }
+    const [first, second] = [...votes].sort((a, b) => b[1] - a[1]);
+    if (!first || first[1] < 3 || (second && first[1] < 2 * second[1]))
+        return null;
+    return first[0];
+};
+/**
+ * The language most of a transcript is in, from its letters: Cyrillic is Russian (Ukrainian when its own letters
+ * show), Latin is decided by frequent words. `null` when the text is too short, mixed, or in neither script.
+ */
+export const transcriptLanguage = (texts) => {
+    const all = [...texts];
+    let cyrillic = 0;
+    let latin = 0;
+    let ukrainian = 0;
+    for (const text of all) {
+        cyrillic += countOf(text, CYRILLIC);
+        latin += countOf(text, LATIN);
+        ukrainian += countOf(text, UKRAINIAN);
+    }
+    const letters = cyrillic + latin;
+    if (letters < MIN_LETTERS)
+        return null;
+    if (cyrillic / letters >= DOMINANT)
+        return ukrainian / cyrillic >= 0.01 ? "uk" : "ru";
+    if (latin / letters >= DOMINANT)
+        return latinLanguage(all);
+    return null;
+};