@wirecat/cli-core 0.546.0 → 0.548.0

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

@@ -0,0 +1,25 @@
+import type { Proposer } from "../../../store/decisions.js";
+import type { ProposalFilter, ProposalRow } from "../types.js";
+/** A stored author as a proposer, with the kind read from its bot row. */
+export declare const proposerOfAuthor: (author: {
+    type: "person" | "bot";
+    id: string;
+    name: string | null;
+    kind: "agent" | "rule" | null;
+}) => Proposer;
+/** What a kind keeps of the rows it read: the filter's status and proposer, newest first, at most `limit`. */
+export declare const kept: (rows: ProposalRow[], filter: ProposalFilter) => ProposalRow[];
+/** The filters every store list takes, so a page is filled by the query and not cut after it. */
+export declare const pushed: (filter: ProposalFilter) => {
+    project?: string | undefined;
+    proposedBy?: "agent" | "rule" | {
+        bot: string;
+    } | undefined;
+    limit: number;
+};
+/** A suggestion an agent or a rule wrote; Drive's editor links and other records stay out of the inbox. */
+export declare const proposedLink: (provenance: string | null) => boolean;
+export declare const projectOf: (...refs: (string | null | undefined)[]) => string | null;
+export declare const actionStatus: (status: string) => ProposalRow["status"];
+/** The stored statuses a filter's status reads, so the store does the filtering when it can. */
+export declare const storedStatus: (filter: ProposalFilter) => "proposed" | "rejected" | undefined;

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

@@ -0,0 +1,49 @@
+/** A stored author as a proposer, with the kind read from its bot row. */
+export const proposerOfAuthor = (author) => {
+    if (author.type === "person")
+        return { type: "person", id: author.id };
+    if (author.name === null)
+        return { type: "unknown" };
+    return { type: "bot", id: author.id, name: author.name, kind: author.kind ?? "agent" };
+};
+const byMatches = (row, by) => {
+    if (by === undefined)
+        return true;
+    const proposer = row.proposedBy;
+    if (proposer.type !== "bot")
+        return false;
+    if (by === "agent" || by === "rule")
+        return proposer.kind === by;
+    return proposer.name === by.bot;
+};
+/** What a kind keeps of the rows it read: the filter's status and proposer, newest first, at most `limit`. */
+export const kept = (rows, filter) => {
+    const status = filter.status ?? "proposed";
+    return rows
+        .filter((row) => (status === "all" || row.status === status) && byMatches(row, filter.by))
+        .filter((row) => filter.project === undefined || row.project === filter.project)
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+        .slice(0, filter.limit);
+};
+/** The filters every store list takes, so a page is filled by the query and not cut after it. */
+export const pushed = (filter) => ({
+    ...(filter.project === undefined ? {} : { project: filter.project }),
+    ...(filter.by === undefined ? {} : { proposedBy: filter.by }),
+    limit: Math.min(filter.limit, 500),
+});
+/** A suggestion an agent or a rule wrote; Drive's editor links and other records stay out of the inbox. */
+export const proposedLink = (provenance) => /^(agent|rule):/.test(provenance ?? "");
+export const projectOf = (...refs) => refs.find((ref) => typeof ref === "string" && ref.startsWith("project:")) ?? null;
+const ACTION_STATUS = {
+    proposed: "proposed",
+    approved: "confirmed",
+    executed: "confirmed",
+    failed: "confirmed",
+    rejected: "rejected",
+};
+export const actionStatus = (status) => ACTION_STATUS[status] ?? "proposed";
+/** The stored statuses a filter's status reads, so the store does the filtering when it can. */
+export const storedStatus = (filter) => {
+    const status = filter.status ?? "proposed";
+    return status === "proposed" || status === "rejected" ? status : undefined;
+};

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

@@ -0,0 +1,9 @@
+import type { MessageStore } from "../../store/store.js";
+import type { ProposalRegistry } from "./types.js";
+/** An empty registry: the host registers its kinds. `proposalRegistry` is this with the core kinds. */
+export declare const emptyProposalRegistry: (store: Pick<MessageStore, "proposedActions" | "decisionPolicy">) => ProposalRegistry & {
+    claimed(): string[];
+};
+/** Every proposal kind core knows, behind one check of who may decide. */
+/** The policy is the store's, set when it was opened, so the registry and the store methods never disagree. */
+export declare const proposalRegistry: (store: MessageStore) => ProposalRegistry;

package/dist/services/proposals/registry.js

@@ -0,0 +1,129 @@
+import { CliError } from "@wirecat/cli-base";
+import { mayDecide } from "../../store/decisions.js";
+import { actionKind } from "./kinds/action.js";
+import { factKind } from "./kinds/fact.js";
+import { findingsKind } from "./kinds/findings.js";
+import { keyDocumentKind } from "./kinds/key-document.js";
+import { memoryKind } from "./kinds/memory.js";
+import { relationshipKind } from "./kinds/relationship.js";
+const PREFIX = /^([a-z][a-z_]*):/;
+const refusalOf = (id, error) => {
+    if (!(error instanceof CliError))
+        throw error;
+    const code = error.code === "not_found" || error.code === "permission_error" ? error.code : "validation_error";
+    const reason = error.details?.reason;
+    return { id, code, reason: typeof reason === "string" ? reason : code, message: error.message };
+};
+/** An empty registry: the host registers its kinds. `proposalRegistry` is this with the core kinds. */
+export const emptyProposalRegistry = (store) => {
+    const policy = store.decisionPolicy;
+    const kinds = [];
+    const claimed = () => kinds.flatMap((kind) => kind.stored ?? []);
+    const kindOf = async (id) => {
+        const prefix = PREFIX.exec(id)?.[1];
+        const found = prefix !== undefined
+            ? kinds.find((kind) => kind.prefix === prefix)
+            : await (async () => {
+                const stored = (await store.proposedActions.get(id)).kind;
+                return (kinds.find((kind) => kind.stored?.includes(stored)) ??
+                    kinds.find((kind) => kind.prefix === undefined && kind.stored === undefined));
+            })();
+        if (!found)
+            throw new CliError("not_found", `no proposal ${id}`, { reason: "proposal.unknown-kind" });
+        return found;
+    };
+    const registry = {
+        claimed,
+        register: (kind) => {
+            if (kinds.some((one) => one.kind === kind.kind))
+                throw new CliError("configuration_error", `proposal kind ${kind.kind} is registered twice`);
+            if (kind.prefix !== undefined && kinds.some((one) => one.prefix === kind.prefix))
+                throw new CliError("configuration_error", `proposal prefix ${kind.prefix} is registered twice`);
+            kinds.push(kind);
+        },
+        list: async (filter) => {
+            if (!Number.isSafeInteger(filter.limit) || filter.limit < 1 || filter.limit > 50)
+                throw new CliError("validation_error", "a proposal list takes 1–50 items");
+            if (!Number.isSafeInteger(filter.offset) || filter.offset < 0)
+                throw new CliError("validation_error", "a proposal list takes a nonnegative offset");
+            const asked = filter.kinds === undefined ? kinds : kinds.filter((kind) => filter.kinds?.includes(kind.kind));
+            const wide = { ...filter, offset: 0, limit: filter.offset + filter.limit + 1 };
+            const rows = (await Promise.all(asked.map((kind) => kind.list(wide)))).flat();
+            rows.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+            const page = rows.slice(filter.offset, filter.offset + filter.limit + 1);
+            return { items: page.slice(0, filter.limit), hasMore: page.length > filter.limit };
+        },
+        get: async (id) => (await kindOf(id)).get(id),
+        decide: async (ids, decision) => {
+            const parts = new Map();
+            const whole = new Set();
+            const order = [];
+            for (const id of ids) {
+                const [batch, part] = id.split("/");
+                if (!batch)
+                    continue;
+                if (!parts.has(batch)) {
+                    parts.set(batch, []);
+                    order.push(batch);
+                }
+                if (part === undefined)
+                    whole.add(batch);
+                else
+                    parts.get(batch)?.push(part);
+            }
+            const decided = [];
+            const refused = [];
+            const refuseIds = (id, message) => refused.push({ id, code: "validation_error", reason: "proposal.ids", message });
+            for (const id of order) {
+                const chosen = parts.get(id) ?? [];
+                if (chosen.length && whole.has(id)) {
+                    refuseIds(id, `name ${id} or some of its parts (${id}/${chosen[0]}), not both`);
+                    continue;
+                }
+                try {
+                    const kind = await kindOf(id);
+                    if (chosen.length && !kind.parts) {
+                        refuseIds(id, `a ${kind.kind} proposal has no parts; name ${id} alone`);
+                        continue;
+                    }
+                    const row = await kind.get(id);
+                    if (row.status !== "proposed") {
+                        refused.push({
+                            id,
+                            code: "validation_error",
+                            reason: "proposal.wrong-state",
+                            message: `${id} is already ${row.status}`,
+                        });
+                        continue;
+                    }
+                    const refusal = mayDecide(row, decision.by, policy);
+                    if (refusal) {
+                        refused.push(refusal);
+                        continue;
+                    }
+                    decided.push(await kind.decide(id, chosen.length ? { ...decision, parts: chosen } : decision));
+                }
+                catch (error) {
+                    refused.push(refusalOf(id, error));
+                }
+            }
+            return { decided, refused };
+        },
+    };
+    return registry;
+};
+/** Every proposal kind core knows, behind one check of who may decide. */
+/** The policy is the store's, set when it was opened, so the registry and the store methods never disagree. */
+export const proposalRegistry = (store) => {
+    const registry = emptyProposalRegistry(store);
+    for (const kind of [
+        relationshipKind(store),
+        keyDocumentKind(store),
+        factKind(store),
+        memoryKind(store),
+        findingsKind(store),
+    ])
+        registry.register(kind);
+    registry.register(actionKind(store, registry.claimed));
+    return registry;
+};

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

@@ -0,0 +1,85 @@
+import type { Decider, Proposer, Refusal } from "../../store/decisions.js";
+export interface ProposalRow {
+    /** `17070` for a stored proposal; `fact:512`, `memory:88`, `link:17` and `key:9` for the kinds kept elsewhere. */
+    id: string;
+    kind: string;
+    status: "proposed" | "confirmed" | "rejected";
+    project: string | null;
+    /** The reference it is about. */
+    subject: string;
+    /** The reference it links to, when it links. */
+    object: string | null;
+    /** A fact's statement or a finding count; never message text. */
+    summary: string | null;
+    proposedBy: Proposer;
+    reason: string | null;
+    /** At most 5 references. */
+    evidence: string[];
+    score: number | null;
+    signals: {
+        scorer: string;
+        weight: number;
+        why: string;
+    }[] | null;
+    parts: {
+        id: string;
+        kind: string;
+        summary: string;
+        outcome: "accepted" | "rejected" | null;
+    }[] | null;
+    createdAt: string;
+}
+export interface ProposalFilter {
+    project?: string;
+    kinds?: string[];
+    by?: "agent" | "rule" | {
+        bot: string;
+    };
+    status?: ProposalRow["status"] | "all";
+    limit: number;
+    offset: number;
+}
+export interface Decision {
+    confirm: boolean;
+    by: Decider;
+    /** Why, kept with the decision; a memory has nowhere to keep it. */
+    reason?: string;
+    /** The findings of a batch to accept; the rest are rejected. */
+    parts?: string[];
+}
+export interface Decided {
+    id: string;
+    kind: string;
+    status: "confirmed" | "rejected";
+    /** References the decision made: `relationship:2203`, `fact:530`, `task:…`. */
+    made: string[];
+}
+/**
+ * One kind of proposal. `prefix` names its own id space (`fact` for `fact:512`); a kind stored in `proposed_actions`
+ * names the stored kinds it owns in `stored` and has bare number ids. A new kind registers itself; nothing else changes.
+ */
+export interface ProposalKind {
+    readonly kind: string;
+    readonly prefix?: string;
+    readonly stored?: readonly string[];
+    /** Whether its proposals have parts decided on their own, as a findings batch has findings. */
+    readonly parts?: boolean;
+    /** Bounded: at most `offset + limit` rows, newest first. */
+    list(filter: ProposalFilter): Promise<ProposalRow[]>;
+    get(id: string): Promise<ProposalRow>;
+    /** Called only after `mayDecide` allowed it. */
+    decide(id: string, decision: Decision): Promise<Decided>;
+}
+export interface ProposalRegistry {
+    register(kind: ProposalKind): void;
+    list(filter: ProposalFilter): Promise<{
+        items: ProposalRow[];
+        hasMore: boolean;
+    }>;
+    get(id: string): Promise<ProposalRow>;
+    /** Each id on its own: one refusal never undoes the others. */
+    decide(ids: string[], decision: Decision): Promise<{
+        decided: Decided[];
+        refused: Refusal[];
+    }>;
+}

package/dist/services/proposals/types.js

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

package/dist/services/server-search.d.ts

@@ -2,12 +2,15 @@ import type { Id } from "../domain/models.js";
 import type { ServiceDeps } from "./deps.js";
 import type { SearchQuery } from "./messages.js";
 export declare const SERVER_SEARCH_KEY = "messages.server-search";
-/** `maxMessageBytes`: a candidate larger than this is not downloaded; a sync reads it, and the answer says so. */
+/**
+ * `textBytes`: a mail candidate is read up to this many bytes, its headers and text; one cut short is stored partial
+ * and the next sync reads it whole.
+ */
 export declare const SERVER_BOUNDS: {
     timeMs: number;
     perCall: number;
     maxCalls: number;
-    maxMessageBytes: number;
+    textBytes: number;
 };
 export declare const DEFAULT_BACKEND = "both";
 export type Backend = "archive" | "server" | "both";
@@ -26,8 +29,8 @@ export interface ServerSearched {
         chat: string | null;
         reason: "rate_limited" | "search_failed" | "time_or_abort_bound";
     }[];
-    /** Candidates larger than `SERVER_BOUNDS.maxMessageBytes`, left on the server unread. */
-    tooLarge?: number;
+    /** Candidates stored from their first `SERVER_BOUNDS.textBytes`, without the attachments; a sync reads them whole. */
+    partial?: number;
     complete: boolean;
 }
 export type HitSource = "archive" | "server" | "both";

package/dist/services/server-search.js

@@ -2,8 +2,11 @@ import { CliError } from "@wirecat/cli-base";
 import { capability } from "../ports/messenger.js";
 import { prepareLucene } from "./messages-search.js";
 export const SERVER_SEARCH_KEY = "messages.server-search";
-/** `maxMessageBytes`: a candidate larger than this is not downloaded; a sync reads it, and the answer says so. */
-export const SERVER_BOUNDS = { timeMs: 5_000, perCall: 100, maxCalls: 3, maxMessageBytes: 5_000_000 };
+/**
+ * `textBytes`: a mail candidate is read up to this many bytes, its headers and text; one cut short is stored partial
+ * and the next sync reads it whole.
+ */
+export const SERVER_BOUNDS = { timeMs: 5_000, perCall: 100, maxCalls: 3, textBytes: 262_144 };
 export const DEFAULT_BACKEND = "both";
 export const sourceKey = (chatId, id) => JSON.stringify([chatId, id]);
 const merge = (one, other) => {

package/dist/services/tasks.js

@@ -260,7 +260,9 @@ export const tasksService = (deps, categories) => {
                 const link = {
                     from: (await store.tasks.details(target.id)).ref,
                     kind: "evidence",
-                    origin: origin === "owner" ? "owner" : "suggested",
+                    ...(origin === "owner"
+                        ? { origin: "owner", by: "owner" }
+                        : { origin: "suggested", confirmed: false }),
                 };
                 try {
                     await store.notes.addLink({ ...link, to: note ? note.ref : source });
@@ -448,17 +450,19 @@ export const tasksService = (deps, categories) => {
                     account: account.account,
                     chat: await storedChatId(deps.messenger, chat, store, account, { includeLeft: true }),
                 })));
-                const origin = by === "owner" ? "owner" : "suggested";
+                const origin = by === "owner"
+                    ? { origin: "owner", by: "owner" }
+                    : { origin: "suggested", confirmed: false };
                 for (const target of [...written, ...chatRefs]) {
                     try {
-                        await store.notes.addLink({ from, to: target, kind: kind, origin });
+                        await store.notes.addLink({ from, to: target, kind: kind, ...origin });
                     }
                     catch (error) {
                         // Only text that names nothing typed, or a message not saved yet; a mistyped `person:9` is refused.
                         const unsaved = error instanceof CliError && error.code === "not_found" && target.startsWith("msg:");
                         if (!unsaved && !(error instanceof CliError && error.code === "validation_error"))
                             throw error;
-                        await store.notes.addLink({ from, targetText: target, kind: kind, origin });
+                        await store.notes.addLink({ from, targetText: target, kind: kind, ...origin });
                     }
                 }
                 if (!written.some((target) => target.startsWith("msg:")))

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/accounts.d.ts

@@ -1,3 +1,4 @@
+import type { CacheDatabase } from "../driver.js";
 import type { AccountKey, StoredAccount } from "../types.js";
 import type { StoreContext } from "./open.js";
 /** An account's row, made on first sight; a name only replaces what was known when there is one. */
@@ -10,3 +11,10 @@ export declare const storedAccounts: ({ orm }: StoreContext) => StoredAccount[];
 export declare const storedAccount: ({ orm }: StoreContext, { provider, account }: AccountKey) => StoredAccount;
 /** Everything the account holds, children before parents: the foreign keys are enforced. */
 export declare const purgeAccount: ({ orm, database }: StoreContext, accountKey: number) => void;
+export declare const unreferenced: (database: CacheDatabase, table: "identities") => Set<number>;
+/**
+ * People only the purged account had seen go with it. An identity stays while anything else points at it
+ * (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.
+ */
+export declare const dropOrphanPeople: (database: CacheDatabase, unseenBefore: Set<number>) => void;