@wirecat/cli-core 0.550.0 → 0.552.0

package/dist/speech/models.js

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

package/dist/store/decisions.d.ts

@@ -38,9 +38,12 @@ export interface Refusal {
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
  */
-export declare const mayDecide: (row: {
+export declare const mayDecide: (
+/** `ownerOnly`: what only the owner may say, such as that a payment was made. */
+row: {
     id: string;
     proposedBy: Proposer;
+    ownerOnly?: boolean;
 }, by: Decider, policy?: DecisionPolicy) => Refusal | null;
 /** One bot whatever its letter case or spacing: `Claude-Code` is `claude-code`. */
 export declare const botKey: (name: string) => string;
@@ -59,6 +62,7 @@ export declare const assertMayWithdraw: (row: {
 export declare const assertMayDecide: (row: {
     id: string;
     proposedBy: Proposer;
+    ownerOnly?: boolean;
 }, by: Decider, policy?: DecisionPolicy) => void;
 /** The author a decision is recorded under. */
 export declare const deciderAuthor: (by: Decider) => "owner" | {

package/dist/store/decisions.js

@@ -4,7 +4,9 @@ export const DEFAULT_DECISION_POLICY = { agentDecisions: true, ruleProposalsOwne
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
  */
-export const mayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
+export const mayDecide = (
+/** `ownerOnly`: what only the owner may say, such as that a payment was made. */
+row, by, policy = DEFAULT_DECISION_POLICY) => {
     if (by === "owner")
         return null;
     const refuse = (code, reason, message) => ({
@@ -13,6 +15,8 @@ export const mayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
         reason,
         message,
     });
+    if (row.ownerOnly)
+        return refuse("permission_error", "proposal.owner-only", `only the owner decides ${row.id}`);
     if (!policy.agentDecisions)
         return refuse("permission_error", "proposals.agent-decisions-off", "agent decisions are turned off; the owner decides");
     if (typeof by.reason !== "string" || !by.reason.trim() || by.reason.length > 2000)

package/dist/store/driver.d.ts

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

package/dist/store/driver.js

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

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

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

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

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

package/dist/store/evidence-findings.js

@@ -18,4 +18,5 @@ export const validateEvidenceFindings = (input) => validateFindings(input, {
     cited: "reference",
     reference,
     anySubject: true,
+    payments: true,
 });

package/dist/store/index.d.ts

@@ -6,6 +6,7 @@ export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } fro
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
 export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFinding, MeetingFindingsInput, MeetingFindingsReceipt, MeetingTaskFinding, } from "../meetings/index.js";
+export { PAYMENT_DIRECTIONS, PAYMENT_STATES, type Payment, paymentTitle, validatePayment } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, type PriorityLabel, priorityLabel, priorityOf, priorityOption, TASK_STATES, type TaskState, } from "../tasks/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
 export { assertMayDecide, DEFAULT_DECISION_POLICY, type Decider, type DecisionPolicy, mayDecide, type Proposer, type Refusal, } from "./decisions.js";
@@ -35,7 +36,7 @@ export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, PartialEmail, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
 export type { EvidenceSource } from "./sqlite/evidence-sources.js";
-export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
+export type { Fact, FactInput, FactsStore, PaymentFilter } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";
 export type { Involvement, InvolvementStore } from "./sqlite/involvements.js";

package/dist/store/index.js

@@ -1,6 +1,7 @@
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
+export { PAYMENT_DIRECTIONS, PAYMENT_STATES, paymentTitle, validatePayment } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, priorityLabel, priorityOf, priorityOption, TASK_STATES, } from "../tasks/index.js";
 export { assertMayDecide, DEFAULT_DECISION_POLICY, mayDecide, } from "./decisions.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";

package/dist/store/project-transfer/request.d.ts

@@ -4,7 +4,7 @@ export declare const projectAnnotationRequest: (request: ProjectAnnotationTarget
         format: "wirecat.project-annotations";
         facts: {
             ref: string;
-            type: "decision" | "fact" | "promise" | "question" | "statement";
+            type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
             statement: string;
             status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
             subject: string | null;

package/dist/store/project-transfer/schema.d.ts

@@ -23,7 +23,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
     readonly aliases: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.MaxLengthAction<string[], 1000, undefined>]>;
     readonly facts: v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, 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.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -38,7 +38,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         readonly updated_at: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>, v.MaxLengthAction<{
         ref: string;
-        type: "decision" | "fact" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
         statement: string;
         status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;

package/dist/store/project-transfer/snapshot-model.d.ts

@@ -4,7 +4,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
     readonly format: v.LiteralSchema<"wirecat.project-annotations", undefined>;
     readonly facts: v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, 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.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -19,7 +19,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         readonly updated_at: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>, v.MaxLengthAction<{
         ref: string;
-        type: "decision" | "fact" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
         statement: string;
         status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;

package/dist/store/sqlite/evidence-findings.js

@@ -167,7 +167,11 @@ export const evidenceFindingsStoreOver = (context) => {
                 : reason && checked.by === "agent"
                     ? { ...checked, reason: `${checked.reason}: ${reason}` }
                     : checked;
-            assertMayDecide({ id, proposedBy: proposals.proposer(id) }, decision.by, context.decisions);
+            assertMayDecide({
+                id,
+                proposedBy: proposals.proposer(id),
+                ownerOnly: batch.input.findings.some((finding) => finding.kind === "payment"),
+            }, decision.by, context.decisions);
             if (batch.receipt) {
                 if (JSON.stringify(batch.receipt.accepted) !== JSON.stringify(accepted))
                     return invalid("this findings batch was already reviewed with a different decision");

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

@@ -1,4 +1,5 @@
 import { type FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
+import { type PAYMENT_DIRECTIONS, type PAYMENT_STATES, type Payment } from "../../meetings/index.js";
 import { type Decider } from "../decisions.js";
 import { type Actor, type ProposedByFilter } from "./actors.js";
 import { type EvidenceSource } from "./evidence-sources.js";
@@ -34,6 +35,8 @@ export interface Fact {
     scope: (typeof MEMORY_SCOPES)[number] | null;
     source: string;
     evidence: string[];
+    /** Set on a `payment` fact only. */
+    payment: Payment | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -52,6 +55,14 @@ export interface FactInput {
     supersedes?: string;
     /** The memory an agent drew it from: a `created-from` link. */
     createdFrom?: string;
+    /** Required on a `payment` fact, refused on any other; checked as `validatePayment` does. */
+    payment?: Payment;
+}
+/** `open` is an expected payment that still holds: not superseded, rejected or cancelled. */
+export interface PaymentFilter {
+    direction?: (typeof PAYMENT_DIRECTIONS)[number];
+    state?: (typeof PAYMENT_STATES)[number];
+    open?: boolean;
 }
 export interface FactsStore {
     add(input: FactInput): Promise<Fact>;
@@ -62,6 +73,8 @@ export interface FactsStore {
         subject?: string;
         status?: Fact["status"];
         proposedBy?: ProposedByFilter;
+        /** Narrows to payment facts by their fields. */
+        payment?: PaymentFilter;
         /** `created` lists the newest written first; by default the newest by when it happened. */
         order?: "occurred" | "created";
         limit?: number;

package/dist/store/sqlite/facts.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { validatePayment } from "../../meetings/index.js";
 import { assertMayDecide, assertMayWithdraw, deciderAuthor } from "../decisions.js";
 import { proposedBySql, proposerOf } from "./actors.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
@@ -35,6 +36,7 @@ export const factOperationsOver = (context) => {
         scope: row.scope == null ? null : row.scope,
         source: String(row.source),
         evidence: evidenceOf(context, { type: "fact", id: Number(row.id) }),
+        payment: row.type === "payment" ? paymentOf(row.metadata) : null,
         createdAt: iso(row.created_at),
         updatedAt: iso(row.updated_at),
     });
@@ -49,7 +51,11 @@ export const factOperationsOver = (context) => {
         proposedBy: proposerOf(database, row.author_type, row.author_id),
         proposed: row.status === "proposed",
     }, by);
-    const decided = (row, by) => assertMayDecide({ id: `fact:${row.id}`, proposedBy: proposerOf(database, row.author_type, row.author_id) }, by, context.decisions);
+    const decided = (row, by) => assertMayDecide({
+        id: `fact:${row.id}`,
+        proposedBy: proposerOf(database, row.author_type, row.author_id),
+        ownerOnly: row.type === "payment",
+    }, by, context.decisions);
     /** Keeps who decided for the owner and why in `metadata.decision`; the decider's actor is in `confirmed_by`. */
     const keepDecision = (id, by, reason) => {
         const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
@@ -85,6 +91,7 @@ export const factOperationsOver = (context) => {
             const occurredAt = input.occurredAt === undefined ? null : calendarMoment(input.occurredAt, "occurredAt");
             if (occurredAt !== null && !Number.isFinite(occurredAt))
                 throw new CliError("validation_error", "occurredAt takes an ISO timestamp");
+            const payment = paymentInput(type, input);
             const id = write(database, () => {
                 const project = input.project === undefined ? undefined : requiredThing(database, input.project, "the project");
                 if (project && project.type !== "project")
@@ -93,14 +100,18 @@ export const factOperationsOver = (context) => {
                 const replaced = input.supersedes === undefined ? undefined : rowOf(input.supersedes);
                 if (replaced && replaced.status !== "proposed" && replaced.status !== "accepted")
                     throw new CliError("validation_error", `${input.supersedes} is ${String(replaced.status)}; only a proposed or accepted fact can be corrected`);
+                if (replaced && (replaced.type === "payment") !== (type === "payment"))
+                    throw new CliError("validation_error", "a payment fact corrects a payment fact, and only one");
+                if (payment?.counterparty)
+                    requiredThing(database, payment.counterparty, "the counterparty");
                 const owner = input.by === "owner";
                 const { actor, model } = authorActor(context, input.by);
                 const at = now();
                 const made = Number(database
                     .prepare("INSERT INTO facts (id, type, statement, status, project_id, subject_type, subject_id, occurred_at, supersedes_id, " +
-                    "author_type, author_id, model, scope, source, created_at, updated_at) " +
-                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", at, at)?.id);
+                    "author_type, author_id, model, scope, source, metadata, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", payment ? JSON.stringify({ payment }) : null, at, at)?.id);
                 linkEvidence(context, { type: "fact", id: made }, input.evidence ?? [], owner ? "owner" : "agent");
                 if (input.createdFrom !== undefined) {
                     const from = requiredThing(database, input.createdFrom, "the source");
@@ -121,11 +132,12 @@ export const factOperationsOver = (context) => {
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
             const by = proposedBySql("f.author_type", "f.author_id", options.proposedBy);
             const order = options.order === "created" ? "f.created_at" : "coalesce(f.occurred_at, f.created_at)";
+            const paid = paymentSql(options.payment);
             return database
                 .prepare(`${NAMED} WHERE f.deleted_at IS NULL AND (? IS NULL OR f.type = ?) AND (? IS NULL OR f.project_id = ?) ` +
                 "AND (? IS NULL OR (f.subject_type = ? AND f.subject_id = ?)) AND (? IS NULL OR f.status = ?) " +
-                `AND ${by.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
-                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                `AND ${by.sql}${paid.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
+                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, ...paid.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(factOf);
         },
         accept: (reference, by, reason) => {
@@ -183,6 +195,52 @@ export const factOperationsOver = (context) => {
         sources: (reference) => evidenceSourcesOf(database, { type: "fact", id: Number(rowOf(reference).id) }),
     };
 };
+const paymentInput = (type, input) => {
+    if (type !== "payment") {
+        if (input.payment !== undefined)
+            throw new CliError("validation_error", "only a payment fact takes a payment");
+        return undefined;
+    }
+    if (input.payment === undefined)
+        throw new CliError("validation_error", "a payment fact needs its payment: amount, currency, direction and state");
+    const evidence = input.evidence?.length ?? 0;
+    if (evidence < 1 || evidence > 8)
+        throw new CliError("validation_error", "a payment fact cites 1–8 references: the ask, the transfer or a sheet row");
+    return validatePayment(input.payment);
+};
+const paymentOf = (metadata) => {
+    if (metadata == null)
+        return null;
+    try {
+        const { payment } = JSON.parse(String(metadata));
+        return payment ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+const paymentSql = (filter) => {
+    if (filter === undefined)
+        return { sql: "", params: [] };
+    const parts = ["f.type = 'payment'"];
+    const params = [];
+    const state = filter.open ? "expected" : filter.state;
+    if (filter.open && filter.state !== undefined && filter.state !== "expected")
+        parts.push("0");
+    if (filter.direction !== undefined) {
+        parts.push("json_extract(f.metadata, '$.payment.direction') = ?");
+        params.push(filter.direction);
+    }
+    if (state !== undefined) {
+        parts.push("json_extract(f.metadata, '$.payment.state') = ?");
+        params.push(state);
+    }
+    if (filter.open)
+        parts.push("f.status IN ('proposed', 'accepted')");
+    if (filter.open === false)
+        parts.push("NOT (json_extract(f.metadata, '$.payment.state') = 'expected' AND f.status IN ('proposed', 'accepted'))");
+    return { sql: ` AND ${parts.join(" AND ")}`, params };
+};
 const migratedFrom = (metadata) => {
     try {
         const { memory } = JSON.parse(metadata);

package/dist/store/sqlite/findings-core.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { findingFingerprint, findingHash, } from "../../meetings/index.js";
+import { findingFingerprint, findingHash, paymentTitle, } from "../../meetings/index.js";
 import { factOperationsOver } from "./facts.js";
 import { linkEvidence } from "./memories.js";
 import { requiredThing } from "./notes.js";
@@ -81,6 +81,19 @@ export const findingsCoreOver = (context, kind) => {
             });
             return facts.acceptChecked(fact.ref, decidedBy).ref;
         }
+        if (finding.kind === "payment") {
+            const fact = facts.add({
+                type: "payment",
+                statement: finding.statement ?? paymentTitle(finding),
+                payment: finding.payment,
+                ...(finding.project === undefined ? {} : { project: finding.project }),
+                ...(finding.subject === undefined ? {} : { subject: finding.subject }),
+                ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
+                evidence,
+                by: agent,
+            });
+            return facts.acceptChecked(fact.ref, decidedBy).ref;
+        }
         if (finding.project === undefined)
             return invalid("a task finding names the project the task goes in");
         const task = tasks.create({

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

@@ -6,7 +6,7 @@ import type { Author } from "./memories.js";
 import { type Link } from "./notes.js";
 import type { StoreContext } from "./open.js";
 import type { ProposedAction } from "./proposed-actions.js";
-import { type KnowledgeRelation, type LinkDecision, type RelateInput, type RelationUpdate } from "./relation-proposals.js";
+import { type KnowledgeRelation, type LinkDecision, type RelateInput, type RelationUpdate, type Scored } from "./relation-proposals.js";
 import type { TagCreationOptions } from "./tag-creation.js";
 import { type Label, type TagKind, type TagRow } from "./tags.js";
 import { type ThingState } from "./things.js";
@@ -190,7 +190,21 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         purpose?: string;
         evidence?: string[];
         reason?: string;
-    }, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    } & Scored, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    /**
+     * Where a pair stands for a scan: `linked` when a link already joins it, `rejected` when any `relationship`
+     * proposal for it was rejected, and the pending proposal if one waits. `undefined` when either end is not stored.
+     */
+    relationState(key: KnowledgeScope, input: {
+        from: string;
+        to: string;
+        kind: KnowledgeRelation["kind"];
+    }): Promise<{
+        linked: boolean;
+        confirmed: boolean;
+        rejected: boolean;
+        pending: ProposedAction | null;
+    } | undefined>;
     /** The owner sets a relationship's role and purpose; `null` clears one. */
     updateRelation(key: KnowledgeScope, id: string, input: RelationUpdate & {
         by: "owner";

package/dist/store/sqlite/knowledge.js

@@ -562,6 +562,7 @@ export const knowledgeStoreOver = (context) => {
                 });
             return proposals.propose(from, input, by);
         },
+        relationState: async (key, input) => proposals.state(() => pair(key, input), input),
         updateRelation: (async (key, id, input) => {
             checked(key);
             const link = linkOf(database, relation(id));

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

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

package/dist/store/sqlite/lucene.js

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

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

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

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

@@ -0,0 +1,4 @@
+import { type MeetingStore } from "../../meetings/index.js";
+import type { StoreContext } from "./open.js";
+export type MeetingLanguageStore = Required<Pick<MeetingStore, "fillTranscriptLanguages">>;
+export declare const meetingLanguagesOver: ({ database }: StoreContext) => MeetingLanguageStore;