@wirecat/cli-core 0.557.0 → 0.559.0

package/dist/meetings/findings-rules.js

@@ -70,20 +70,27 @@ export const validateFindings = (input, rules) => {
         if (finding.kind === "fact") {
             fields(finding, ["id", "project", "subject", "evidence", "kind", "type", "statement"], rules.singular);
             if (finding.type === "payment")
-                return invalid("a payment is a finding of kind payment");
+                return invalid("a payment is a finding of kind payment; money is a payments row, not a fact");
             if (!FACT_TYPES.includes(finding.type))
                 return invalid("unknown fact finding type");
             return { ...base, kind: "fact", type: finding.type, statement: text(finding.statement, 2000) };
         }
         if (finding.kind === "payment" && rules.payments) {
             fields(finding, ["id", "project", "subject", "evidence", "kind", "statement", "payment", "supersedes"], rules.singular);
-            if (finding.supersedes !== undefined && !/^fact:[1-9]\d*$/.test(String(finding.supersedes)))
-                return invalid("a payment finding supersedes a fact: reference");
+            if (finding.supersedes !== undefined && !/^invoice:[1-9]\d*$/.test(String(finding.supersedes)))
+                return invalid("a payment finding supersedes an invoice: reference, the expected payment it settles or voids");
+            const payment = validatePayment(finding.payment);
+            if (payment.state === "expected" && finding.supersedes !== undefined)
+                return invalid("an expected payment supersedes nothing; a paid or cancelled one supersedes its invoice");
+            if (payment.state === "cancelled" && finding.supersedes === undefined)
+                return invalid("a cancelled payment names the invoice: it cancels in supersedes");
+            if (payment.state === "expected" && !/^(person|organization):/.test(payment.counterparty ?? ""))
+                return invalid("an expected payment becomes an invoice, which names its counterparty as a person: or organization:");
             return {
                 ...base,
                 kind: "payment",
                 ...(finding.statement === undefined ? {} : { statement: text(finding.statement, 2000) }),
-                payment: validatePayment(finding.payment),
+                payment,
                 ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
             };
         }

package/dist/meetings/payment.d.ts

@@ -1,8 +1,11 @@
-/** Every fact type the store takes; findings and meeting changes check against the same list. */
-export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise", "payment"];
+/** Every fact type the store takes; findings and meeting changes check against the same list. Money is not a fact. */
+export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise"];
 export declare const PAYMENT_DIRECTIONS: readonly ["to_us", "from_us"];
 export declare const PAYMENT_STATES: readonly ["expected", "paid", "cancelled"];
-/** A payment fact's fields, kept in `facts.metadata.payment`. */
+/**
+ * A payment finding's fields, as an agent reads them from evidence. Confirmed by the owner, a paid one becomes a
+ * `payments` row, an expected one an invoice, a cancelled one voids the invoice it supersedes.
+ */
 export interface Payment {
     /** A decimal as text with two places, "50000.00": money is never a float. */
     amount: string;
@@ -14,14 +17,15 @@ export interface Payment {
     counterparty_name: string | null;
     /** An ISO date. */
     due_at: string | null;
-    /** A change of state is a new fact that supersedes this one, so the history and its evidence stay. */
     state: (typeof PAYMENT_STATES)[number];
-    /** What it is for, short: "support, September". The fact's statement is the full sentence. */
+    /** What it is for, short: "support, September". The finding's statement is the full sentence. */
     item: string | null;
+    /** When a paid one was paid, an ISO date; without it the due date, else the day the owner confirms it. */
+    paid_at?: string;
 }
 /** A payment as stored: the amount with two decimals, the currency upper case; refuses what is not one. */
 export declare const validatePayment: (input: unknown) => Payment;
-/** One line for a payment, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
+/** One line for a payment finding, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
 export declare const paymentTitle: (fact: {
     payment: Payment | null;
 }) => string;

package/dist/meetings/payment.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
-/** Every fact type the store takes; findings and meeting changes check against the same list. */
-export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise", "payment"];
+/** Every fact type the store takes; findings and meeting changes check against the same list. Money is not a fact. */
+export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
 export const PAYMENT_DIRECTIONS = ["to_us", "from_us"];
 export const PAYMENT_STATES = ["expected", "paid", "cancelled"];
 const invalid = (message) => {
@@ -21,7 +21,7 @@ const amountOf = (value) => {
 const dateOf = (value) => {
     const date = typeof value === "string" ? value.trim() : "";
     if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) !== date)
-        return invalid("a payment's due date is an ISO date, such as 2026-10-31");
+        return invalid("a payment's dates are ISO dates, such as 2026-10-31");
     return date;
 };
 const optionalText = (value, what, limit) => {
@@ -36,7 +36,17 @@ const oneOf = (value, allowed, what) => {
         return invalid(`a payment's ${what} is one of ${allowed.join(", ")}`);
     return value;
 };
-const FIELDS = ["amount", "currency", "direction", "counterparty", "counterparty_name", "due_at", "state", "item"];
+const FIELDS = [
+    "amount",
+    "currency",
+    "direction",
+    "counterparty",
+    "counterparty_name",
+    "due_at",
+    "state",
+    "item",
+    "paid_at",
+];
 /** A payment as stored: the amount with two decimals, the currency upper case; refuses what is not one. */
 export const validatePayment = (input) => {
     if (!input || typeof input !== "object" || Array.isArray(input))
@@ -51,6 +61,9 @@ export const validatePayment = (input) => {
     const counterparty = optionalText(raw.counterparty, "counterparty", 80);
     if (counterparty !== null && !COUNTERPARTY.test(counterparty))
         return invalid("a payment's counterparty is a person:, organization: or project: reference");
+    const state = oneOf(raw.state, PAYMENT_STATES, "state");
+    if (raw.paid_at != null && state !== "paid")
+        return invalid("only a paid payment has paid_at");
     return {
         amount: amountOf(raw.amount),
         currency,
@@ -58,8 +71,10 @@ export const validatePayment = (input) => {
         counterparty,
         counterparty_name: optionalText(raw.counterparty_name, "counterparty name", 200),
         due_at: raw.due_at === undefined || raw.due_at === null ? null : dateOf(raw.due_at),
-        state: oneOf(raw.state, PAYMENT_STATES, "state"),
+        state,
         item: optionalText(raw.item, "item", 200),
+        // Left out when absent, so a finding staged before the field keeps its fingerprint.
+        ...(raw.paid_at == null ? {} : { paid_at: dateOf(raw.paid_at) }),
     };
 };
 const grouped = (amount) => {
@@ -67,7 +82,7 @@ const grouped = (amount) => {
     const digits = whole.replace(/\B(?=(\d{3})+(?!\d))/g, " ");
     return cents === "00" ? digits : `${digits}.${cents}`;
 };
-/** One line for a payment, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
+/** One line for a payment finding, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
 export const paymentTitle = (fact) => {
     const payment = fact.payment;
     if (!payment)

package/dist/runs/secrets.d.ts

@@ -1,4 +1,6 @@
 export declare const secretNamed: (name: string) => boolean;
+/** A credential in a shape vendors publish so scanners find it: a known token prefix, a private key, a `Bearer` value. */
+export declare const holdsCredential: (text: string) => boolean;
 /**
  * Whether a run of token characters is a random string rather than words: long, mixed case, high Shannon entropy,
  * cut into short pieces (`Kz9vQ2mX`) where a name is cut into words (`InlineQueryResultMpeg4Gif`).

package/dist/runs/secrets.js

@@ -54,6 +54,8 @@ const PRIVATE_KEY = /-----BEGIN[A-Z ]* PRIVATE KEY-----[\s\S]*?(?:-----END[A-Z ]
 const SCHEME = /(?<![A-Za-z])(Bearer|Basic)(\s+)(?![A-Z]?[a-z]+(?![A-Za-z0-9]))[A-Za-z0-9._~+/=-]{8,}/g;
 // After a bare space only a value that is not a plain word: `pin 1234` is a secret, `pin this message` is not.
 const NAMED_PAIR = /(?<![\p{L}\p{N}])([\p{L}\p{N}_.-]*(?:token|pass|pwd|pin|otp|2fa|secret|credential|cookie|authorization|key|contrase|clave|пароль|пин|код)[\p{L}\p{N}_.-]*)(["']?\s*(?:=>|[:=])\s*["']?|\s+(?![\p{L}]+(?![\p{L}\p{N}])))((?:Bearer\s+|Basic\s+)?)([^\s"'&,;]+)/giu;
+/** A credential in a shape vendors publish so scanners find it: a known token prefix, a private key, a `Bearer` value. */
+export const holdsCredential = (text) => text.search(PRIVATE_KEY) >= 0 || text.search(KNOWN_TOKENS) >= 0 || text.search(SCHEME) >= 0;
 /**
  * Whether a run of token characters is a random string rather than words: long, mixed case, high Shannon entropy,
  * cut into short pieces (`Kz9vQ2mX`) where a name is cut into words (`InlineQueryResultMpeg4Gif`).

package/dist/services/index.d.ts

@@ -6,6 +6,7 @@ export { type ChatCoverage, chatCoverage } from "./chat-coverage.js";
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
+export { type IngestOptions, type IngestReceipt, ingest } from "./ingest.js";
 export { aliasHits, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, type LinkCandidate, type LinkScorer, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput as LinkScanInput, type ScannedProject, type ScannedProposal, type ScanResult as LinkScanResult, type ScorerInput, type Signal as LinkSignal, scanProjectLinks, } from "./link-scorers/index.js";
 export type { MediaArchiveOptions, MediaArchivePorts } from "./media-archive.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";

package/dist/services/index.js

@@ -5,6 +5,7 @@ export { AGENDA_DEFAULTS } from "./agenda.js";
 export { chatCoverage } from "./chat-coverage.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
+export { ingest } from "./ingest.js";
 export { aliasHits, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./link-scorers/index.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";
 export { moveMediaArchive } from "./media-archive-move.js";

package/dist/services/ingest.d.ts

@@ -0,0 +1,45 @@
+import { type IngestError } from "../domain/records.js";
+import type { MessageStore } from "../store/store.js";
+export interface IngestOptions {
+    /** The account the caller means; the envelope's `source.account` must be this one. */
+    account: string;
+    /** Checks and plans everything, then writes nothing. */
+    dryRun?: boolean;
+    /** Records per transaction, 1000 by default. */
+    chunk?: number;
+}
+export interface IngestReceipt {
+    dryRun: boolean;
+    source: {
+        provider: string;
+        account: string;
+        batchId: string;
+    } | null;
+    created: number;
+    updated: number;
+    unchanged: number;
+    deleted: number;
+    refused: number;
+    /** `invoice:` and `payment:` proposals this import made; the owner confirms them in review. */
+    proposed: string[];
+    /** Kept, with no entity yet: each named role points at a record not imported, or one with no entity. */
+    waiting: {
+        key: string;
+        pointer: string;
+        missing: string[];
+    }[];
+    /** Changed or deleted at the source after the entity was made from it: the entity was not touched. */
+    flagged: {
+        key: string;
+        pointer: string;
+        entity: string;
+    }[];
+    errors: IngestError[];
+}
+/**
+ * Takes a v1 records envelope (or `envelopeOfJsonl` of a JSONL file) into the store: checks it, then writes per
+ * chunk in one transaction. The same import twice writes nothing new. A record with a lower revision than the stored
+ * one is refused, a delete is soft, a reference to a record not yet imported waits for it, and nothing is linked by
+ * name. An invoice or a payment becomes a proposal: an import never writes confirmed money.
+ */
+export declare const ingest: (store: Pick<MessageStore, "records">, envelope: unknown, { account, dryRun, chunk }: IngestOptions) => Promise<IngestReceipt>;

package/dist/services/ingest.js

@@ -0,0 +1,80 @@
+import { envelopeErrors, pointerOf, recordErrors, } from "../domain/records.js";
+const emptyReceipt = (dryRun) => ({
+    dryRun,
+    source: null,
+    created: 0,
+    updated: 0,
+    unchanged: 0,
+    deleted: 0,
+    refused: 0,
+    proposed: [],
+    waiting: [],
+    flagged: [],
+    errors: [],
+});
+/**
+ * Takes a v1 records envelope (or `envelopeOfJsonl` of a JSONL file) into the store: checks it, then writes per
+ * chunk in one transaction. The same import twice writes nothing new. A record with a lower revision than the stored
+ * one is refused, a delete is soft, a reference to a record not yet imported waits for it, and nothing is linked by
+ * name. An invoice or a payment becomes a proposal: an import never writes confirmed money.
+ */
+export const ingest = async (store, envelope, { account, dryRun = false, chunk = 1000 }) => {
+    const receipt = emptyReceipt(dryRun);
+    const broken = envelopeErrors(envelope, account);
+    if (broken.length > 0)
+        return { ...receipt, errors: broken };
+    const { source, records } = envelope;
+    receipt.source = { provider: source.provider, account: source.account, batchId: source.batch_id };
+    const taken = [];
+    const keys = new Set();
+    const identities = new Set();
+    for (const [index, record] of records.entries()) {
+        const errors = recordErrors(record, index);
+        const valid = record;
+        if (errors.length === 0 && keys.has(valid.key))
+            errors.push({
+                pointer: pointerOf("records", index, "key"),
+                code: "record.duplicate-key",
+                message: "another record of this envelope has this key",
+                key: valid.key,
+            });
+        const identity = errors.length === 0 ? `${valid.type}\0${valid.external_id}` : "";
+        if (errors.length === 0 && identities.has(identity))
+            errors.push({
+                pointer: pointerOf("records", index, "external_id"),
+                code: "record.duplicate",
+                message: `another record of this envelope is ${valid.type} ${valid.external_id}`,
+                key: valid.key,
+            });
+        if (errors.length > 0) {
+            receipt.refused += 1;
+            for (const error of errors)
+                receipt.errors.push(error);
+            continue;
+        }
+        keys.add(valid.key);
+        identities.add(identity);
+        taken.push({ index, record: valid });
+    }
+    const written = await store.records.write(source, taken, { dryRun, chunk });
+    for (const outcome of written.outcomes) {
+        receipt[outcome.status] += 1;
+        if (outcome.error)
+            receipt.errors.push(outcome.error);
+    }
+    for (const error of written.laterErrors)
+        receipt.errors.push(error);
+    receipt.errors.sort((a, b) => a.pointer.localeCompare(b.pointer, "en", { numeric: true }));
+    receipt.proposed = written.proposed;
+    receipt.waiting = written.waiting.map(({ index, key, missing }) => ({
+        key,
+        pointer: pointerOf("records", index, "relations"),
+        missing,
+    }));
+    receipt.flagged = written.flagged.map(({ index, key, entity }) => ({
+        key,
+        pointer: pointerOf("records", index),
+        entity,
+    }));
+    return receipt;
+};

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

@@ -60,7 +60,7 @@ export interface ProjectStatus {
     chats: StatusChatSummary[];
     /** Every signal's items, in signal order, then chat order. */
     items: StatusItem[];
-    /** Open amounts and expected payment facts, summed per direction and currency. */
+    /** Open amounts and what confirmed open invoices still owe, summed per direction and currency. */
     money: {
         open: MoneyTotal[];
     };

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

@@ -53,11 +53,15 @@ const childrenOf = async (store, root, catalog) => {
 };
 const inAccounts = (accounts, provider, account) => accounts === undefined || accounts.some((one) => one.provider === provider && one.account === account);
 const failure = (error) => (error instanceof Error ? error.message : String(error));
-/** An open ask, or an expected payment fact; an ask that a payment fact cites is counted once, as the fact. */
+/**
+ * An open ask, or a confirmed open invoice; an ask that a confirmed row cites is counted once, as the row. A proposed
+ * row promises nothing yet, so the ask it cites still counts.
+ */
 const counted = (items) => {
-    const recorded = new Set(items.filter((item) => item.signal === "payments").flatMap((item) => item.evidence.slice(1).map((one) => one.ref)));
+    const confirmed = (item) => item.signal === "payments" && item.data.status === "confirmed";
+    const recorded = new Set(items.filter(confirmed).flatMap((item) => item.evidence.slice(1).map((one) => one.ref)));
     return (item, state) => item.signal === "payments"
-        ? state === "expected"
+        ? state === "expected" && confirmed(item)
         : item.signal === "amounts" && state === "open" && !item.evidence.some((one) => recorded.has(one.ref));
 };
 const totalsOf = (items) => {

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

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

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

@@ -1,24 +1,50 @@
-import { paymentTitle } from "../../../meetings/index.js";
-const HOLDING = new Set(["proposed", "accepted"]);
-/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+const holding = (row) => row.review !== "rejected";
+const item = (row, at, data) => ({
+    signal: "payments",
+    chat: null,
+    at,
+    who: null,
+    // The row first, then what it cites, so an amount read from a cited message is not counted twice.
+    evidence: [row.ref, ...row.evidence].map((ref) => ({ ref, fingerprint: null })),
+    basis: "store",
+    data: { ...data, title: row.title, status: row.review },
+});
+const paid = (row) => {
+    const party = row.direction === "in" ? row.payer : row.payee;
+    return item(row, `${row.date}T00:00:00.000Z`, {
+        amount: row.amount,
+        currency: row.currency,
+        direction: row.direction === "in" ? "to_us" : "from_us",
+        counterparty: party?.ref ?? null,
+        counterparty_name: party?.name ?? null,
+        due_at: null,
+        state: "paid",
+        item: row.reference,
+        paid_at: row.date,
+    });
+};
+/** What an open invoice still owes is the expected payment. */
+const expected = (row) => item(row, row.issueDate === null ? row.createdAt : `${row.issueDate}T00:00:00.000Z`, {
+    amount: row.open,
+    currency: row.currency,
+    direction: row.direction === "receivable" ? "to_us" : "from_us",
+    counterparty: row.counterparty.ref,
+    counterparty_name: row.counterparty.name,
+    due_at: row.dueDate,
+    state: "expected",
+    item: row.number,
+});
+/** Payments and open invoices of the project and its children from `store.finance`, proposed or confirmed. */
 export const payments = {
     id: "payments",
-    version: 2,
+    version: 3,
     scope: "project",
     read: async (context) => {
         const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
-        const facts = (await Promise.all(projects.map((project) => context.store.facts.list({ project, type: "payment", limit: 500 })))).flat();
-        return facts
-            .filter((fact) => fact.payment !== null && HOLDING.has(fact.status))
-            .map((fact) => ({
-            signal: "payments",
-            chat: null,
-            at: fact.occurredAt ?? fact.createdAt,
-            who: null,
-            // The fact first, then what it cites, so an amount read from a cited message is not counted twice.
-            evidence: [fact.ref, ...fact.evidence].map((ref) => ({ ref, fingerprint: null })),
-            basis: "fact",
-            data: { ...fact.payment, title: paymentTitle(fact), status: fact.status },
-        }));
+        const rows = await Promise.all(projects.map(async (project) => [
+            ...(await context.store.finance.payments({ project, limit: 500 })).filter(holding).map(paid),
+            ...(await context.store.finance.invoices({ project, open: true, limit: 500 })).filter(holding).map(expected),
+        ]));
+        return rows.flat();
     },
 };

package/dist/store/evidence-findings.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator, parseLocator } from "../domain/locator.js";
 import { validateFindings } from "../meetings/index.js";
+import { entryAmount } from "./sqlite/payment-entries.js";
 export const EVIDENCE_FINDINGS_KIND = "evidence_findings";
 const reference = (raw) => {
     if (/^(document|note):[1-9]\d*$/.test(raw))
@@ -12,11 +13,18 @@ const reference = (raw) => {
         throw new CliError("validation_error", "finding evidence is a msg:, document: or note: reference");
     }
 };
-export const validateEvidenceFindings = (input) => validateFindings(input, {
-    plural: "evidence findings",
-    singular: "evidence finding",
-    cited: "reference",
-    reference,
-    anySubject: true,
-    payments: true,
-});
+export const validateEvidenceFindings = (input) => {
+    const valid = validateFindings(input, {
+        plural: "evidence findings",
+        singular: "evidence finding",
+        cited: "reference",
+        reference,
+        anySubject: true,
+        payments: true,
+    });
+    // Refused at staging rather than when the owner accepts, which would fail the whole batch.
+    for (const finding of valid.findings)
+        if (finding.kind === "payment")
+            entryAmount(finding.payment);
+    return valid;
+};

package/dist/store/index.d.ts

@@ -36,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, PaymentFilter } from "./sqlite/facts.js";
+export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export type { Allocation, FinanceStore, Invoice, InvoiceDetail, InvoiceInput, InvoiceLine, InvoiceLineInput, OpenTotal, Party, Payment as FinancePayment, PaymentDetail as FinancePaymentDetail, PaymentInput as FinancePaymentInput, } from "./sqlite/finance.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";
@@ -54,6 +54,7 @@ export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, typ
 export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export { PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
+export type { RecordKey, RecordOutcome, RecordStore, RecordsWritten, SourceRecord, } from "./sqlite/records.js";
 export type { LinkDecision, RelationUpdate } from "./sqlite/relation-proposals.js";
 export { fillSearchIndex, resetSearchIndex, type SearchIndexFill, type SearchIndexState, searchIndexState, } from "./sqlite/search-index.js";
 export type { SyncStateSave } from "./sqlite/sync.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" | "payment" | "promise" | "question" | "statement";
+            type: "decision" | "fact" | "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", "payment"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], 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" | "payment" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "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", "payment"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], 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" | "payment" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "promise" | "question" | "statement";
         statement: string;
         status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;

package/dist/store/sqlite/accounts.js

@@ -114,6 +114,10 @@ export const purgeAccount = ({ orm, database }, accountKey) => {
     // The inbox project and its tasks are the owner's; only the tie to the account goes.
     orm.update(projects).set({ accountId: null }).where(eq(projects.accountId, accountKey)).run();
     orm.run(sql `DELETE FROM files WHERE account_id = ${accountKey}`);
+    // An entity made from a record is the owner's and stays; only what the source said goes.
+    const recordsOf = sql `(SELECT id FROM records WHERE account_id = ${accountKey})`;
+    orm.run(sql `DELETE FROM record_relations WHERE record_id IN ${recordsOf} OR target_id IN ${recordsOf}`);
+    orm.run(sql `DELETE FROM records WHERE account_id = ${accountKey}`);
     orm.delete(accounts).where(eq(accounts.id, accountKey)).run();
     dropOrphanPeople(database, unseenBefore);
     dropUnusedVectors(database, hashes);

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

@@ -1,5 +1,4 @@
 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";
@@ -35,8 +34,6 @@ 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;
 }
@@ -55,14 +52,6 @@ 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>;
@@ -73,8 +62,6 @@ 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;