@wirecat/cli-core 0.545.0 → 0.547.0

package/dist/services/questions.d.ts

@@ -9,9 +9,14 @@ export declare const unanswered: (messages: Message[], { answerers, before }: {
     answerers: ReadonlySet<Id>;
     before: number;
 }) => Message[];
-/** Every question from others, as `unanswered` reads them, with the message that answered it, if one did. */
-export declare const questions: (messages: Message[], { answerers }: {
+/**
+ * Every question from others, as `unanswered` reads them, with the message that answered it, if one did.
+ * With `asker: "owner"` it is the owner's own questions instead, and anyone but the owner answers: by replying to
+ * it, or by speaking next. `answerers` is not read then.
+ */
+export declare const questions: (messages: Message[], { answerers, asker }: {
     answerers: ReadonlySet<Id>;
+    asker?: "others" | "owner";
 }) => {
     question: Message;
     answer?: Message;

package/dist/services/questions.js

@@ -9,12 +9,21 @@ const LINKS = /https?:\/\/\S+/g;
 export const unanswered = (messages, { answerers, before }) => questions(messages, { answerers })
     .filter(({ question, answer }) => answer === undefined && Date.parse(question.timestamp) < before)
     .map(({ question }) => question);
-/** Every question from others, as `unanswered` reads them, with the message that answered it, if one did. */
-export const questions = (messages, { answerers }) => {
-    const answers = (message) => message.outgoing === true || (message.senderId !== null && answerers.has(message.senderId));
+/**
+ * Every question from others, as `unanswered` reads them, with the message that answered it, if one did.
+ * With `asker: "owner"` it is the owner's own questions instead, and anyone but the owner answers: by replying to
+ * it, or by speaking next. `answerers` is not read then.
+ */
+export const questions = (messages, { answerers, asker = "others" }) => {
+    const fromOwner = (message) => message.outgoing === true;
+    const answers = asker === "owner"
+        ? (message) => !fromOwner(message)
+        : (message) => fromOwner(message) || (message.senderId !== null && answerers.has(message.senderId));
     const byId = new Map(messages.map((message) => [message.id, message]));
     // Telegram names only the id a reply answers; the message itself is found in the window, or not at all.
     const repliesToAnswerer = (message) => {
+        if (asker === "owner")
+            return false;
         const to = message.replyTo?.id ?? message.replyToId;
         const quoted = to === undefined ? undefined : byId.get(to);
         if (quoted)
@@ -22,7 +31,7 @@ export const questions = (messages, { answerers }) => {
         return (message.replyTo !== null && (message.replyTo.outgoing === true || answerers.has(message.replyTo.senderId ?? "")));
     };
     return messages.flatMap((message, index) => {
-        if (answers(message))
+        if (asker === "owner" ? !fromOwner(message) : answers(message))
             return [];
         const transcript = "transcript" in message && typeof message.transcript === "string" ? message.transcript : "";
         if (![message.text, transcript].join("\n").replace(LINKS, "").includes("?") && !repliesToAnswerer(message))

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/stored-project-gathering.d.ts

@@ -34,6 +34,15 @@ export interface StoredProjectInput {
 }
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export declare const canonicalProjectRef: (store: MessageStore, reference: string) => Promise<string>;
+export interface LinkedChat {
+    provider: string;
+    account: string;
+    chat: string;
+    /** The link's free role (`source report`, `what worked`), if the owner set one. */
+    role: string | null;
+}
+/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
+export declare const linkedChatsOf: (store: MessageStore, project: string | null) => Promise<LinkedChat[]>;
 export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvidence>> & {
     projectRef: string | null;
     unreadSources: {

package/dist/services/stored-project-gathering.js

@@ -118,7 +118,7 @@ const memberLanesOf = async (store, project, given, room) => {
     return { lanes, left };
 };
 /** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-const linkedChatsOf = async (store, project) => {
+export const linkedChatsOf = async (store, project) => {
     if (!project)
         return [];
     const chats = [];
@@ -129,9 +129,14 @@ const linkedChatsOf = async (store, project) => {
             continue;
         const reference = parseReference(relation.from);
         if (reference.type === "chat")
-            chats.push(reference);
+            chats.push({
+                provider: reference.provider,
+                account: reference.account,
+                chat: reference.chat,
+                role: relation.role,
+            });
     }
-    return chats.map(({ provider, account, chat }) => ({ provider, account, chat }));
+    return chats;
 };
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
@@ -158,7 +163,7 @@ export const gatherStoredProject = async (store, input) => {
     const members = await memberLanesOf(store, project.ref, new Set(contacts.flatMap((one) => one.reference ?? [])), room);
     const people = [...contacts, ...members.lanes];
     const linked = await linkedChatsOf(store, project.ref);
-    const linkedChats = linked.slice(0, LINKED_CHATS);
+    const linkedChats = linked.slice(0, LINKED_CHATS).map(({ provider, account, chat }) => ({ provider, account, chat }));
     const budgets = {
         ...(input.maxReads === undefined ? {} : { maxReads: input.maxReads }),
         ...(input.limit === undefined ? {} : { maxItems: input.limit }),

package/dist/services/task-categories.d.ts

@@ -2,6 +2,8 @@ import { type TaskCategory } from "../domain/task-categories.js";
 export { DEFAULT_TASK_CATEGORIES, FALLBACK_CATEGORY, parseTaskCategory, type TaskCategory, type UnlistedCategory, unlistedNote, withTaskCategory, } from "../domain/task-categories.js";
 /** A category the list holds, or a refusal that names the list. */
 export declare const taskCategoryOf: (categories?: readonly TaskCategory[], flag?: string) => (typed: string) => string;
+/** The names of every list the text hits, so a message can be a request and a promise at once. */
+export declare const listsHit: (text: string, categories: readonly TaskCategory[]) => string[];
 /**
  * The category with the most distinct trigger stems in the text; none is `other`, a tie goes to the earlier one.
  * A word hits by its English stem first, so a cognate (`hospital`) counts once, not twice.

package/dist/services/task-categories.js

@@ -38,15 +38,12 @@ const triggerStems = (categories) => {
     stemsByList.set(categories, built);
     return built;
 };
-/**
- * The category with the most distinct trigger stems in the text; none is `other`, a tie goes to the earlier one.
- * A word hits by its English stem first, so a cognate (`hospital`) counts once, not twice.
- */
-export const categorize = (text, categories = DEFAULT_TASK_CATEGORIES) => {
+/** For each list the text hits, the number of distinct trigger stems it hit, in list order. */
+const hitsByList = (text, categories) => {
     const stem = stemmersOf();
     const english = stem.english.stemTokens(text);
     const spanish = readsSpanish(text) ? stem.spanish.stemTokens(text) : [];
-    let best = { name: FALLBACK_CATEGORY, hits: 0 };
+    const counted = [];
     for (const triggers of triggerStems(categories)) {
         const hit = new Set();
         english.forEach((word, at) => {
@@ -56,8 +53,22 @@ export const categorize = (text, categories = DEFAULT_TASK_CATEGORIES) => {
             else if (other !== undefined && triggers.spanish.has(other))
                 hit.add(other);
         });
-        if (hit.size > best.hits)
-            best = { name: triggers.name, hits: hit.size };
+        counted.push({ name: triggers.name, hits: hit.size });
     }
+    return counted;
+};
+/** The names of every list the text hits, so a message can be a request and a promise at once. */
+export const listsHit = (text, categories) => hitsByList(text, categories)
+    .filter(({ hits }) => hits > 0)
+    .map(({ name }) => name);
+/**
+ * The category with the most distinct trigger stems in the text; none is `other`, a tie goes to the earlier one.
+ * A word hits by its English stem first, so a cognate (`hospital`) counts once, not twice.
+ */
+export const categorize = (text, categories = DEFAULT_TASK_CATEGORIES) => {
+    let best = { name: FALLBACK_CATEGORY, hits: 0 };
+    for (const counted of hitsByList(text, categories))
+        if (counted.hits > best.hits)
+            best = counted;
     return best.name;
 };

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