@wirecat/cli-core 0.558.0 → 0.560.0

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/proposals/kinds/mail-findings.d.ts

@@ -0,0 +1,8 @@
+import { type MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/**
+ * What an agent read in new mail, one batch per mailbox and run. Only the owner decides it (NEED-2187): an agent's
+ * confirmation is refused whatever `agent_decisions` says. Confirming accepts the parts named, or every finding not
+ * rejected before; the rest are rejected.
+ */
+export declare const mailFindingsKind: (store: Pick<MessageStore, "mailFindings" | "proposedActions">) => ProposalKind;

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

@@ -0,0 +1,87 @@
+import { MAIL_FINDINGS_KIND } from "../../../store/index.js";
+import { kept, proposerOfAuthor } from "./shared.js";
+/** A finding's one line in the inbox; never the email's text, only what the agent wrote. */
+const summaryOf = (finding) => {
+    switch (finding.kind) {
+        case "task":
+            return finding.title;
+        case "fact":
+            return finding.statement;
+        case "task_update":
+            return `${finding.change} ${finding.task}: ${finding.reason}`;
+        case "memory":
+            return finding.body.slice(0, 200);
+        case "link":
+            return `${finding.from} → ${finding.to}`;
+        case "new_contact":
+            return `${finding.name} <${finding.address}>`;
+    }
+};
+const rowOf = (batch, createdAt) => {
+    const findings = batch.input.findings;
+    const outcome = (id) => batch.receipt?.items.find((item) => item.id === id)?.status ?? null;
+    const project = findings.flatMap((finding) => ("project" in finding && finding.project ? [finding.project] : []))[0] ?? null;
+    return {
+        id: batch.id,
+        kind: "mail_findings",
+        status: batch.status === "proposed" ? "proposed" : batch.receipt?.accepted.length ? "confirmed" : "rejected",
+        project,
+        subject: `findings:${batch.id}`,
+        object: null,
+        summary: `${findings.length} mail finding${findings.length === 1 ? "" : "s"} for ${batch.account.account}`,
+        proposedBy: proposerOfAuthor(batch.author),
+        reason: null,
+        evidence: [...new Set(findings.flatMap((finding) => finding.evidence.map((one) => one.reference)))].slice(0, 5),
+        score: null,
+        signals: null,
+        parts: findings.map((finding) => ({
+            id: finding.id,
+            kind: finding.kind,
+            summary: summaryOf(finding),
+            outcome: outcome(finding.id),
+        })),
+        createdAt,
+    };
+};
+/**
+ * What an agent read in new mail, one batch per mailbox and run. Only the owner decides it (NEED-2187): an agent's
+ * confirmation is refused whatever `agent_decisions` says. Confirming accepts the parts named, or every finding not
+ * rejected before; the rest are rejected.
+ */
+export const mailFindingsKind = (store) => {
+    const created = async (batch) => rowOf(batch, (await store.proposedActions.get(batch.id)).createdAt);
+    return {
+        kind: "mail_findings",
+        stored: [MAIL_FINDINGS_KIND],
+        parts: true,
+        ownerOnly: true,
+        list: async (filter) => {
+            const status = filter.status ?? "proposed";
+            const rows = [];
+            for (let offset = 0; rows.length < filter.limit; offset += 50) {
+                const page = await store.mailFindings.list({
+                    ...(status === "proposed" ? { status: "proposed" } : {}),
+                    ...(status === "confirmed" || status === "rejected" ? { status: "reviewed" } : {}),
+                    limit: 50,
+                    offset,
+                });
+                for (const row of kept(await Promise.all(page.items.map(created)), { ...filter, limit: 50 }))
+                    rows.push(row);
+                if (!page.hasMore)
+                    break;
+            }
+            return kept(rows, filter);
+        },
+        get: async (id) => created(await store.mailFindings.get(id)),
+        decide: async (id, { confirm, by, parts }) => {
+            const batch = await store.mailFindings.get(id);
+            const turnedDown = new Set(batch.previous.filter((one) => one.status === "rejected").map((one) => one.id));
+            const accept = !confirm
+                ? []
+                : (parts ?? batch.input.findings.map((finding) => finding.id).filter((one) => !turnedDown.has(one)));
+            const reviewed = await store.mailFindings.review(id, { fingerprint: batch.fingerprint, accept, by });
+            const made = (reviewed.receipt?.items ?? []).flatMap((item) => item.status === "accepted" && item.reference && !item.reused ? [item.reference] : []);
+            return { id, kind: "mail_findings", status: accept.length ? "confirmed" : "rejected", made };
+        },
+    };
+};

package/dist/services/proposals/registry.js

@@ -5,6 +5,7 @@ import { factKind } from "./kinds/fact.js";
 import { invoiceKind, paymentKind } from "./kinds/finance.js";
 import { findingsKind } from "./kinds/findings.js";
 import { keyDocumentKind } from "./kinds/key-document.js";
+import { mailFindingsKind } from "./kinds/mail-findings.js";
 import { memoryKind } from "./kinds/memory.js";
 import { relationshipKind } from "./kinds/relationship.js";
 import { relationshipUpdateKind } from "./kinds/relationship-update.js";
@@ -98,7 +99,7 @@ export const emptyProposalRegistry = (store) => {
                         });
                         continue;
                     }
-                    const refusal = mayDecide(row, decision.by, policy);
+                    const refusal = mayDecide(kind.ownerOnly ? { ...row, ownerOnly: true } : row, decision.by, policy);
                     if (refusal) {
                         refused.push(refusal);
                         continue;
@@ -127,6 +128,7 @@ export const proposalRegistry = (store) => {
         paymentKind(store),
         memoryKind(store),
         findingsKind(store),
+        mailFindingsKind(store),
     ])
         registry.register(kind);
     registry.register(actionKind(store, registry.claimed));

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";
@@ -54,6 +55,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/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/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/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;