@wirecat/cli-core 0.549.0 → 0.551.0

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

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

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

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

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

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

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

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

package/dist/services/proposals/index.js

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

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

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

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

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

package/dist/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/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/email-locations.d.ts

@@ -23,7 +23,8 @@ export declare const locate: (database: CacheDatabase, accountId: number, emailI
 export declare const folderEmails: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string) => FolderEmail[];
 /**
  * An email stored from its first bytes only (`metadata.partial`): a sync reads it whole and clears the mark.
- * `partialEmails` lists an account's live ones newest first, with how many there are in all.
+ * `partialEmails` lists an account's live ones newest first, with how many there are in all; one given up on
+ * (`partial.stuck`) is left out and only counted, so it never holds back newer ones. Its newest location comes first.
  */
 export interface PartialEmail {
     externalId: string;
@@ -35,6 +36,26 @@ export interface PartialEmail {
 export declare const partialEmails: (database: CacheDatabase, accountId: number, limit: number) => {
     emails: PartialEmail[];
     total: number;
+    stuck: number;
 };
+/** Replaces a partial email's `metadata.partial`, as a failed read records itself; a whole email is left alone. */
+export declare const markPartial: (database: CacheDatabase, accountId: number, externalId: string, mark: Metadata) => {
+    changes: number;
+};
+export interface PartialMailStore {
+    partialEmails(accountId: number, limit: number): Promise<{
+        emails: PartialEmail[];
+        total: number;
+        stuck: number;
+    }>;
+    /** Records a failed read of a partial email in its `metadata.partial`; a whole email is left alone. */
+    markPartial(accountId: number, externalId: string, mark: Metadata): Promise<void>;
+}
+export declare const partialMail: (database: CacheDatabase) => PartialMailStore;
+/**
+ * A live email stored whole, which a partial copy must not replace: a server search checks what is held before its
+ * slow read, and a sync in another process may store the email whole in between.
+ */
+export declare const storedWhole: (database: CacheDatabase, emailId: number) => boolean;
 export declare const setLocations: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string, found: ReadonlyMap<string, number[]>) => number;
 export declare const forgetLocations: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string, uids: number[]) => void;

package/dist/store/sqlite/email-locations.js

@@ -1,4 +1,5 @@
 import { fromJson } from "./events.js";
+import { write } from "./transaction.js";
 export const locate = (database, accountId, emailId, where) => database
     .prepare(`INSERT OR REPLACE INTO email_locations (mailbox_id, uidvalidity, uid, email_id)
          SELECT id, ?, ?, ? FROM mailboxes WHERE account_id = ? AND external_id = ?`)
@@ -26,14 +27,22 @@ export const partialEmails = (database, accountId, limit) => {
     const rows = database
         .prepare(`SELECT e.external_id, t.external_id AS thread, coalesce(e.received_at, e.sent_at) AS at, e.metadata,
          count(*) OVER () AS total,
-         (SELECT json_group_array(json_object('folder', b.external_id, 'uidvalidity', l.uidvalidity, 'uid', l.uid))
-            FROM email_locations l JOIN mailboxes b ON b.id = l.mailbox_id WHERE l.email_id = e.id) AS places
+         (SELECT json_group_array(json_object('folder', folder, 'uidvalidity', uidvalidity, 'uid', uid))
+            FROM (SELECT b.external_id AS folder, l.uidvalidity, l.uid
+                    FROM email_locations l JOIN mailboxes b ON b.id = l.mailbox_id
+                    WHERE l.email_id = e.id ORDER BY l.rowid DESC)) AS places
        FROM emails e JOIN email_threads t ON t.id = e.email_thread_id
        WHERE e.account_id = ? AND e.deleted_at IS NULL AND json_extract(e.metadata, '$.partial') IS NOT NULL
+         AND json_extract(e.metadata, '$.partial.stuck') IS NULL
        ORDER BY at DESC, e.id DESC LIMIT ?`)
         .all(accountId, limit);
+    const stuck = database
+        .prepare(`SELECT count(*) AS n FROM emails WHERE account_id = ? AND deleted_at IS NULL
+         AND json_extract(metadata, '$.partial.stuck') IS NOT NULL`)
+        .get(accountId);
     return {
         total: rows.length ? Number(rows[0]?.total) : 0,
+        stuck: Number(stuck?.n ?? 0),
         emails: rows.map((row) => ({
             externalId: String(row.external_id),
             threadExternalId: String(row.thread),
@@ -47,6 +56,24 @@ export const partialEmails = (database, accountId, limit) => {
         })),
     };
 };
+/** Replaces a partial email's `metadata.partial`, as a failed read records itself; a whole email is left alone. */
+export const markPartial = (database, accountId, externalId, mark) => database
+    .prepare(`UPDATE emails SET metadata = json_set(metadata, '$.partial', json(?)) WHERE account_id = ? AND external_id = ?
+         AND json_extract(metadata, '$.partial') IS NOT NULL`)
+    .run(JSON.stringify(mark), accountId, externalId);
+export const partialMail = (database) => ({
+    partialEmails: async (accountId, limit) => partialEmails(database, accountId, limit),
+    markPartial: async (accountId, externalId, mark) => {
+        write(database, () => markPartial(database, accountId, externalId, mark));
+    },
+});
+/**
+ * A live email stored whole, which a partial copy must not replace: a server search checks what is held before its
+ * slow read, and a sync in another process may store the email whole in between.
+ */
+export const storedWhole = (database, emailId) => database
+    .prepare("SELECT 1 FROM emails WHERE id = ? AND deleted_at IS NULL AND json_extract(metadata, '$.partial') IS NULL")
+    .get(emailId) !== undefined;
 export const setLocations = (database, accountId, folder, uidvalidity, found) => {
     database
         .prepare(`DELETE FROM email_locations WHERE uidvalidity <> ?

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

@@ -3,13 +3,13 @@ import type { Attachment, Metadata } from "../../meetings/index.js";
 import type { Stemmer, Stemmers } from "../../search/stem.js";
 import type { CacheDatabase } from "../driver.js";
 import type { ConversationSummary, StoredHit } from "../types.js";
-import { type EmailLocationInput, type FolderEmail, type PartialEmail } from "./email-locations.js";
+import { type EmailLocationInput, type FolderEmail, type PartialMailStore } from "./email-locations.js";
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
 import type { StoreContext } from "./open.js";
 import { type SyncStateSave } from "./sync.js";
 import { type ThreadFilter } from "./thread-columns.js";
-export type { EmailLocationInput, FolderEmail, PartialEmail };
+export type { EmailLocationInput, FolderEmail, PartialEmail } from "./email-locations.js";
 export interface EmailAddress {
     address: string;
     name: string | null;
@@ -205,7 +205,7 @@ export interface SenderScore {
     demoted?: boolean;
 }
 /** Mail in tables of its own: threads, emails, recipients and mailboxes, keyed by account and Message-ID. */
-export interface MailStore {
+export interface MailStore extends PartialMailStore {
     saveThread(input: ThreadSave): Promise<ThreadDetails>;
     /** Several threads and sync state in one transaction: a slice of mail commits with its resume point, or not at all. */
     saveThreads(inputs: ThreadSave[], states?: SyncStateSave[]): Promise<ThreadDetails[]>;
@@ -217,10 +217,6 @@ export interface MailStore {
     emails(filter?: EmailFilter): Promise<Email[]>;
     /** Each matching email's Message-ID and mailboxes, without text or people: cheap over a whole mailbox. */
     emailRefs(filter?: Omit<EmailFilter, "limit" | "offset">): Promise<EmailRef[]>;
-    partialEmails(accountId: number, limit: number): Promise<{
-        emails: PartialEmail[];
-        total: number;
-    }>;
     /** Each matching email's sender, recipients, list, size, flag and mailboxes, oldest first; no text. */
     emailFacts(filter?: Omit<EmailFilter, "limit" | "offset">): Promise<EmailFacts[]>;
     /**

package/dist/store/sqlite/emails.js

@@ -2,7 +2,7 @@ import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
-import { folderEmails, forgetLocations, locate, partialEmails, setLocations, } from "./email-locations.js";
+import { folderEmails, forgetLocations, locate, partialMail, setLocations, storedWhole, } from "./email-locations.js";
 import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
 import { bool, flag, fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
@@ -204,6 +204,8 @@ const saveEmail = (database, orm, accountId, threadId, mail, now) => {
     const found = database
         .prepare("SELECT id, email_thread_id FROM emails WHERE account_id = ? AND external_id = ?")
         .get(accountId, mail.externalId);
+    if (found && mail.metadata?.partial !== undefined && storedWhole(database, Number(found.id)))
+        return null;
     let emailId;
     if (found) {
         emailId = Number(found.id);
@@ -469,7 +471,7 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             mailboxes: JSON.parse(String(row.boxes)),
         }));
     },
-    partialEmails: async (accountId, limit) => partialEmails(database, accountId, limit),
+    ...partialMail(database),
     async emailFacts(filter = {}) {
         const [where, params] = emailWhere(filter);
         return database

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;