@wirecat/cli-core 0.559.0 → 0.560.0

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

@@ -64,6 +64,8 @@ export interface ProposalKind {
     readonly stored?: readonly string[];
     /** Whether its proposals have parts decided on their own, as a findings batch has findings. */
     readonly parts?: boolean;
+    /** Only the owner decides it, whatever the host's `agent_decisions` says. */
+    readonly ownerOnly?: boolean;
     /** Bounded: at most `offset + limit` rows, newest first. */
     list(filter: ProposalFilter): Promise<ProposalRow[]>;
     get(id: string): Promise<ProposalRow>;

package/dist/store/decisions.d.ts

@@ -22,7 +22,7 @@ export type Decider = "owner" | {
     reason: string;
 };
 export interface DecisionPolicy {
-    /** The host's `agent_decisions`: `false` keeps every decision with the owner. */
+    /** The host's `agent_decisions`: off unless the owner sets it to `true`; off keeps every decision with the owner. */
     agentDecisions: boolean;
     /** A rule scorer's proposal is the owner's alone to decide. */
     ruleProposalsOwnerOnly: boolean;

package/dist/store/decisions.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-export const DEFAULT_DECISION_POLICY = { agentDecisions: true, ruleProposalsOwnerOnly: true };
+export const DEFAULT_DECISION_POLICY = { agentDecisions: false, ruleProposalsOwnerOnly: true };
 /**
  * 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.

package/dist/store/index.d.ts

@@ -16,6 +16,7 @@ export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./dr
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, type EvidenceFindingsBatch, type EvidenceFindingsDecider, type EvidenceFindingsReceipt, type EvidenceFindingsStore, validateEvidenceFindings, } from "./evidence-findings.js";
 export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
+export { MAIL_FINDINGS_KIND, type MailFindingsBatch, type MailFindingsStore } from "./mail-findings.js";
 export type { MeetingFindingsBatch, MeetingFindingsStore } from "./meeting-findings.js";
 export { MIGRATIONS, type Migration, migrate } from "./migrations.js";
 export { openCache } from "./open.js";

package/dist/store/index.js

@@ -8,6 +8,7 @@ export { applyDocumentTransfer, previewDocumentTransfer } from "./document-trans
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
 export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
+export { MAIL_FINDINGS_KIND } from "./mail-findings.js";
 export { MIGRATIONS, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
 export { storePath } from "./path.js";

package/dist/store/mail-findings.d.ts

@@ -0,0 +1,51 @@
+import type { MailFindingsInput } from "../mail/findings.js";
+import type { FindingOutcome, FindingsReceipt } from "../meetings/index.js";
+import type { Decider } from "./decisions.js";
+import type { AccountKey } from "./types.js";
+export declare const MAIL_FINDINGS_KIND = "mail_findings";
+export interface MailFindingsBatch {
+    id: string;
+    account: AccountKey;
+    input: MailFindingsInput;
+    fingerprint: string;
+    status: "proposed" | "reviewed";
+    author: {
+        type: "person" | "bot";
+        id: string;
+        name: string | null;
+        kind: "agent" | "rule" | null;
+    };
+    decidedBy: {
+        type: "person" | "bot";
+        id: string;
+    } | null;
+    decidedAt: string | null;
+    previous: FindingOutcome[];
+    receipt: FindingsReceipt | null;
+}
+/**
+ * What an agent read in new mail — tasks, task updates, facts, memories, links, new contacts — cited and staged for
+ * the owner, one batch per mailbox and run. Only the owner decides one: an agent's mail proposal never becomes the
+ * owner's word without him.
+ */
+export interface MailFindingsStore {
+    stage(account: AccountKey, input: MailFindingsInput, agent: {
+        bot: string;
+        model?: string;
+    }): Promise<MailFindingsBatch>;
+    get(id: string): Promise<MailFindingsBatch>;
+    list(options?: {
+        account?: AccountKey;
+        status?: "proposed" | "reviewed";
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: MailFindingsBatch[];
+        hasMore: boolean;
+    }>;
+    review(id: string, input: {
+        fingerprint: string;
+        accept: string[];
+        by: Decider;
+    }): Promise<MailFindingsBatch>;
+}

package/dist/store/mail-findings.js

@@ -0,0 +1 @@
+export const MAIL_FINDINGS_KIND = "mail_findings";

package/dist/store/path.d.ts

@@ -6,3 +6,5 @@ export declare const wirecatDirectory: (env?: NodeJS.ProcessEnv, platform?: Node
  * before this one: a build still installed would open that name and run its own migrations over these tables.
  */
 export declare const storePath: (env?: NodeJS.ProcessEnv) => string;
+/** Throws when a test is about to open a file in the owner's real WireCat folder. */
+export declare const refuseOwnerStoreInTests: (file: string, env?: NodeJS.ProcessEnv, home?: string | undefined) => void;

package/dist/store/path.js

@@ -1,4 +1,5 @@
-import { join } from "node:path";
+import { userInfo } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { resolvePaths } from "@wirecat/cli-base";
 /** The folder the CLIs share: the store, its backups and the models. `WIRECAT_STATE_DIR` moves all of it. */
 export const wirecatDirectory = (env = process.env, platform) => resolvePaths({ appName: "WireCat", prefix: "WIRECAT", env, ...(platform ? { platform } : {}) }).state;
@@ -8,3 +9,22 @@ export const wirecatDirectory = (env = process.env, platform) => resolvePaths({
  * before this one: a build still installed would open that name and run its own migrations over these tables.
  */
 export const storePath = (env = process.env) => env.MESSAGING_STORE ?? join(wirecatDirectory(env), "wirecat.db");
+// The account's home from the user database, not HOME: the test sandbox moves HOME, and a worker thread's
+// `os.homedir()` still answers the real one (the 2026-10-18 leak).
+const accountHome = () => {
+    try {
+        return userInfo().homedir;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Throws when a test is about to open a file in the owner's real WireCat folder. */
+export const refuseOwnerStoreInTests = (file, env = process.env, home = accountHome()) => {
+    if (!env.VITEST || !home || file === ":memory:")
+        return;
+    const inside = relative(wirecatDirectory({ HOME: home, USERPROFILE: home }), resolve(file));
+    if (inside.startsWith("..") || isAbsolute(inside))
+        return;
+    throw new Error(`a test tried to open ${file}, in the owner's real WireCat folder; give it a MESSAGING_STORE or HOME of its own`);
+};

package/dist/store/sqlite/email-activity.d.ts

@@ -35,6 +35,12 @@ export interface EmailMarks {
     listId: string | null;
     /** The mail rule that decided how it is stored, by its id in `rules list`. */
     ruleId: number | null;
+    /** What a finding citing this email gives as its evidence fingerprint: a hash of its stored subject and text. */
+    fingerprint: string;
+    /** No earlier stored email, in any account, came from this address. */
+    newSender: boolean;
+    /** How many identities the sender's person has; 1 is this address alone. 0 when the sender is unknown. */
+    senderIdentities: number;
 }
 /** One email as a processing mark sees it, by its store id; never its text. */
 export interface MarkedEmail {
@@ -52,6 +58,8 @@ export interface MarkedEmail {
     /** Stored from its first bytes, not whole yet. */
     partial: boolean;
     draft: boolean;
+    /** Its sender's mail looks like spam, a scam or a robot (the sender score). */
+    demoted: boolean;
 }
 export interface MailActivityStore {
     /**

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

@@ -1,3 +1,5 @@
+import { contextEvidenceFingerprint } from "../../context/evidence.js";
+import { formatLocator } from "../../domain/locator.js";
 import { int, str } from "./events.js";
 /** `tasks agenda` fields over `threadActivity`'s threads: an email thread counts as a dialog. */
 export const MAIL_AGENDA_COLUMNS = { chat_kind: { type: "enum", sql: "'dialog'" } };
@@ -50,18 +52,39 @@ export const threadEmailIds = (database, accountId, thread, { after, until } = {
         ORDER BY coalesce(e.sent_at, e.received_at), e.id`)
     .all(accountId, thread, after ?? null, until ?? null)
     .map(({ id }) => Number(id));
+// The subject and text are read only to hash them as `contextRecordOf` does, so a cited fingerprint matches.
 const MARKS = `
   SELECT e.mail_rule_id, coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) AS list_id,
     EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
-      WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk
-  FROM emails e WHERE e.account_id = ? AND e.external_id = ? AND e.deleted_at IS NULL`;
+      WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk,
+    a.provider, a.external_id AS account, t.external_id AS thread, e.subject, coalesce(e.body_text, '') AS body,
+    e.from_identity_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM emails f
+      WHERE f.from_identity_id = e.from_identity_id AND f.id < e.id AND f.deleted_at IS NULL) AS new_sender,
+    (SELECT count(*) FROM identity_links o WHERE o.person_id =
+      (SELECT l.person_id FROM identity_links l WHERE l.identity_id = e.from_identity_id)) AS identities
+  FROM emails e JOIN accounts a ON a.id = e.account_id JOIN email_threads t ON t.id = e.email_thread_id
+  WHERE e.account_id = ? AND e.external_id = ? AND e.deleted_at IS NULL`;
 export const emailMarks = (database, accountId, externalIds) => {
     const one = database.prepare(MARKS);
     const marks = new Map();
     for (const id of externalIds) {
         const row = one.get(accountId, id);
-        if (row)
-            marks.set(id, { bulk: Boolean(row.bulk), listId: str(row.list_id), ruleId: int(row.mail_rule_id) });
+        if (!row)
+            continue;
+        const ref = formatLocator({
+            provider: String(row.provider),
+            account: String(row.account),
+            chat: String(row.thread),
+            message: id,
+        });
+        marks.set(id, {
+            bulk: Boolean(row.bulk),
+            listId: str(row.list_id),
+            ruleId: int(row.mail_rule_id),
+            fingerprint: contextEvidenceFingerprint({ ref, title: str(row.subject), text: String(row.body), revision: null }),
+            newSender: Boolean(row.new_sender),
+            senderIdentities: Number(row.identities ?? 0),
+        });
     }
     return marks;
 };
@@ -72,7 +95,9 @@ const MARKED = `
       OR EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
         WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk,
     EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
-      WHERE m.email_id = e.id AND b.kind = 'envelope') AS envelope
+      WHERE m.email_id = e.id AND b.kind = 'envelope') AS envelope,
+    EXISTS (SELECT 1 FROM account_identities ai WHERE ai.account_id = e.account_id
+      AND ai.identity_id = e.from_identity_id AND ai.mail_demoted = 1) AS demoted
   FROM emails e JOIN email_threads t ON t.id = e.email_thread_id`;
 const markedOf = (row) => ({
     id: Number(row.id),
@@ -85,6 +110,7 @@ const markedOf = (row) => ({
     envelope: Boolean(row.envelope),
     partial: Boolean(row.partial),
     draft: Boolean(row.draft),
+    demoted: Boolean(row.demoted),
 });
 export const emailsAfter = (database, accountId, afterId, limit, ids = []) => {
     const next = database

package/dist/store/sqlite/findings-core.d.ts

@@ -16,4 +16,5 @@ export declare const findingsCoreOver: (context: StoreContext, kind: string) =>
     snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string | null, seen: Map<string, unknown>) => void) => Record<string, string>;
     previous: (account: number | null, fingerprint: string) => FindingOutcome | undefined;
     outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent, decidedBy: Decider) => FindingOutcome[];
+    create: (finding: Finding, agent: FindingsAgent, decidedBy: Decider) => string;
 };

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

@@ -120,5 +120,5 @@ export const findingsCoreOver = (context, kind) => {
             reused: false,
         };
     });
-    return { snapshot, snapshotParts, previous, outcomes };
+    return { snapshot, snapshotParts, previous, outcomes, create };
 };

package/dist/store/sqlite/mail-findings.d.ts

@@ -0,0 +1,3 @@
+import { type MailFindingsStore } from "../mail-findings.js";
+import type { StoreContext } from "./open.js";
+export declare const mailFindingsStoreOver: (context: StoreContext) => MailFindingsStore;

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

@@ -0,0 +1,333 @@
+import { CliError } from "@wirecat/cli-base";
+import { contextEvidenceFingerprint } from "../../context/evidence.js";
+import { parseLocator } from "../../domain/locator.js";
+import { MAIL_FINDINGS_PER_SENDER, mailFindingFingerprint, validateMailFindings, } from "../../mail/findings.js";
+import { findingHash } from "../../meetings/index.js";
+import { assertMayDecide } from "../decisions.js";
+import { MAIL_FINDINGS_KIND } from "../mail-findings.js";
+import { findingsAgent, findingsCoreOver } from "./findings-core.js";
+import { authorActor, memoriesStoreOver } from "./memories.js";
+import { insertLink, requiredThing } from "./notes.js";
+import { linkIdentityToPerson } from "./person-links.js";
+import { proposalOperationsOver } from "./proposed-actions.js";
+import { addComment } from "./task-comments.js";
+import { inboxProject } from "./tasks.js";
+import { taskRowOf } from "./things.js";
+import { write } from "./transaction.js";
+import { workTaskOperationsOver } from "./work-tasks.js";
+const stale = () => {
+    throw new CliError("validation_error", "mail findings cite mail that changed since it was read; stage a new batch", {
+        reason: "mail-findings.stale",
+    });
+};
+const invalid = (message, reason) => {
+    throw new CliError("validation_error", message, reason ? { reason } : undefined);
+};
+const TEXT_BUDGET = 262144;
+const EMAIL = `SELECT e.id, e.account_id, e.subject, coalesce(e.body_text, '') AS body,
+    json_extract(e.metadata, '$.partial') IS NOT NULL AS partial, lower(e.from_address) AS sender,
+    coalesce(e.outgoing, lower(e.from_address) = lower(a.external_id)) AS outgoing
+  FROM emails e JOIN email_threads t ON t.id = e.email_thread_id JOIN accounts a ON a.id = e.account_id
+  WHERE a.provider = 'email' AND a.external_id = ? AND t.external_id = ? AND e.external_id = ? AND e.deleted_at IS NULL`;
+export const mailFindingsStoreOver = (context) => {
+    const { database, now } = context;
+    const proposals = proposalOperationsOver(context);
+    const core = findingsCoreOver(context, MAIL_FINDINGS_KIND);
+    const memories = memoriesStoreOver(context);
+    const tasks = workTaskOperationsOver(context);
+    const mailbox = (key) => {
+        if (key?.provider !== "email" || typeof key.account !== "string" || !key.account.trim())
+            return invalid("mail findings belong to one email account");
+        const row = database
+            .prepare("SELECT id FROM accounts WHERE provider = 'email' AND external_id = ?")
+            .get(key.account);
+        if (!row)
+            throw new CliError("not_found", `no mail of ${key.account} is stored`);
+        return Number(row.id);
+    };
+    const load = (id) => {
+        if (typeof id !== "string" || !/^[1-9]\d*$/.test(id) || !Number.isSafeInteger(Number(id)))
+            return invalid("a findings batch needs a stored ID");
+        const row = database
+            .prepare("SELECT length(CAST(payload AS BLOB)) AS bytes, length(CAST(result AS BLOB)) AS result_bytes FROM proposed_actions WHERE id = ? AND kind = ?")
+            .get(Number(id), MAIL_FINDINGS_KIND);
+        if (!row)
+            throw new CliError("not_found", "the mail findings batch is unavailable");
+        if (Number(row.bytes) > 100000 || Number(row.result_bytes) > 65536)
+            return invalid("stored findings exceed the read budget");
+        return proposals.get(id);
+    };
+    const accountOf = (proposal) => mailbox(proposal.account);
+    const view = (proposal) => {
+        const input = proposal.payload;
+        if (!input || !proposal.account || !["proposed", "approved", "rejected"].includes(proposal.status))
+            return invalid("invalid stored findings batch");
+        return {
+            id: proposal.id,
+            account: proposal.account,
+            input: { schemaVersion: 1, key: input.key, extractor: input.extractor, findings: input.findings },
+            fingerprint: findingHash({ input, author: proposal.proposedBy.id }),
+            status: proposal.status === "proposed" ? "proposed" : "reviewed",
+            author: proposal.proposedBy,
+            decidedBy: proposal.decidedBy,
+            decidedAt: proposal.decidedAt,
+            previous: proposal.result
+                ? proposal.result.items
+                : input.findings.flatMap((finding) => {
+                    const held = core.previous(accountOf(proposal), mailFindingFingerprint(finding));
+                    return held ? [{ ...held, id: finding.id, reused: true }] : [];
+                }),
+            receipt: proposal.result,
+        };
+    };
+    /**
+     * Reads each cited email once: it must be stored, whole, and hash to the fingerprint given. Every finding cites
+     * mail of the batch's own mailbox, and no sender other than the owner is behind more than five findings.
+     */
+    const cite = (findings, account) => {
+        const read = new Map();
+        const perSender = new Map();
+        let bytes = 0;
+        for (const finding of findings) {
+            const senders = new Set();
+            let own = false;
+            for (const { reference, fingerprint } of finding.evidence) {
+                let row = read.get(reference);
+                if (!row) {
+                    const at = parseLocator(reference);
+                    row = database.prepare(EMAIL).get(at.account, at.chat, at.message);
+                    if (!row)
+                        return stale();
+                    bytes += Buffer.byteLength(String(row.body)) + Buffer.byteLength(String(row.subject ?? ""));
+                    if (bytes > TEXT_BUDGET)
+                        return invalid(`finding evidence exceeds the ${TEXT_BUDGET}-byte stored text budget`);
+                    if (row.partial)
+                        return invalid(`${reference} is not stored whole yet; cite it once it is`, "mail-findings.partial");
+                    const title = row.subject == null ? null : String(row.subject);
+                    row.fingerprint = contextEvidenceFingerprint({
+                        ref: reference,
+                        title,
+                        text: String(row.body),
+                        revision: null,
+                    });
+                    read.set(reference, row);
+                }
+                if (row.fingerprint !== fingerprint)
+                    return stale();
+                if (Number(row.account_id) === account)
+                    own = true;
+                if (!row.outgoing && row.sender != null)
+                    senders.add(String(row.sender));
+            }
+            if (!own)
+                return invalid(`finding ${finding.id} cites no email of this mailbox`);
+            for (const sender of senders) {
+                const count = (perSender.get(sender) ?? 0) + 1;
+                if (count > MAIL_FINDINGS_PER_SENDER)
+                    return invalid(`more than ${MAIL_FINDINGS_PER_SENDER} findings from ${sender} in one batch`);
+                perSender.set(sender, count);
+            }
+        }
+        return read;
+    };
+    const identityOfAddress = (address) => database
+        .prepare("SELECT i.id, l.person_id FROM identities i LEFT JOIN identity_links l ON l.identity_id = i.id " +
+        "WHERE i.provider = 'email' AND lower(i.external_id) = ?")
+        .get(address.toLowerCase());
+    /** Whatever a finding names must be stored: a task to update, a subject, a link's ends, a contact's address. */
+    const targets = (finding, read) => {
+        const thing = (reference, what) => {
+            if (reference !== undefined)
+                requiredThing(database, reference, what);
+        };
+        switch (finding.kind) {
+            case "task":
+                thing(finding.project, "the project");
+                thing(finding.assignee, "the assignee");
+                return;
+            case "fact":
+            case "memory":
+                thing(finding.subject, "the subject");
+                thing(finding.project, "the project");
+                return;
+            case "task_update":
+                if (taskRowOf(database, finding.task.slice("task:".length)) === undefined)
+                    throw new CliError("not_found", `no task ${finding.task}`);
+                return;
+            case "link":
+                thing(finding.from, "the link's source");
+                thing(finding.to, "the link's target");
+                return;
+            case "new_contact": {
+                const ids = finding.evidence.map(({ reference }) => Number(read.get(reference)?.id));
+                const marks = ids.map(() => "?").join(",");
+                const named = database
+                    .prepare(`SELECT 1 FROM emails WHERE id IN (${marks}) AND lower(from_address) = ? UNION ALL ` +
+                    `SELECT 1 FROM email_recipients WHERE email_id IN (${marks}) AND lower(address) = ? LIMIT 1`)
+                    .get(...ids, finding.address, ...ids, finding.address);
+                if (!named)
+                    return invalid(`${finding.address} neither sent nor received the mail finding ${finding.id} cites`);
+                if (!identityOfAddress(finding.address))
+                    throw new CliError("not_found", `no stored contact ${finding.address}`);
+                return;
+            }
+        }
+    };
+    /** What accepting one finding makes, inside the decision's write; returns the reference of what it made. */
+    const create = (finding, account, agent) => {
+        const evidence = finding.evidence.map((one) => one.reference);
+        switch (finding.kind) {
+            case "fact":
+                return core.create(finding, agent, "owner");
+            case "task": {
+                const project = finding.project ?? `project:${inboxProject(context, `email:${account.account}`, true)}`;
+                return core.create({ ...finding, project }, agent, "owner");
+            }
+            case "task_update": {
+                if (finding.change === "close")
+                    tasks.editNow(finding.task, { status: "done", reason: finding.reason }, "owner");
+                else if (finding.change === "due")
+                    tasks.editNow(finding.task, { dueAt: new Date(finding.dueAt) }, "owner");
+                else {
+                    const row = taskRowOf(database, finding.task.slice("task:".length));
+                    addComment(context, row, `${finding.detail}\n\n${evidence.join("\n")}`, agent);
+                }
+                return finding.task;
+            }
+            case "memory": {
+                const made = memories.addNow({
+                    kind: finding.memoryKind,
+                    body: finding.body,
+                    scope: finding.scope,
+                    evidence,
+                    author: agent,
+                    ...(finding.subject === undefined ? {} : { subject: finding.subject }),
+                    ...(finding.project === undefined ? {} : { project: finding.project }),
+                });
+                return memories.confirmNow(made.ref, "owner").ref;
+            }
+            case "link": {
+                if (finding.from.startsWith("contact:")) {
+                    const identity = requiredThing(database, finding.from, "the contact");
+                    const person = requiredThing(database, finding.to, "the person");
+                    linkIdentityToPerson(context, identity.id, person.id, { method: "mail-finding", by: "owner" });
+                    return finding.to;
+                }
+                const link = insertLink(context, {
+                    from: finding.from,
+                    to: finding.to,
+                    kind: "member-of",
+                    origin: "owner",
+                    evidence: evidence[0],
+                    provenance: `${agent.bot}: ${finding.reason}`,
+                });
+                if (!link.confirmed)
+                    database.prepare("UPDATE links SET confirmed = 1, updated_at = ? WHERE id = ?").run(now(), Number(link.id));
+                return `link:${link.id}`;
+            }
+            case "new_contact": {
+                const person = Number(identityOfAddress(finding.address)?.person_id);
+                database
+                    .prepare("UPDATE persons SET name = ?, updated_at = ? WHERE id = ? AND name IS NULL")
+                    .run(finding.name, now(), person);
+                return `person:${person}`;
+            }
+        }
+    };
+    return {
+        stage: async (key, raw, rawAgent) => {
+            const input = validateMailFindings(raw);
+            const by = findingsAgent(rawAgent);
+            return write(database, () => {
+                const account = mailbox(key);
+                const { actor } = authorActor(context, by);
+                const inputHash = findingHash({ input, model: by.model ?? null });
+                const held = database
+                    .prepare("SELECT id FROM proposed_actions WHERE account_id = ? AND kind = ? AND proposed_by_type = ? AND proposed_by_id = ? AND json_extract(payload, '$.key') = ? ORDER BY id LIMIT 1")
+                    .get(account, MAIL_FINDINGS_KIND, actor.type, actor.id, input.key);
+                if (held) {
+                    const proposal = load(String(held.id));
+                    if (proposal.payload.inputHash !== inputHash)
+                        return invalid("the findings batch key was already used for different input");
+                    return view(proposal);
+                }
+                const read = cite(input.findings, account);
+                for (const finding of input.findings)
+                    targets(finding, read);
+                const fingerprints = input.findings.map(mailFindingFingerprint);
+                if (new Set(fingerprints).size !== fingerprints.length)
+                    return invalid("the batch contains duplicate findings");
+                return view(proposals.propose({
+                    kind: MAIL_FINDINGS_KIND,
+                    by,
+                    account: { provider: "email", account: key.account },
+                    payload: { ...input, inputHash, agentModel: by.model ?? null },
+                }));
+            });
+        },
+        get: async (id) => view(load(id)),
+        list: async ({ account, status, limit = 20, offset = 0 } = {}) => {
+            if (status !== undefined && status !== "proposed" && status !== "reviewed")
+                return invalid("finding status is proposed or reviewed");
+            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50 || !Number.isSafeInteger(offset) || offset < 0)
+                return invalid("findings lists take 1–50 items and a nonnegative offset");
+            const id = account === undefined ? null : mailbox(account);
+            const rows = database
+                .prepare("SELECT id FROM proposed_actions WHERE kind = ? AND (? IS NULL OR account_id = ?) AND (? IS NULL OR status = ?) " +
+                "ORDER BY id DESC LIMIT ? OFFSET ?")
+                .all(MAIL_FINDINGS_KIND, id, id, status ?? null, status === "reviewed" ? "approved" : (status ?? null), limit + 1, offset);
+            return { items: rows.slice(0, limit).map((row) => view(load(String(row.id)))), hasMore: rows.length > limit };
+        },
+        review: async (id, decision) => write(database, () => {
+            const proposal = load(id);
+            const batch = view(proposal);
+            if (!decision || typeof decision.fingerprint !== "string" || decision.fingerprint !== batch.fingerprint)
+                return stale();
+            if (!Array.isArray(decision.accept) ||
+                decision.accept.length > batch.input.findings.length ||
+                new Set(decision.accept).size !== decision.accept.length ||
+                decision.accept.some((candidate) => !batch.input.findings.some((finding) => finding.id === candidate)))
+                return invalid("accept only unique IDs shown in this batch");
+            if (decision.by === undefined)
+                return invalid("a findings review names who decides: the owner");
+            assertMayDecide({ id, proposedBy: proposals.proposer(id), ownerOnly: true }, decision.by, context.decisions);
+            const accepted = [...decision.accept].sort();
+            if (batch.receipt) {
+                if (JSON.stringify(batch.receipt.accepted) !== JSON.stringify(accepted))
+                    return invalid("this findings batch was already reviewed with a different decision");
+                return batch;
+            }
+            const input = proposal.payload;
+            const account = accountOf(proposal);
+            // Rejecting creates nothing, so a batch whose mail changed can still be closed; accepting needs the
+            // accepted findings' own mail unchanged.
+            const chosen = batch.input.findings.filter((finding) => accepted.includes(finding.id));
+            if (chosen.length)
+                cite(chosen, account);
+            if (proposal.proposedBy.type !== "bot" || !proposal.proposedBy.name)
+                return invalid("a findings author must be an agent");
+            const agent = {
+                bot: proposal.proposedBy.name,
+                ...(input.agentModel === null ? {} : { model: input.agentModel }),
+            };
+            const items = batch.input.findings.map((finding) => {
+                const fingerprint = mailFindingFingerprint(finding);
+                const prior = core.previous(account, fingerprint);
+                if (prior) {
+                    if (accepted.includes(finding.id) && prior.status === "rejected")
+                        return invalid("this unchanged finding was already rejected; changed evidence needs a new candidate");
+                    return { ...prior, id: finding.id, reused: true };
+                }
+                const status = accepted.includes(finding.id) ? "accepted" : "rejected";
+                return {
+                    id: finding.id,
+                    fingerprint,
+                    status,
+                    reference: status === "accepted" ? create(finding, batch.account, agent) : null,
+                    reused: false,
+                };
+            });
+            return view(proposals.approve(id, { previewFingerprint: batch.fingerprint, accepted, items }, "owner"));
+        }),
+    };
+};

package/dist/store/sqlite/manifest.js

@@ -63,6 +63,7 @@ export const MANIFEST = [
     { name: "20261102173113_version-45-finance-rules", version: 45, minCompatible: 34 },
     { name: "20261102185954_version-46-payment-facts", version: 46, minCompatible: 34 },
     { name: "20261102192959_version-47-records", version: 47, minCompatible: 34 },
+    { name: "20261102222340_version-48-test-accounts", version: 48, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

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

@@ -141,5 +141,8 @@ export declare const dropLinksOf: (database: StoreContext["database"], thing: {
  * segment still holds the erased words, and the write-ahead log emptied when no reader holds it.
  */
 export declare const erase: <T>(database: StoreContext["database"], work: () => T) => T;
-export declare const memoriesStoreOver: (context: StoreContext) => MemoriesStore;
+export declare const memoriesStoreOver: (context: StoreContext) => MemoriesStore & {
+    addNow(input: MemoryInput): Memory;
+    confirmNow(reference: string, by: Decider): Memory;
+};
 export {};