@wirecat/cli-core 0.550.0 → 0.552.0

package/dist/cli/project-status.js

@@ -0,0 +1,248 @@
+import * as v from "valibot";
+import { snakeKeys } from "./envelope.js";
+import { heldPhrase } from "./messenger/search-answers.js";
+import { STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
+const day = (at) => new Date(at).toISOString().slice(0, 10);
+const listKey = (signal) => signal.replaceAll("-", "_");
+const SECTIONS = {
+    signals: "status.signal",
+    money: "status.money",
+    chats: "status.chat",
+    out_of_scope: "status.out-of-scope",
+    failed: "status.failed",
+};
+/** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
+export const projectStatusRow = (signals) => ({
+    columns: [],
+    sections: {
+        ...SECTIONS,
+        ...Object.fromEntries(signals.map(({ id }) => [listKey(id), `status.${id}`])),
+    },
+});
+const statusItem = v.looseObject({
+    signal: v.string(),
+    ref: v.nullable(v.string()),
+    chat: v.nullable(v.string()),
+    chat_title: v.nullable(v.string()),
+    at: v.nullable(v.string()),
+    who: v.nullable(v.strictObject({ ref: v.nullable(v.string()), name: v.nullable(v.string()), owner: v.boolean() })),
+    evidence: v.array(v.strictObject({ ref: v.string(), fingerprint: v.nullable(v.string()) })),
+    basis: v.picklist(["store", "fact", "task", "pattern"]),
+    data: v.record(v.string(), v.unknown()),
+});
+/** Where a project stands: per chat signals, open money, and what was left out. Empty lists are left out. */
+export const projectStatusSchema = v.looseObject({
+    project: v.string(),
+    key: v.nullable(v.string()),
+    name: v.string(),
+    window: v.strictObject({ since: v.string(), until: v.string() }),
+    signals: v.array(v.strictObject({ id: v.string(), version: v.number() })),
+    money: v.array(v.strictObject({ direction: v.string(), currency: v.nullable(v.string()), amount: v.string(), rows: v.number() })),
+    chats: v.array(v.strictObject({
+        chat: v.string(),
+        title: v.nullable(v.string()),
+        kind: v.string(),
+        role: v.nullable(v.string()),
+        purpose: v.string(),
+        project: v.string(),
+        coverage: v.string(),
+        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()) }))),
+    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))])),
+});
+const coverageOf = (found, chat) => found.items.find((one) => one.signal === "coverage" && one.chat === chat)?.data;
+const partial = (found, chat) => {
+    const held = coverageOf(found, chat.ref);
+    return held ? held.state !== "complete" && held.beforeHeld : chat.coverage.completeness.state !== "complete";
+};
+const readFrom = (found, chat) => {
+    const reply = found.items.find((one) => one.signal === "reply-next" && one.chat === chat)?.data;
+    const money = found.items
+        .filter((one) => one.signal === "amounts" && one.chat === chat && one.data.state === "open")
+        .map((one) => one.data.since)
+        .sort()[0];
+    return day([money, reply?.waitingSince, found.window.since].find((one) => typeof one === "string"));
+};
+/** At most two: the chats `attention` weighs highest, a chat held in part synced first. */
+const nextOf = (found, hints) => {
+    const byRef = new Map(found.chats.map((chat) => [chat.ref, chat]));
+    const top = found.attention.slice(0, 2).flatMap((one) => {
+        const chat = byRef.get(one.chat);
+        return chat ? [{ chat, why: one.why }] : [];
+    });
+    const because = (step, why) => (step ? [{ ...step, why }] : []);
+    const syncs = top.flatMap(({ chat, why }) => partial(found, chat) ? because(hints.sync(chat, day(found.window.since)), why) : []);
+    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 held = found.chats.filter((chat) => partial(found, chat));
+    const [first] = held;
+    return [
+        ...(first
+            ? [
+                {
+                    field: "history",
+                    why: `${held.length} of ${found.chats.length} chats hold only part of the window; ` +
+                        `the first is ${heldPhrase(first.coverage)}`,
+                    step: "messages.sync",
+                },
+            ]
+            : []),
+        ...(found.outOfScope.length
+            ? [
+                {
+                    field: "chats",
+                    why: `${found.outOfScope.length} linked chats were not read here (${[
+                        ...new Set(found.outOfScope.map((one) => one.reason)),
+                    ].join(", ")}); memo projects status reads every account`,
+                },
+            ]
+            : []),
+        ...found.failed.map((one) => ({ field: `signal:${one.signal}`, why: one.why })),
+    ];
+};
+const withPlace = (found, hints) => {
+    const titles = new Map(found.chats.map((chat) => [chat.ref, chat.title]));
+    const sync = (one) => {
+        const chat = found.chats.find((each) => each.ref === one.chat);
+        const step = chat && partial(found, chat) ? hints.sync(chat, day(found.window.since)) : null;
+        return step ? hints.line(step) : null;
+    };
+    return (one) => ({
+        ...one,
+        ref: one.evidence[0]?.ref ?? one.chat,
+        chatTitle: one.chat === null ? null : (titles.get(one.chat) ?? null),
+        ...(one.signal === "coverage" ? { syncCommand: sync(one) } : {}),
+    });
+};
+/** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
+export const projectStatusAnswer = (found, hints) => {
+    const weights = new Map(found.attention.map((one) => [one.chat, one]));
+    const place = withPlace(found, hints);
+    const lists = Object.fromEntries(found.signals.flatMap(({ id }) => {
+        const items = found.items.filter((one) => one.signal === id).map(place);
+        return items.length ? [[listKey(id), items]] : [];
+    }));
+    const item = snakeKeys({
+        project: found.project.ref,
+        key: found.project.key,
+        name: found.project.name,
+        window: found.window,
+        signals: found.signals,
+        money: found.money.open,
+        chats: found.chats.map((chat) => ({
+            chat: chat.ref,
+            title: chat.title,
+            kind: chat.kind,
+            role: chat.role,
+            purpose: chat.purpose,
+            project: chat.project,
+            coverage: chat.coverage.completeness.state,
+            attention: weights.get(chat.ref)?.weight ?? 0,
+            why: weights.get(chat.ref)?.why ?? null,
+        })),
+        ...(found.outOfScope.length ? { outOfScope: found.outOfScope } : {}),
+        ...(found.failed.length ? { failed: found.failed } : {}),
+        ...lists,
+    });
+    const missing = missingOf(found);
+    const complete = found.failed.length === 0 && !found.chats.some((chat) => partial(found, chat));
+    return {
+        item,
+        next: nextOf(found, hints),
+        missing,
+        meta: { window: found.window, complete, ...(found.accounts.length ? { accounts: found.accounts } : {}) },
+    };
+};
+const NEXT_WORDS = { owner: "YOU", them: "them", nobody: "nobody" };
+const chatLine = (found, chat) => {
+    const of = (signal) => found.items.filter((one) => one.signal === signal && one.chat === chat.ref);
+    const [last] = of("last-message");
+    const reply = of("reply-next")[0]?.data;
+    const head = [
+        `${chat.title ?? chat.ref} (${[chat.role ?? "no role", chat.kind].join(", ")})`,
+        last
+            ? `last ${day(last.at)} ${last.who?.owner ? "you" : (last.who?.name ?? "them")}`
+            : "nothing in the window",
+        ...(reply
+            ? [
+                `next: ${reply.next === "named" ? `${reply.addressed?.name ?? "someone"} (named)` : NEXT_WORDS[reply.next]}` +
+                    (reply.waitingSince ? ` since ${day(reply.waitingSince)}` : ""),
+            ]
+            : []),
+        ...(partial(found, chat) ? [heldPhrase(chat.coverage)] : []),
+    ].join(" · ");
+    const open = [];
+    const asked = of("questions").map((one) => one.data);
+    const yours = asked.filter((one) => one.side === "yours").length;
+    const theirs = asked.length - yours;
+    if (theirs)
+        open.push(`${theirs} question${theirs === 1 ? "" : "s"} to you unanswered`);
+    if (yours)
+        open.push(`${yours} question${yours === 1 ? "" : "s"} of yours unanswered`);
+    for (const topic of of("topics")) {
+        const data = topic.data;
+        if (data.silentSince)
+            open.push(`"${data.query}" quiet on their side since ${day(data.silentSince)}`);
+    }
+    const promised = of("promises").length;
+    if (promised)
+        open.push(`${promised} promise${promised === 1 ? "" : "s"}`);
+    return [`  ${head}`, ...(open.length ? [`    open: ${open.join(" · ")}`] : [])];
+};
+const moneyLine = (one, titles) => {
+    const data = one.data;
+    const asks = data.asks > 1 && data.lastAsked ? ` (asked ${data.asks}×, last ${day(data.lastAsked)})` : "";
+    const where = one.chat === null ? "" : ` · ${titles.get(one.chat) ?? one.chat}`;
+    const words = data.direction.replace("_", " ");
+    const sum = `${data.amount} ${data.currency ?? "?"} ${data.state} since ${day(data.since)}`;
+    return `  ${words.padEnd(7)} ${sum}${asks}${where} · ${one.evidence[0]?.ref ?? ""} [${one.basis}]`;
+};
+/** The human form: header, money, a line per chat with what is open, then the steps. */
+export const projectStatusText = (found, hints) => {
+    const titles = new Map(found.chats.map((chat) => [chat.ref, chat.title]));
+    const { next } = projectStatusAnswer(found, hints);
+    const money = found.items.filter((one) => one.signal === "amounts" && one.data.state !== "mentioned");
+    const payments = found.items.filter((one) => one.signal === "payments");
+    const children = found.items.filter((one) => one.signal === "children");
+    const key = found.project.key ? `${found.project.key} · ` : "";
+    const lines = [
+        `${key}${found.project.name} · ${found.chats.length} linked chats in ${found.accounts.length} accounts, ` +
+            `${day(found.window.since)} to ${day(found.window.until)}`,
+    ];
+    if (money.length || payments.length) {
+        lines.push("Money");
+        for (const one of money)
+            lines.push(moneyLine(one, titles));
+        for (const one of payments) {
+            const data = one.data;
+            lines.push(`  payment ${data.title} · ${one.evidence[0]?.ref ?? ""} [${data.status}]`);
+        }
+    }
+    if (found.chats.length)
+        lines.push("Chats");
+    for (const chat of found.chats)
+        for (const line of chatLine(found, chat))
+            lines.push(line);
+    if (children.length)
+        lines.push("Children");
+    for (const one of children) {
+        const data = one.data;
+        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(", ")}`);
+    for (const one of found.failed)
+        lines.push(`Signal ${one.signal} failed: ${one.why}`);
+    if (next.length)
+        lines.push("Next");
+    next.forEach((step, index) => {
+        lines.push(`  ${index + 1}. ${hints.line(step)}`);
+    });
+    return lines.join("\n");
+};

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/cli/steps.js

@@ -48,7 +48,10 @@ export const STEPS = defineSteps([
     {
         id: "messages.list",
         command: "messages list",
-        args: [{ name: "chat", required: true }],
+        args: [
+            { name: "chat", required: true },
+            { name: "query", required: false },
+        ],
         why: "only the newest were read here; this reads the chat itself",
     },
     {

package/dist/domain/knowledge.d.ts

@@ -1,4 +1,4 @@
-export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise"];
+export { FACT_TYPES } from "../meetings/index.js";
 export declare const FACT_STATUSES: readonly ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export declare const MEMORY_KINDS: readonly ["summary", "digest", "preference"];
 export declare const MEMORY_STATUSES: readonly ["proposed", "confirmed", "stale", "superseded"];

package/dist/domain/knowledge.js

@@ -1,5 +1,5 @@
 import { TASK_KINDS } from "../tasks/index.js";
-export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
+export { FACT_TYPES } from "../meetings/index.js";
 export const FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export const MEMORY_KINDS = ["summary", "digest", "preference"];
 export const MEMORY_STATUSES = ["proposed", "confirmed", "stale", "superseded"];

package/dist/domain/status-words.d.ts

@@ -0,0 +1,3 @@
+export declare const MONEY_DONE_FORMS: RegExp;
+/** First person future: "I'll send", "сделаю", "lo envío". Labelled a guess wherever it is shown. */
+export declare const PROMISE_FORMS: RegExp;

package/dist/domain/status-words.js

@@ -0,0 +1,44 @@
+/**
+ * Word patterns for project status, ru/en/es, matched on the text as written (case folded here). A stem cannot tell
+ * `оплатил` from `оплати`, so the past forms a money stem shares with a request are listed whole: a message with one
+ * of them reads as "done", whatever stems it also hits.
+ */
+const words = (forms) => new RegExp(`(?<![\\p{L}\\p{N}])(?:${forms.join("|")})(?![\\p{L}\\p{N}])`, "iu");
+export const MONEY_DONE_FORMS = words([
+    "оплатил[аи]?",
+    "заплатил[аи]?",
+    "перевел[аи]?",
+    "перевёл",
+    "отправил[аи]?",
+    "оплачено",
+    "переведено",
+    "paid",
+    "transferred",
+    "pagué",
+    "pagado",
+    "transferí",
+]);
+/** First person future: "I'll send", "сделаю", "lo envío". Labelled a guess wherever it is shown. */
+export const PROMISE_FORMS = words([
+    "сделаю",
+    "пришлю",
+    "отправлю",
+    "подготовлю",
+    "проверю",
+    "напишу",
+    "позвоню",
+    "скину",
+    "вышлю",
+    "оплачу",
+    "будет готов[аоы]?",
+    "i'?ll (?:send|do|check|call|write|pay|prepare|share|fix)",
+    "i will (?:send|do|check|call|write|pay|prepare|share|fix)",
+    "will be ready",
+    "lo envío",
+    "te envío",
+    "enviaré",
+    "haré",
+    "mandaré",
+    "te llamo",
+    "estará listo",
+]);

package/dist/entities/fact.d.ts

@@ -2,7 +2,7 @@ import * as v from "valibot";
 export declare const fact: v.StrictObjectSchema<{
     readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+    readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
     readonly text: v.StringSchema<undefined>;
     readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
     readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -29,6 +29,17 @@ export declare const fact: v.StrictObjectSchema<{
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
     readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** A `payment` fact's fields. */
+    readonly payment: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
+        readonly amount: v.StringSchema<undefined>;
+        readonly currency: v.StringSchema<undefined>;
+        readonly direction: v.PicklistSchema<readonly ["to_us", "from_us"], undefined>;
+        readonly counterparty: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly counterparty_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly due_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly state: v.PicklistSchema<readonly ["expected", "paid", "cancelled"], undefined>;
+        readonly item: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
     /** With `--sources`: each piece of evidence read back. */
     readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;

package/dist/entities/fact.js

@@ -1,6 +1,17 @@
 import * as v from "valibot";
 import { FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../domain/knowledge.js";
+import { PAYMENT_DIRECTIONS, PAYMENT_STATES } from "../meetings/index.js";
 import { author, evidenceSource, id, reference, text, time } from "./fields.js";
+const payment = v.strictObject({
+    amount: text,
+    currency: text,
+    direction: v.picklist(PAYMENT_DIRECTIONS),
+    counterparty: v.nullable(reference),
+    counterparty_name: v.nullable(text),
+    due_at: v.nullable(text),
+    state: v.picklist(PAYMENT_STATES),
+    item: v.nullable(text),
+});
 export const fact = v.strictObject({
     ref: reference,
     id,
@@ -24,6 +35,8 @@ export const fact = v.strictObject({
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     origin: v.picklist(["owner", "agent"]),
     evidence: v.array(reference),
+    /** A `payment` fact's fields. */
+    payment: v.optional(v.nullable(payment)),
     /** With `--sources`: each piece of evidence read back. */
     sources: v.optional(v.array(evidenceSource)),
     created_at: time,

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>;
@@ -1099,6 +1108,7 @@ export declare const ENTITIES: {
         readonly reached_since: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         readonly reached_last: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         readonly stopped: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+        readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], 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>]>;
@@ -1145,6 +1155,11 @@ export declare const ENTITIES: {
                 readonly retryable: v.BooleanSchema<undefined>;
                 readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
             }, v.UnknownSchema, undefined>, undefined>;
+            readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly limited: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly group_too_large: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly older_than_window: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, 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>]>;
@@ -4569,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>]>;
@@ -5448,7 +5466,7 @@ export declare const ENTITIES: {
     readonly fact: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
         readonly text: v.StringSchema<undefined>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -5471,6 +5489,16 @@ export declare const ENTITIES: {
         readonly scope: v.NullableSchema<v.PicklistSchema<readonly ["personal", "work"], undefined>, undefined>;
         readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
         readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly payment: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
+            readonly amount: v.StringSchema<undefined>;
+            readonly currency: v.StringSchema<undefined>;
+            readonly direction: v.PicklistSchema<readonly ["to_us", "from_us"], undefined>;
+            readonly counterparty: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly counterparty_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly due_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly state: v.PicklistSchema<readonly ["expected", "paid", "cancelled"], undefined>;
+            readonly item: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
             readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
             readonly kind: v.StringSchema<undefined>;
@@ -5609,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>;
@@ -5774,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>;
@@ -6145,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>;
@@ -6257,7 +6294,7 @@ export declare const ENTITIES: {
                     readonly fingerprint: v.StringSchema<undefined>;
                 }, undefined>, undefined>;
                 readonly kind: v.LiteralSchema<"fact", undefined>;
-                readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+                readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
                 readonly statement: v.StringSchema<undefined>;
             }, undefined>, v.StrictObjectSchema<{
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -8796,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-findings.d.ts

@@ -17,7 +17,7 @@ export declare const meetingFindings: v.StrictObjectSchema<{
                 readonly fingerprint: v.StringSchema<undefined>;
             }, undefined>, undefined>;
             readonly kind: v.LiteralSchema<"fact", undefined>;
-            readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+            readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
             readonly statement: v.StringSchema<undefined>;
         }, undefined>, v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

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