@wirecat/cli-core 0.546.0 → 0.548.0

package/dist/store/sqlite/accounts.js

@@ -132,7 +132,7 @@ const referencesTo = (database, table, skip) => {
     const pointers = pointerPairs(database).map(({ table: tbl, pointer }) => `SELECT ${pointer}_id AS id FROM "${tbl}" WHERE ${pointer}_type = '${type}'`);
     return [...keys, ...pointers].join(" UNION ");
 };
-const unreferenced = (database, table) => new Set(database
+export const unreferenced = (database, table) => new Set(database
     .prepare(`SELECT id FROM ${table} WHERE id NOT IN (SELECT id FROM (${referencesTo(database, table, OWN)}) WHERE id IS NOT NULL)`)
     .all()
     .map(({ id }) => Number(id)));
@@ -141,7 +141,7 @@ const unreferenced = (database, table) => new Set(database
  * (another account, a tag, a note, a link), or while its person is kept: the owner, a person something
  * points at, or one linked to an identity that stays.
  */
-const dropOrphanPeople = (database, unseenBefore) => {
+export const dropOrphanPeople = (database, unseenBefore) => {
     const orphans = [...unreferenced(database, "identities")].filter((id) => !unseenBefore.has(id));
     if (orphans.length === 0)
         return;

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

@@ -1,3 +1,4 @@
+import type { Proposer } from "../decisions.js";
 import type { CacheDatabase } from "../driver.js";
 /** Who made or owns something: the store's polymorphic actor pair. */
 export interface Actor {
@@ -6,7 +7,7 @@ export interface Actor {
 }
 /** How the task package names who acted; each maps to one stable actor row. */
 export type Origin = "owner" | "agent" | "rule";
-declare const BOT_KINDS: readonly ["agent", "script", "integration"];
+export declare const BOT_KINDS: readonly ["agent", "rule", "script", "integration"];
 /** The owner's person row, which the initial migration seeds. */
 export declare const ownerPerson: (database: CacheDatabase) => Actor;
 /** A bot by its unique handle, registered on first use. */
@@ -17,4 +18,14 @@ export declare const botNamed: (database: CacheDatabase, name: string, now: numb
  */
 export declare const actorOfOrigin: (database: CacheDatabase, origin: Origin) => Actor;
 export declare const originOfActor: (database: CacheDatabase, type: unknown, id: unknown) => Origin | undefined;
-export {};
+/** Who proposed a stored row, from its actor pair; the seeded bot `rule` and a bot of kind `rule` are rules. */
+export declare const proposerOf: (database: CacheDatabase, type: unknown, id: unknown) => Proposer;
+/** Who proposed something, as a list filter: any agent, any rule, or one bot by its handle. */
+export type ProposedByFilter = "agent" | "rule" | {
+    bot: string;
+};
+/** The SQL that keeps rows whose actor pair matches `by`; the seeded bot `rule` counts as a rule. */
+export declare const proposedBySql: (type: string, id: string, by: ProposedByFilter | undefined) => {
+    sql: string;
+    params: string[];
+};

package/dist/store/sqlite/actors.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-const BOT_KINDS = ["agent", "script", "integration"];
+export const BOT_KINDS = ["agent", "rule", "script", "integration"];
 /** The owner's person row, which the initial migration seeds. */
 export const ownerPerson = (database) => {
     const found = database.prepare("SELECT id FROM persons WHERE owner = 1 ORDER BY id LIMIT 1").get();
@@ -41,3 +41,26 @@ export const originOfActor = (database, type, id) => {
         return "owner";
     return database.prepare("SELECT name FROM bots WHERE id = ?").get(Number(id))?.name === "rule" ? "rule" : "agent";
 };
+/** Who proposed a stored row, from its actor pair; the seeded bot `rule` and a bot of kind `rule` are rules. */
+export const proposerOf = (database, type, id) => {
+    if (type === "person" && id != null)
+        return { type: "person", id: String(id) };
+    if (type !== "bot" || id == null)
+        return { type: "unknown" };
+    const bot = database.prepare("SELECT name, kind FROM bots WHERE id = ?").get(Number(id));
+    if (!bot)
+        return { type: "unknown" };
+    const name = String(bot.name);
+    return { type: "bot", id: String(id), name, kind: bot.kind === "rule" || name === "rule" ? "rule" : "agent" };
+};
+/** The SQL that keeps rows whose actor pair matches `by`; the seeded bot `rule` counts as a rule. */
+export const proposedBySql = (type, id, by) => {
+    if (by === undefined)
+        return { sql: "1", params: [] };
+    const bot = (condition) => `${type} = 'bot' AND EXISTS (SELECT 1 FROM bots pb WHERE pb.id = ${id} AND ${condition})`;
+    if (by === "rule")
+        return { sql: bot("(pb.kind = 'rule' OR pb.name = 'rule')"), params: [] };
+    if (by === "agent")
+        return { sql: bot("pb.kind <> 'rule' AND pb.name <> 'rule'"), params: [] };
+    return { sql: bot("pb.name = ?"), params: [by.bot] };
+};

package/dist/store/sqlite/calendar-forget.d.ts

@@ -0,0 +1,17 @@
+import type { CacheDatabase } from "../driver.js";
+/**
+ * `EventStore.forgetCalendar` inside its transaction: children before parents, since the foreign keys are enforced.
+ * `refresh` gives a kept event or series its fields again from the copies left.
+ */
+export declare const forgetCalendarRows: (database: CacheDatabase, { calendarId, accountId, cursorKey, now }: {
+    calendarId: number;
+    accountId: number;
+    cursorKey: string;
+    now: number;
+}, refresh: {
+    event: (id: number, now: number) => void;
+    series: (id: number, now: number) => void;
+}) => {
+    entries: number;
+    events: number;
+};

package/dist/store/sqlite/calendar-forget.js

@@ -0,0 +1,68 @@
+import { dropOrphanPeople, unreferenced } from "./accounts.js";
+import { dropUnusedVectors } from "./vector-index.js";
+const distinctIds = (rows) => [...new Set(rows.map((row) => Number(row.id)))];
+/**
+ * `EventStore.forgetCalendar` inside its transaction: children before parents, since the foreign keys are enforced.
+ * `refresh` gives a kept event or series its fields again from the copies left.
+ */
+export const forgetCalendarRows = (database, { calendarId, accountId, cursorKey, now }, refresh) => {
+    const unseenBefore = unreferenced(database, "identities");
+    const ids = (sql) => distinctIds(database.prepare(sql).all(calendarId));
+    const entryIds = ids("SELECT id FROM calendar_entries WHERE calendar_id = ?");
+    const eventIds = ids("SELECT event_id AS id FROM calendar_entries WHERE calendar_id = ? AND event_id IS NOT NULL");
+    const seriesIds = ids("SELECT event_series_id AS id FROM calendar_entries WHERE calendar_id = ? AND event_series_id IS NOT NULL");
+    const hashes = [];
+    const dropAround = (type, list) => {
+        const json = JSON.stringify(list);
+        const inList = "IN (SELECT value FROM json_each(?))";
+        for (const row of database
+            .prepare(`SELECT DISTINCT content_hash FROM chunks WHERE chunkable_type = ? AND chunkable_id ${inList}`)
+            .all(type, json))
+            hashes.push(String(row.content_hash));
+        database.prepare(`DELETE FROM chunks WHERE chunkable_type = ? AND chunkable_id ${inList}`).run(type, json);
+        database
+            .prepare(`DELETE FROM links WHERE (from_type = ? AND from_id ${inList}) OR (to_type = ? AND to_id ${inList})`)
+            .run(type, json, type, json);
+        for (const [table, pointer] of [
+            ["taggings", "taggable"],
+            ["aliases", "aliasable"],
+            ["attachments", "attachable"],
+            ["link_reviews", "linkable"],
+            ["entity_link_events", "linkable"],
+        ])
+            database.prepare(`DELETE FROM ${table} WHERE ${pointer}_type = ? AND ${pointer}_id ${inList}`).run(type, json);
+    };
+    const entries = JSON.stringify(entryIds);
+    for (const table of ["calendar_entry_participants", "calendar_entry_revisions"])
+        database.prepare(`DELETE FROM ${table} WHERE entry_id IN (SELECT value FROM json_each(?))`).run(entries);
+    dropAround("calendar_entry", entryIds);
+    // Occurrences point at their series in the same table: the pointers go first, so the order of rows is free.
+    database.prepare("UPDATE calendar_entries SET series_entry_id = NULL WHERE calendar_id = ?").run(calendarId);
+    database.prepare("DELETE FROM calendar_entries WHERE calendar_id = ?").run(calendarId);
+    const held = (column, id) => database.prepare(`SELECT 1 FROM calendar_entries WHERE ${column} = ? LIMIT 1`).get(id) !== undefined;
+    const goneSeries = seriesIds.filter((id) => !held("event_series_id", id));
+    const goneEvents = eventIds.filter((id) => !held("event_id", id));
+    const gone = (list) => JSON.stringify(list);
+    database
+        .prepare("UPDATE meetings SET event_id = NULL, updated_at = ? WHERE event_id IN (SELECT value FROM json_each(?))")
+        .run(now, gone(goneEvents));
+    dropAround("event", goneEvents);
+    database.prepare("DELETE FROM events WHERE id IN (SELECT value FROM json_each(?))").run(gone(goneEvents));
+    for (const table of ["meeting_series", "events"])
+        database
+            .prepare(`UPDATE ${table} SET event_series_id = NULL, updated_at = ? WHERE event_series_id IN (SELECT value FROM json_each(?))`)
+            .run(now, gone(goneSeries));
+    dropAround("event_series", goneSeries);
+    database.prepare("DELETE FROM event_series WHERE id IN (SELECT value FROM json_each(?))").run(gone(goneSeries));
+    for (const id of seriesIds)
+        if (!goneSeries.includes(id))
+            refresh.series(id, now);
+    for (const id of eventIds)
+        if (!goneEvents.includes(id))
+            refresh.event(id, now);
+    database.prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?").run(accountId, cursorKey);
+    database.prepare("DELETE FROM calendars WHERE id = ?").run(calendarId);
+    dropOrphanPeople(database, unseenBefore);
+    dropUnusedVectors(database, hashes);
+    return { entries: entryIds.length, events: goneEvents.length };
+};

package/dist/store/sqlite/calendar.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { calendarText, entryInWindow, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
 import { listEvents } from "./calendar-events.js";
+import { forgetCalendarRows } from "./calendar-forget.js";
 import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
 import { driveDocumentOf, driveFileTarget, logFileLink } from "./files.js";
 import { identityOf } from "./identities.js";
@@ -524,6 +525,13 @@ export const eventStoreOver = (context) => {
                 .prepare("UPDATE calendars SET synced = ?, updated_at = ? WHERE id = ?")
                 .run(flag(synced), now, calendarId);
         }),
+        forgetCalendar: async (calendarId, now) => write(database, () => {
+            const accountId = Number(calendarRow(calendarId).account_id);
+            return forgetCalendarRows(database, { calendarId, accountId, cursorKey: cursorKey(calendarId), now }, {
+                event: refreshEvent,
+                series: refreshSeries,
+            });
+        }),
         saveEntries: async (calendarId, entries, now) => write(database, () => saveAll(calendarId, entries, now)),
         removeEntries: async (calendarId, externalIds, now) => write(database, () => removeAll(calendarId, externalIds, now)),
         markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => {

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

@@ -1,3 +1,4 @@
+import type { Metadata } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 /** Where an IMAP server holds an email: `folder` is the mailbox's external id. */
 export interface EmailLocationInput {
@@ -20,5 +21,20 @@ export declare const locate: (database: CacheDatabase, accountId: number, emailI
     changes: number;
 };
 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.
+ */
+export interface PartialEmail {
+    externalId: string;
+    threadExternalId: string;
+    receivedAt: number | null;
+    metadata: Metadata;
+    locations: EmailLocationInput[];
+}
+export declare const partialEmails: (database: CacheDatabase, accountId: number, limit: number) => {
+    emails: PartialEmail[];
+    total: number;
+};
 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,3 +1,4 @@
+import { fromJson } from "./events.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 = ?`)
@@ -21,6 +22,31 @@ export const folderEmails = (database, accountId, folder, uidvalidity) => databa
     locations: Number(row.locations),
     folders: Number(row.folders),
 }));
+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
+       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
+       ORDER BY at DESC, e.id DESC LIMIT ?`)
+        .all(accountId, limit);
+    return {
+        total: rows.length ? Number(rows[0]?.total) : 0,
+        emails: rows.map((row) => ({
+            externalId: String(row.external_id),
+            threadExternalId: String(row.thread),
+            receivedAt: row.at === null ? null : Number(row.at),
+            metadata: fromJson(row.metadata),
+            locations: JSON.parse(String(row.places)).map((place) => ({
+                folder: String(place.folder),
+                uidvalidity: String(place.uidvalidity),
+                uid: Number(place.uid),
+            })),
+        })),
+    };
+};
 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 } from "./email-locations.js";
+import { type EmailLocationInput, type FolderEmail, type PartialEmail } 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 };
+export type { EmailLocationInput, FolderEmail, PartialEmail };
 export interface EmailAddress {
     address: string;
     name: string | null;
@@ -217,6 +217,10 @@ 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, setLocations, } from "./email-locations.js";
+import { folderEmails, forgetLocations, locate, partialEmails, setLocations, } 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";
@@ -469,6 +469,7 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             mailboxes: JSON.parse(String(row.boxes)),
         }));
     },
+    partialEmails: async (accountId, limit) => partialEmails(database, accountId, limit),
     async emailFacts(filter = {}) {
         const [where, params] = emailWhere(filter);
         return database

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

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { contextEvidenceFingerprint } from "../../context/evidence.js";
 import { findingFingerprint, findingHash } from "../../meetings/index.js";
+import { assertMayDecide } from "../decisions.js";
 import { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "../evidence-findings.js";
 import { contextRecordOf } from "./context-evidence.js";
 import { sourcesOfReferences } from "./evidence-sources.js";
@@ -80,8 +81,10 @@ export const evidenceFindingsStoreOver = (context) => {
     };
     const snapshot = (input) => core.snapshot(input, cite());
     const decider = (by) => {
-        if (by === undefined || by === "owner")
+        if (by === "owner")
             return { author: "owner", decision: { by: "owner" } };
+        if (by === undefined)
+            return invalid("a findings review names who decides: the owner or an agent with a reason");
         const raw = by;
         const agent = findingsAgent({
             bot: raw.bot,
@@ -157,7 +160,14 @@ export const evidenceFindingsStoreOver = (context) => {
                 decision.accept.some((candidate) => !batch.input.findings.some((finding) => finding.id === candidate)))
                 return invalid("accept only unique IDs shown in this batch");
             const accepted = [...decision.accept].sort();
-            const { author, decision: decidedBy } = decider(decision.by);
+            const { author, decision: checked } = decider(decision.by);
+            const reason = typeof decision.reason === "string" ? decision.reason.trim().slice(0, 2000) : "";
+            const decidedBy = reason && checked.by === "owner"
+                ? { ...checked, reason }
+                : reason && checked.by === "agent"
+                    ? { ...checked, reason: `${checked.reason}: ${reason}` }
+                    : checked;
+            assertMayDecide({ id, proposedBy: proposals.proposer(id) }, 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");
@@ -187,7 +197,7 @@ export const evidenceFindingsStoreOver = (context) => {
                 bot: proposal.proposedBy.name,
                 ...(input.agentModel === null ? {} : { model: input.agentModel }),
             };
-            const items = core.outcomes(null, batch.input, accepted, agent);
+            const items = core.outcomes(null, batch.input, accepted, agent, decision.by);
             return view(proposals.approve(id, {
                 previewFingerprint: batch.fingerprint,
                 accepted,

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

@@ -1,5 +1,6 @@
 import { type FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
-import type { Actor } from "./actors.js";
+import { type Decider } from "../decisions.js";
+import { type Actor, type ProposedByFilter } from "./actors.js";
 import { type EvidenceSource } from "./evidence-sources.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
@@ -18,11 +19,12 @@ export interface Fact {
     subjectIsOwner: boolean;
     occurredAt: string | null;
     supersedes: string | null;
-    /** `name` is a bot's handle; `null` for a person. */
+    /** `name` is a bot's handle and `kind` whether it is an agent or a rule; both `null` for a person. */
     author: {
         type: Actor["type"];
         id: string;
         name: string | null;
+        kind: "agent" | "rule" | null;
     };
     model: string | null;
     confirmedBy: {
@@ -59,19 +61,22 @@ export interface FactsStore {
         project?: string;
         subject?: string;
         status?: Fact["status"];
+        proposedBy?: ProposedByFilter;
+        /** `created` lists the newest written first; by default the newest by when it happened. */
+        order?: "occurred" | "created";
         limit?: number;
     }): Promise<Fact[]>;
-    /** The owner accepts a proposed fact; the fact it supersedes stops holding. */
-    accept(reference: string): Promise<Fact>;
+    /** The owner, or an agent for the owner, accepts a proposed fact; the fact it supersedes stops holding. */
+    accept(reference: string, by: Decider, reason?: string): Promise<Fact>;
     /** An accepted decision no longer holds and nothing replaced it. */
-    reverse(reference: string): Promise<Fact>;
-    /** The owner turns down a proposed fact; it stays, marked `rejected`. */
-    reject(reference: string): Promise<Fact>;
+    reverse(reference: string, by: Decider): Promise<Fact>;
+    /** The owner, or an agent for the owner, turns down a proposed fact; it stays, marked `rejected`. */
+    reject(reference: string, by: Decider, reason?: string): Promise<Fact>;
     /**
      * Erases the fact: its row, its links, its tags, and the memory it was migrated from, which still held its text.
      * A decision that replaced it no longer names it. A backup made before keeps it.
      */
-    remove(reference: string): Promise<{
+    remove(reference: string, by: Decider): Promise<{
         ref: string;
         removed: true;
         links: number;
@@ -81,6 +86,9 @@ export interface FactsStore {
 }
 type FactOperations = {
     [K in keyof FactsStore]: FactsStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
+} & {
+    /** Accepts as part of a decision already checked, such as a reviewed findings batch. */
+    acceptChecked(reference: string, by: Decider): Fact;
 };
 export declare const factOperationsOver: (context: StoreContext) => FactOperations;
 export declare const factsStoreOver: (context: StoreContext) => FactsStore;

package/dist/store/sqlite/facts.js

@@ -1,12 +1,14 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { assertMayDecide, assertMayWithdraw, deciderAuthor } from "../decisions.js";
+import { proposedBySql, proposerOf } from "./actors.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
 import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, keepHighestId, linkEvidence, nextId, projectOf, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.js";
 import { write } from "./transaction.js";
-const NAMED = "SELECT f.*, b.name AS author_name FROM facts f LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id";
+const NAMED = "SELECT f.*, b.name AS author_name, b.kind AS author_kind FROM facts f LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id";
 const iso = (value) => new Date(Number(value)).toISOString();
 const oneOf = (value, allowed, what) => {
     if (typeof value !== "string" || !allowed.includes(value))
@@ -42,15 +44,32 @@ export const factOperationsOver = (context) => {
             throw new CliError("validation_error", `${reference} is not a fact`);
         return database.prepare(`${NAMED} WHERE f.id = ?`).get(thing.id);
     };
-    const accept = (id) => {
+    const withdrawn = (row, by) => assertMayWithdraw({
+        id: `fact:${row.id}`,
+        proposedBy: proposerOf(database, row.author_type, row.author_id),
+        proposed: row.status === "proposed",
+    }, by);
+    const decided = (row, by) => assertMayDecide({ id: `fact:${row.id}`, proposedBy: proposerOf(database, row.author_type, row.author_id) }, by, context.decisions);
+    /** Keeps who decided for the owner and why in `metadata.decision`; the decider's actor is in `confirmed_by`. */
+    const keepDecision = (id, by, reason) => {
+        const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
+        if (by === "owner" && !why)
+            return;
+        const decision = by === "owner" ? { by: "owner", reason: why } : { by: "agent", bot: by.bot, reason: why };
+        database
+            .prepare("UPDATE facts SET metadata = json_set(coalesce(metadata, '{}'), '$.decision', json(?)) WHERE id = ?")
+            .run(JSON.stringify(decision), id);
+    };
+    const accept = (id, by = "owner", reason) => {
         const row = database.prepare("SELECT * FROM facts WHERE id = ?").get(id);
         if (row.status !== "proposed" && row.status !== "accepted")
             throw new CliError("validation_error", `a ${String(row.status)} fact cannot be accepted`);
-        const { actor } = authorActor(context, "owner");
+        const { actor } = authorActor(context, deciderAuthor(by));
         const at = now();
         database
             .prepare("UPDATE facts SET status = 'accepted', confirmed_by_type = ?, confirmed_by_id = ?, updated_at = ? WHERE id = ?")
             .run(actor.type, actor.id, at, id);
+        keepDecision(id, by, reason);
         if (row.supersedes_id != null)
             database
                 .prepare("UPDATE facts SET status = 'superseded', updated_at = ? WHERE id = ? AND status IN ('proposed', 'accepted')")
@@ -100,20 +119,29 @@ export const factOperationsOver = (context) => {
         list: (options = {}) => {
             const project = options.project === undefined ? undefined : requiredThing(database, options.project, "the project");
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
+            const by = proposedBySql("f.author_type", "f.author_id", options.proposedBy);
+            const order = options.order === "created" ? "f.created_at" : "coalesce(f.occurred_at, f.created_at)";
             return database
                 .prepare(`${NAMED} WHERE f.deleted_at IS NULL AND (? IS NULL OR f.type = ?) AND (? IS NULL OR f.project_id = ?) ` +
                 "AND (? IS NULL OR (f.subject_type = ? AND f.subject_id = ?)) AND (? IS NULL OR f.status = ?) " +
-                "ORDER BY coalesce(f.occurred_at, f.created_at) DESC, f.id DESC LIMIT ?")
-                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                `AND ${by.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
+                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(factOf);
         },
-        accept: (reference) => {
+        accept: (reference, by, reason) => {
+            const row = rowOf(reference);
+            decided(row, by);
+            write(database, () => accept(Number(row.id), by, reason));
+            return factOf(rowOf(reference));
+        },
+        acceptChecked: (reference, by) => {
             const id = Number(rowOf(reference).id);
-            write(database, () => accept(id));
+            write(database, () => accept(id, by));
             return factOf(rowOf(reference));
         },
-        reverse: (reference) => {
+        reverse: (reference, by) => {
             const row = rowOf(reference);
+            assertMayWithdraw({ id: `fact:${row.id}`, proposedBy: { type: "unknown" }, proposed: false }, by);
             if (row.type !== "decision")
                 throw new CliError("validation_error", "only a decision can be reversed");
             if (row.status !== "accepted")
@@ -121,15 +149,20 @@ export const factOperationsOver = (context) => {
             database.prepare("UPDATE facts SET status = 'reversed', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
             return factOf(rowOf(reference));
         },
-        reject: (reference) => {
+        reject: (reference, by, reason) => {
             const row = rowOf(reference);
+            decided(row, by);
             if (row.status !== "proposed")
                 throw new CliError("validation_error", `only a proposed fact can be rejected; this one is ${String(row.status)}`);
-            database.prepare("UPDATE facts SET status = 'rejected', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
+            write(database, () => {
+                database.prepare("UPDATE facts SET status = 'rejected', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
+                keepDecision(Number(row.id), by, reason);
+            });
             return factOf(rowOf(reference));
         },
-        remove: (reference) => {
+        remove: (reference, by) => {
             const row = rowOf(reference);
+            withdrawn(row, by);
             const id = Number(row.id);
             const twin = row.source === "memory" && row.metadata != null ? migratedFrom(String(row.metadata)) : undefined;
             const links = erase(database, () => {
@@ -165,10 +198,10 @@ export const factsStoreOver = (context) => {
         add: async (input) => operations.add(input),
         get: async (reference) => operations.get(reference),
         list: async (options) => operations.list(options),
-        accept: async (reference) => operations.accept(reference),
-        reverse: async (reference) => operations.reverse(reference),
-        reject: async (reference) => operations.reject(reference),
-        remove: async (reference) => operations.remove(reference),
+        accept: async (reference, by, reason) => operations.accept(reference, by, reason),
+        reverse: async (reference, by) => operations.reverse(reference, by),
+        reject: async (reference, by, reason) => operations.reject(reference, by, reason),
+        remove: async (reference, by) => operations.remove(reference, by),
         sources: async (reference) => operations.sources(reference),
     };
 };

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

@@ -1,4 +1,5 @@
 import { type Finding, type FindingEvidence, type FindingOutcome, type FindingsInput } from "../../meetings/index.js";
+import type { Decider } from "../decisions.js";
 import type { StoreContext } from "./open.js";
 export interface FindingsAgent {
     bot: string;
@@ -14,5 +15,5 @@ export declare const findingsCoreOver: (context: StoreContext, kind: string) =>
     snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string | null, seen: Map<string, unknown>) => void) => 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) => FindingOutcome[];
+    outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent, decidedBy: Decider) => FindingOutcome[];
 };

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

@@ -68,7 +68,7 @@ export const findingsCoreOver = (context, kind) => {
             .get(account, kind, fingerprint);
         return row ? JSON.parse(String(row.item)) : undefined;
     };
-    const create = (finding, agent) => {
+    const create = (finding, agent, decidedBy) => {
         const evidence = finding.evidence.map((item) => item.reference);
         if (finding.kind === "fact") {
             const fact = facts.add({
@@ -79,7 +79,7 @@ export const findingsCoreOver = (context, kind) => {
                 evidence,
                 by: agent,
             });
-            return facts.accept(fact.ref).ref;
+            return facts.acceptChecked(fact.ref, decidedBy).ref;
         }
         if (finding.project === undefined)
             return invalid("a task finding names the project the task goes in");
@@ -99,7 +99,7 @@ export const findingsCoreOver = (context, kind) => {
         return task.ref;
     };
     /** Reuses an earlier decision on an unchanged candidate; refuses to accept one that was rejected. */
-    const outcomes = (account, input, accepted, agent) => input.findings.map((finding) => {
+    const outcomes = (account, input, accepted, agent, decidedBy) => input.findings.map((finding) => {
         const fingerprint = findingFingerprint(finding);
         const prior = previous(account, fingerprint);
         if (prior) {
@@ -112,7 +112,7 @@ export const findingsCoreOver = (context, kind) => {
             id: finding.id,
             fingerprint,
             status,
-            reference: status === "accepted" ? create(finding, agent) : null,
+            reference: status === "accepted" ? create(finding, agent, decidedBy) : null,
             reused: false,
         };
     });