@wirecat/cli-core 0.546.0 → 0.547.0

package/dist/store/decisions.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Who proposed something waiting for the owner. `unknown` is a suggestion that names no author, such as an
+ * unconfirmed link written without provenance: only the owner decides it.
+ */
+export type Proposer = {
+    type: "person";
+    id: string;
+} | {
+    type: "bot";
+    id: string;
+    name: string;
+    kind: "agent" | "rule";
+} | {
+    type: "unknown";
+};
+/** Who decides: the owner, or an agent the host lets decide for the owner, with its reason. */
+export type Decider = "owner" | {
+    bot: string;
+    model?: string;
+    reason: string;
+};
+export interface DecisionPolicy {
+    /** The host's `agent_decisions`: `false` keeps every decision with the owner. */
+    agentDecisions: boolean;
+    /** A rule scorer's proposal is the owner's alone to decide. */
+    ruleProposalsOwnerOnly: boolean;
+}
+export declare const DEFAULT_DECISION_POLICY: DecisionPolicy;
+export interface Refusal {
+    id: string;
+    code: "permission_error" | "validation_error" | "not_found";
+    reason: string;
+    message: string;
+}
+/**
+ * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
+ * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
+ */
+export declare const mayDecide: (row: {
+    id: string;
+    proposedBy: Proposer;
+}, by: Decider, policy?: DecisionPolicy) => Refusal | null;
+/** One bot whatever its letter case or spacing: `Claude-Code` is `claude-code`. */
+export declare const botKey: (name: string) => string;
+/**
+ * Removing or reversing a row: the owner always may; an agent only withdraws its own row while it is still
+ * proposed. Everything else stays the owner's.
+ */
+export declare const assertMayWithdraw: (row: {
+    id: string;
+    proposedBy: Proposer;
+    proposed: boolean;
+}, by: Decider | Exclude<Decider, "owner"> | {
+    bot: string;
+}) => void;
+/** `mayDecide` for a store method: throws the refusal instead of returning it. */
+export declare const assertMayDecide: (row: {
+    id: string;
+    proposedBy: Proposer;
+}, by: Decider, policy?: DecisionPolicy) => void;
+/** The author a decision is recorded under. */
+export declare const deciderAuthor: (by: Decider) => "owner" | {
+    bot: string;
+    model?: string;
+};

package/dist/store/decisions.js

@@ -0,0 +1,55 @@
+import { CliError } from "@wirecat/cli-base";
+export const DEFAULT_DECISION_POLICY = { agentDecisions: true, 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.
+ */
+export const mayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
+    if (by === "owner")
+        return null;
+    const refuse = (code, reason, message) => ({
+        id: row.id,
+        code,
+        reason,
+        message,
+    });
+    if (!policy.agentDecisions)
+        return refuse("permission_error", "proposals.agent-decisions-off", "agent decisions are turned off; the owner decides");
+    if (typeof by.reason !== "string" || !by.reason.trim() || by.reason.length > 2000)
+        return refuse("validation_error", "proposal.reason-required", "an agent deciding for the owner gives a reason");
+    const proposer = row.proposedBy;
+    if (proposer.type === "unknown")
+        return refuse("permission_error", "proposal.owner-only", "this proposal names no author; only the owner decides it");
+    if (proposer.type === "bot" && proposer.kind === "rule" && policy.ruleProposalsOwnerOnly)
+        return refuse("permission_error", "proposal.owner-only", `proposed by ${proposer.name}: only the owner decides it`);
+    if (proposer.type === "bot" && proposer.kind === "agent" && botKey(proposer.name) === botKey(by.bot))
+        return refuse("permission_error", "proposal.own", `${by.bot} proposed this; another decider must decide it`);
+    return null;
+};
+/** One bot whatever its letter case or spacing: `Claude-Code` is `claude-code`. */
+export const botKey = (name) => name
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_]+/g, "-");
+/**
+ * Removing or reversing a row: the owner always may; an agent only withdraws its own row while it is still
+ * proposed. Everything else stays the owner's.
+ */
+export const assertMayWithdraw = (row, by) => {
+    if (by === "owner")
+        return;
+    const proposer = row.proposedBy;
+    if (row.proposed && proposer.type === "bot" && proposer.kind === "agent" && botKey(proposer.name) === botKey(by.bot))
+        return;
+    throw new CliError("permission_error", `only the owner removes or reverses ${row.id}`, {
+        reason: "proposal.owner-only",
+    });
+};
+/** `mayDecide` for a store method: throws the refusal instead of returning it. */
+export const assertMayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
+    const refusal = mayDecide(row, by, policy);
+    if (refusal)
+        throw new CliError(refusal.code, refusal.message, { reason: refusal.reason });
+};
+/** The author a decision is recorded under. */
+export const deciderAuthor = (by) => by === "owner" ? "owner" : { bot: by.bot, ...(by.model === undefined ? {} : { model: by.model }) };

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

@@ -1,16 +1,14 @@
 import { type FindingOutcome, type FindingsInput, type FindingsReceipt } from "../meetings/index.js";
+import type { Decider } from "./decisions.js";
 import type { EvidenceSource } from "./sqlite/evidence-sources.js";
 export declare const EVIDENCE_FINDINGS_KIND = "evidence_findings";
 export declare const validateEvidenceFindings: (input: FindingsInput) => FindingsInput;
 /** Who decided: the owner, or an agent the host let decide for the owner, with its reason. */
-export type EvidenceFindingsDecider = "owner" | {
-    bot: string;
-    model?: string;
-    reason: string;
-};
+export type EvidenceFindingsDecider = Decider;
 export interface EvidenceFindingsReceipt extends FindingsReceipt {
     decision: {
         by: "owner";
+        reason?: string;
     } | {
         by: "agent";
         bot: string;
@@ -31,6 +29,7 @@ export interface EvidenceFindingsBatch {
         type: "person" | "bot";
         id: string;
         name: string | null;
+        kind: "agent" | "rule" | null;
     };
     decidedBy: {
         type: "person" | "bot";
@@ -62,7 +61,8 @@ export interface EvidenceFindingsStore {
     review(id: string, input: {
         fingerprint: string;
         accept: string[];
-        by?: EvidenceFindingsDecider;
+        by: EvidenceFindingsDecider;
+        reason?: string;
     }): Promise<EvidenceFindingsBatch>;
     /** Each reference the batch cites, read back once; one gone from the store since is `missing`. */
     sources(id: string): Promise<EvidenceSource[]>;

package/dist/store/index.d.ts

@@ -7,6 +7,7 @@ export { note } from "../entities/note.js";
 export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFinding, MeetingFindingsInput, MeetingFindingsReceipt, MeetingTaskFinding, } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, type PriorityLabel, priorityLabel, priorityOf, priorityOption, TASK_STATES, type TaskState, } from "../tasks/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
+export { assertMayDecide, DEFAULT_DECISION_POLICY, type Decider, type DecisionPolicy, mayDecide, type Proposer, type Refusal, } from "./decisions.js";
 export type { DocumentTransferOptions, DocumentTransferPreview, DocumentTransferReceipt, } from "./document-transfer/index.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./driver.js";
@@ -30,7 +31,7 @@ export type { BotUpdate, BotUpdateStore } from "./sqlite/bot-updates.js";
 export type { CatalogActor, CatalogEntry, CatalogInput, CatalogQuery, CatalogStore } from "./sqlite/catalog.js";
 export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
-export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
+export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, PartialEmail, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
 export type { EvidenceSource } from "./sqlite/evidence-sources.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
@@ -49,8 +50,8 @@ export type { NoteIndexState } from "./sqlite/note-index.js";
 export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, type NoteQuery, type NoteSearch, } from "./sqlite/note-search.js";
 export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
-export type { ProposalInput, ProposedAction, ProposedActionsStore } from "./sqlite/proposed-actions.js";
-export { PROPOSAL_STATUSES } from "./sqlite/proposed-actions.js";
+export { PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
+export type { LinkDecision } 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";
 export type { TagCreationOptions, TagCreationReview } from "./sqlite/tag-creation.js";

package/dist/store/index.js

@@ -2,6 +2,7 @@ export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, priorityLabel, priorityOf, priorityOption, TASK_STATES, } from "../tasks/index.js";
+export { assertMayDecide, DEFAULT_DECISION_POLICY, mayDecide, } from "./decisions.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
@@ -21,7 +22,7 @@ export { EVENT_FIELDS, } from "./sqlite/event-search.js";
 export { IMPORTED_DOCUMENT_QUERY } from "./sqlite/imported-documents.js";
 export { ORGANIZATION_KINDS, PROJECT_TYPES, SCOPES } from "./sqlite/knowledge.js";
 export { NOTE_FIELDS, } from "./sqlite/note-search.js";
-export { PROPOSAL_STATUSES } from "./sqlite/proposed-actions.js";
+export { PROPOSAL_STATUSES, proposerOfAction, } from "./sqlite/proposed-actions.js";
 export { fillSearchIndex, resetSearchIndex, searchIndexState, } from "./sqlite/search-index.js";
 export { PROJECT_TASK_FIELDS, TASK_SORTS } from "./sqlite/task-board.js";
 export { certaintyOf } from "./sqlite/task-close.js";

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

@@ -1,4 +1,5 @@
 import type { FindingOutcome, MeetingFindingsInput, MeetingFindingsReceipt } from "../meetings/index.js";
+import type { Decider } from "./decisions.js";
 import type { AccountKey } from "./types.js";
 export interface MeetingFindingsBatch {
     id: string;
@@ -36,5 +37,6 @@ export interface MeetingFindingsStore {
     review(account: AccountKey, id: string, input: {
         fingerprint: string;
         accept: string[];
+        by: Decider;
     }): Promise<MeetingFindingsBatch>;
 }

package/dist/store/messages.d.ts

@@ -2,6 +2,7 @@ import type { CounterObservations } from "../domain/counters.js";
 import type { Delivery, Id, Message, Page, PersonReaction, PollVote, Reactions, Reactor, WindowedMessage } from "../domain/models.js";
 import { type DocumentLinkMessage } from "./sqlite/document-links.js";
 import type { StoreContext } from "./sqlite/open.js";
+import * as reads from "./sqlite/reads.js";
 import type { AccountKey, DeletionScope, IngestedVia, MessageFilter, SenderChatStats, StoredHit } from "./types.js";
 export interface AccountMessages {
     /**
@@ -40,16 +41,10 @@ export interface AccountMessages {
     /** Oldest to newest, like a provider's history page. */
     /**
      * `threadId` keeps one forum topic's; `outgoing` only the owner's (true) or only the others' (false); `starred`
-     * only the ones the owner starred (true) or did not (false).
+     * only the ones the owner starred (true) or did not (false). `after` reads forward instead of back, and `until`
+     * ends the window; `reads.MessagePageWindow` says how.
      */
-    messages(key: AccountKey, chatId: Id, window: {
-        limit: number;
-        before?: Id;
-        since?: string;
-        threadId?: Id;
-        outgoing?: boolean;
-        starred?: boolean;
-    }): Promise<Page<Message>>;
+    messages(key: AccountKey, chatId: Id, window: reads.MessagePageWindow): Promise<Page<Message>>;
     /** How many stored messages the chat has, sent at `since` or later when it is given. */
     countMessages(key: AccountKey, chatId: Id, options?: {
         since?: string;

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/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;