@wirecat/cli-core 0.559.0 → 0.561.0

package/dist/meetings/findings-rules.d.ts

@@ -73,7 +73,31 @@ export interface FindingsRules {
     anySubject?: boolean;
     /** Payment findings are staged on a project's evidence, not from a meeting. */
     payments?: boolean;
+    /** A task finding may name no project: it goes in its account's inbox. */
+    inboxTasks?: boolean;
 }
+/** A finding's cited evidence: 1–8 distinct references in `rules`' form, each with a 64-hex fingerprint. */
+export declare const validEvidence: (raw: unknown, rules: FindingsRules) => FindingEvidence[];
+/** A finding's simple key: unique among `ids`, which it joins. */
+export declare const findingId: (raw: unknown, ids: Set<string>) => string;
+/** One fact, payment or task finding, its ID added to `ids`. */
+export declare const validateFinding: (finding: Finding, rules: FindingsRules, ids: Set<string>) => Finding;
+/** A date's or assignee's support: references the finding's own evidence cites. */
+export declare const support: (value: unknown, evidence: readonly FindingEvidence[]) => string[];
+/** A batch's envelope — schema version, key, extractor — around 1–`most` findings each `one` checks. */
+export declare const validateBatch: <F>(input: {
+    schemaVersion: 1;
+    key: string;
+    extractor: string;
+    findings: unknown[];
+}, rules: Pick<FindingsRules, "plural" | "singular">, most: number, one: (finding: never, ids: Set<string>) => F) => {
+    schemaVersion: 1;
+    key: string;
+    extractor: string;
+    findings: F[];
+};
 export declare const validateFindings: (input: FindingsInput, rules: FindingsRules) => FindingsInput;
+export declare const findingText: (value: unknown, limit: number) => string;
+export declare const findingFields: (value: object, allowed: string[], noun: string) => void;
 export declare const findingFingerprint: ({ id: _id, ...finding }: Finding) => string;
 export {};

package/dist/meetings/findings-rules.js

@@ -17,132 +17,152 @@ const fields = (value, allowed, noun) => {
         invalid(`unknown ${noun} field`);
 };
 const SUBJECT = /^(person|organization|project):[1-9]\d*$|^task:[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
-export const validateFindings = (input, rules) => {
+/** A finding's cited evidence: 1–8 distinct references in `rules`' form, each with a 64-hex fingerprint. */
+export const validEvidence = (raw, rules) => {
+    if (!Array.isArray(raw) || raw.length < 1 || raw.length > 8)
+        return invalid(`a finding requires 1–8 cited ${rules.cited}s`);
+    const evidence = raw
+        .map((item) => {
+        if (!item || typeof item !== "object")
+            return invalid("finding evidence is a reference and fingerprint");
+        fields(item, ["reference", "fingerprint"], rules.singular);
+        if (typeof item.reference !== "string" || typeof item.fingerprint !== "string")
+            return invalid("evidence requires a reference and fingerprint");
+        const reference = rules.reference(item.reference);
+        if (!/^[a-f0-9]{64}$/.test(item.fingerprint))
+            return invalid(`finding evidence requires exact ${rules.cited} references and fingerprints`);
+        return { reference, fingerprint: item.fingerprint };
+    })
+        .sort((a, b) => a.reference.localeCompare(b.reference));
+    if (new Set(evidence.map((item) => item.reference)).size !== evidence.length)
+        return invalid(`duplicate evidence ${rules.cited}`);
+    return evidence;
+};
+/** A finding's simple key: unique among `ids`, which it joins. */
+export const findingId = (raw, ids) => {
+    const id = findingText(raw, 64);
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_.:-]*$/.test(id) || ids.has(id))
+        return invalid("finding IDs must be unique simple keys");
+    ids.add(id);
+    return id;
+};
+/** One fact, payment or task finding, its ID added to `ids`. */
+export const validateFinding = (finding, rules, ids) => {
+    if (!finding || typeof finding !== "object")
+        return invalid("a finding is an object");
+    const id = findingId(finding.id, ids);
+    const project = finding.project === undefined && rules.anySubject ? undefined : text(finding.project, 64);
+    if (project !== undefined && !/^project:[1-9]\d*$/.test(project))
+        return invalid("a finding names a project reference");
+    if (finding.subject !== undefined && (!rules.anySubject || !SUBJECT.test(text(finding.subject, 80))))
+        return invalid("a finding's subject is a person:, organization:, task: or project: reference");
+    if (finding.kind === "task" && project === undefined && !rules.inboxTasks)
+        return invalid("a task finding names the project the task goes in");
+    const evidence = validEvidence(finding.evidence, rules);
+    const base = {
+        id,
+        ...(project === undefined ? {} : { project }),
+        ...(finding.subject === undefined ? {} : { subject: finding.subject }),
+        evidence,
+    };
+    if (finding.kind === "fact") {
+        fields(finding, ["id", "project", "subject", "evidence", "kind", "type", "statement"], rules.singular);
+        if (finding.type === "payment")
+            return invalid("a payment is a finding of kind payment; money is a payments row, not a fact");
+        if (!FACT_TYPES.includes(finding.type))
+            return invalid("unknown fact finding type");
+        return { ...base, kind: "fact", type: finding.type, statement: text(finding.statement, 2000) };
+    }
+    if (finding.kind === "payment" && rules.payments) {
+        fields(finding, ["id", "project", "subject", "evidence", "kind", "statement", "payment", "supersedes"], rules.singular);
+        if (finding.supersedes !== undefined && !/^invoice:[1-9]\d*$/.test(String(finding.supersedes)))
+            return invalid("a payment finding supersedes an invoice: reference, the expected payment it settles or voids");
+        const payment = validatePayment(finding.payment);
+        if (payment.state === "expected" && finding.supersedes !== undefined)
+            return invalid("an expected payment supersedes nothing; a paid or cancelled one supersedes its invoice");
+        if (payment.state === "cancelled" && finding.supersedes === undefined)
+            return invalid("a cancelled payment names the invoice: it cancels in supersedes");
+        if (payment.state === "expected" && !/^(person|organization):/.test(payment.counterparty ?? ""))
+            return invalid("an expected payment becomes an invoice, which names its counterparty as a person: or organization:");
+        return {
+            ...base,
+            kind: "payment",
+            ...(finding.statement === undefined ? {} : { statement: text(finding.statement, 2000) }),
+            payment,
+            ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
+        };
+    }
+    if (finding.kind !== "task")
+        return invalid(`a finding is a fact${rules.payments ? ", payment" : ""} or task`);
+    fields(finding, [
+        "id",
+        "project",
+        "evidence",
+        "kind",
+        "type",
+        "title",
+        "reason",
+        "commitment",
+        "dueAt",
+        "dueEvidence",
+        "assignee",
+        "assigneeEvidence",
+    ], rules.singular);
+    if (!TASK_TYPES.includes(finding.type))
+        return invalid("a task finding type is bug, chore or feature");
+    if (!["explicit", "inferred"].includes(finding.commitment))
+        return invalid("task commitment must be explicit or inferred");
+    if ((finding.dueAt === undefined) !== (finding.dueEvidence === undefined) ||
+        (finding.assignee === undefined) !== (finding.assigneeEvidence === undefined))
+        return invalid("optional dates and assignees require their supporting evidence");
+    if (finding.assignee !== undefined &&
+        (typeof finding.assignee !== "string" || !/^person:[1-9]\d*$/.test(finding.assignee)))
+        return invalid("an assignee must be a person reference");
+    return {
+        ...base,
+        kind: "task",
+        type: finding.type,
+        title: text(finding.title, 300),
+        reason: text(finding.reason, 2000),
+        commitment: finding.commitment,
+        ...(finding.dueAt === undefined
+            ? {}
+            : {
+                dueAt: meetingTimestamp(finding.dueAt, "finding due date"),
+                dueEvidence: support(finding.dueEvidence, evidence),
+            }),
+        ...(finding.assignee === undefined
+            ? {}
+            : { assignee: finding.assignee, assigneeEvidence: support(finding.assigneeEvidence, evidence) }),
+    };
+};
+/** A date's or assignee's support: references the finding's own evidence cites. */
+export const support = (value, evidence) => {
+    if (!Array.isArray(value) ||
+        value.length < 1 ||
+        value.length > 8 ||
+        value.some((ref) => typeof ref !== "string" || !evidence.some((item) => item.reference === ref)))
+        return invalid("date and assignee support must cite the finding's evidence");
+    return [...new Set(value)].sort();
+};
+/** A batch's envelope — schema version, key, extractor — around 1–`most` findings each `one` checks. */
+export const validateBatch = (input, rules, most, one) => {
     if (!input || typeof input !== "object" || Buffer.byteLength(JSON.stringify(input), "utf8") > 65536)
         return invalid(`${rules.plural} take at most 65536 UTF-8 bytes`);
     fields(input, ["schemaVersion", "key", "extractor", "findings"], rules.singular);
     if (input.schemaVersion !== 1 ||
         !Array.isArray(input.findings) ||
         input.findings.length < 1 ||
-        input.findings.length > 16)
-        return invalid(`schemaVersion 1 takes 1–16 ${rules.plural}`);
+        input.findings.length > most)
+        return invalid(`schemaVersion 1 takes 1–${most} ${rules.plural}`);
     const key = text(input.key, 64);
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_.:-]*$/.test(key))
         return invalid("a findings key uses letters, digits, dot, colon, underscore or hyphen");
     const ids = new Set();
-    const findings = input.findings.map((finding) => {
-        if (!finding || typeof finding !== "object")
-            return invalid("a finding is an object");
-        const id = text(finding.id, 64);
-        if (!/^[a-zA-Z0-9][a-zA-Z0-9_.:-]*$/.test(id) || ids.has(id))
-            return invalid("finding IDs must be unique simple keys");
-        ids.add(id);
-        const project = finding.project === undefined && rules.anySubject ? undefined : text(finding.project, 64);
-        if (project !== undefined && !/^project:[1-9]\d*$/.test(project))
-            return invalid("a finding names a project reference");
-        if (finding.subject !== undefined && (!rules.anySubject || !SUBJECT.test(text(finding.subject, 80))))
-            return invalid("a finding's subject is a person:, organization:, task: or project: reference");
-        if (finding.kind === "task" && project === undefined)
-            return invalid("a task finding names the project the task goes in");
-        if (!Array.isArray(finding.evidence) || finding.evidence.length < 1 || finding.evidence.length > 8)
-            return invalid(`a finding requires 1–8 cited ${rules.cited}s`);
-        const evidence = finding.evidence
-            .map((item) => {
-            if (!item || typeof item !== "object")
-                return invalid("finding evidence is a reference and fingerprint");
-            fields(item, ["reference", "fingerprint"], rules.singular);
-            if (typeof item.reference !== "string" || typeof item.fingerprint !== "string")
-                return invalid("evidence requires a reference and fingerprint");
-            const reference = rules.reference(item.reference);
-            if (!/^[a-f0-9]{64}$/.test(item.fingerprint))
-                return invalid(`finding evidence requires exact ${rules.cited} references and fingerprints`);
-            return { reference, fingerprint: item.fingerprint };
-        })
-            .sort((a, b) => a.reference.localeCompare(b.reference));
-        if (new Set(evidence.map((item) => item.reference)).size !== evidence.length)
-            return invalid(`duplicate evidence ${rules.cited}`);
-        const base = {
-            id,
-            ...(project === undefined ? {} : { project }),
-            ...(finding.subject === undefined ? {} : { subject: finding.subject }),
-            evidence,
-        };
-        if (finding.kind === "fact") {
-            fields(finding, ["id", "project", "subject", "evidence", "kind", "type", "statement"], rules.singular);
-            if (finding.type === "payment")
-                return invalid("a payment is a finding of kind payment; money is a payments row, not a fact");
-            if (!FACT_TYPES.includes(finding.type))
-                return invalid("unknown fact finding type");
-            return { ...base, kind: "fact", type: finding.type, statement: text(finding.statement, 2000) };
-        }
-        if (finding.kind === "payment" && rules.payments) {
-            fields(finding, ["id", "project", "subject", "evidence", "kind", "statement", "payment", "supersedes"], rules.singular);
-            if (finding.supersedes !== undefined && !/^invoice:[1-9]\d*$/.test(String(finding.supersedes)))
-                return invalid("a payment finding supersedes an invoice: reference, the expected payment it settles or voids");
-            const payment = validatePayment(finding.payment);
-            if (payment.state === "expected" && finding.supersedes !== undefined)
-                return invalid("an expected payment supersedes nothing; a paid or cancelled one supersedes its invoice");
-            if (payment.state === "cancelled" && finding.supersedes === undefined)
-                return invalid("a cancelled payment names the invoice: it cancels in supersedes");
-            if (payment.state === "expected" && !/^(person|organization):/.test(payment.counterparty ?? ""))
-                return invalid("an expected payment becomes an invoice, which names its counterparty as a person: or organization:");
-            return {
-                ...base,
-                kind: "payment",
-                ...(finding.statement === undefined ? {} : { statement: text(finding.statement, 2000) }),
-                payment,
-                ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
-            };
-        }
-        if (finding.kind !== "task")
-            return invalid(`a finding is a fact${rules.payments ? ", payment" : ""} or task`);
-        fields(finding, [
-            "id",
-            "project",
-            "evidence",
-            "kind",
-            "type",
-            "title",
-            "reason",
-            "commitment",
-            "dueAt",
-            "dueEvidence",
-            "assignee",
-            "assigneeEvidence",
-        ], rules.singular);
-        if (!TASK_TYPES.includes(finding.type))
-            return invalid("a task finding type is bug, chore or feature");
-        if (!["explicit", "inferred"].includes(finding.commitment))
-            return invalid("task commitment must be explicit or inferred");
-        const support = (value) => {
-            if (!Array.isArray(value) ||
-                value.length < 1 ||
-                value.length > 8 ||
-                value.some((ref) => typeof ref !== "string" || !evidence.some((item) => item.reference === ref)))
-                return invalid("date and assignee support must cite the finding's evidence");
-            return [...new Set(value)].sort();
-        };
-        if ((finding.dueAt === undefined) !== (finding.dueEvidence === undefined) ||
-            (finding.assignee === undefined) !== (finding.assigneeEvidence === undefined))
-            return invalid("optional dates and assignees require their supporting evidence");
-        if (finding.assignee !== undefined &&
-            (typeof finding.assignee !== "string" || !/^person:[1-9]\d*$/.test(finding.assignee)))
-            return invalid("an assignee must be a person reference");
-        return {
-            ...base,
-            kind: "task",
-            type: finding.type,
-            title: text(finding.title, 300),
-            reason: text(finding.reason, 2000),
-            commitment: finding.commitment,
-            ...(finding.dueAt === undefined
-                ? {}
-                : { dueAt: meetingTimestamp(finding.dueAt, "finding due date"), dueEvidence: support(finding.dueEvidence) }),
-            ...(finding.assignee === undefined
-                ? {}
-                : { assignee: finding.assignee, assigneeEvidence: support(finding.assigneeEvidence) }),
-        };
-    });
+    const findings = input.findings.map((finding) => one(finding, ids));
     return { schemaVersion: 1, key, extractor: text(input.extractor, 200), findings };
 };
+export const validateFindings = (input, rules) => validateBatch(input, rules, 16, (finding, ids) => validateFinding(finding, rules, ids));
+export const findingText = (value, limit) => text(value, limit);
+export const findingFields = (value, allowed, noun) => fields(value, allowed, noun);
 export const findingFingerprint = ({ id: _id, ...finding }) => findingHash(finding);

package/dist/meetings/index.d.ts

@@ -9,7 +9,7 @@ export { entryInWindow, eventChange } from "./event-store.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";
-export { type Finding, type FindingsInput, type FindingsReceipt, type FindingsRules, findingFingerprint, type PaymentFinding, validateFindings, } from "./findings-rules.js";
+export { type FactFinding, type Finding, type FindingsInput, type FindingsReceipt, type FindingsRules, findingFields, findingFingerprint, findingId, findingText, type PaymentFinding, type TaskFinding, validateBatch, validateFinding, validateFindings, validEvidence, } from "./findings-rules.js";
 export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, type MeetingIssue, type MeetingItem, type MeetingOwner, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
@@ -53,6 +53,7 @@ export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validat
 export type { MeetingSource, SourceParticipant } from "./source.js";
 export { aggregateMeetingStats, type MeetingSpeakerStats, type MeetingStats, type MeetingStatsInput, type MeetingStatsRow, type MeetingStatsSelection, type MeetingStatsStore, type MeetingWeekStats, } from "./stats.js";
 export type { ChatInput, ContractCase, EventCandidateFilter, IdentityInput, MeetingDetails, MeetingFilter, MeetingHitSource, MeetingInput, MeetingSave, MeetingStore, NewRecord, ParticipantInput, SearchHit, TranscriptInput, TranscriptLanguageFill, TranscriptRowInput, } from "./store.js";
+export { meetingTimestamp } from "./timestamp.js";
 export type { MeetingTranscriptReceiptStore, MeetingTranscriptStore, TranscriptAppend, TranscriptAppendReceipt, UnlinkedTranscriptInput, } from "./transcript-store.js";
 export { parseTranscriptText, TranscriptTextError, type TranscriptTextHeader } from "./transcript-text.js";
 export { type MeetingMediaDescriptor, type MeetingRecognitionSegment, type MeetingTranscriptionContext, type MeetingTranscriptionOptions, type MeetingTranscriptionReceipt, type MeetingTranscriptionSource, transcribeMeeting, } from "./transcription.js";

package/dist/meetings/index.js

@@ -6,7 +6,7 @@ export { entryInWindow, eventChange } from "./event-store.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, serializeVtt, } from "./export.js";
 export { findingHash, MEETING_FINDINGS_KIND, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";
-export { findingFingerprint, validateFindings, } from "./findings-rules.js";
+export { findingFields, findingFingerprint, findingId, findingText, validateBatch, validateFinding, validateFindings, validEvidence, } from "./findings-rules.js";
 export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
@@ -39,6 +39,7 @@ export { validateMeetingSeriesHistory, } from "./series-history.js";
 export { createMeetingSeriesInventoryReader } from "./series-inventory.js";
 export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validation.js";
 export { aggregateMeetingStats, } from "./stats.js";
+export { meetingTimestamp } from "./timestamp.js";
 export { parseTranscriptText, TranscriptTextError } from "./transcript-text.js";
 export { transcribeMeeting, } from "./transcription.js";
 export { createUpcomingMeetingReader } from "./upcoming.js";

package/dist/sends/index.d.ts

@@ -3,6 +3,7 @@ export { type FloodDeadline, FloodMemory, type FloodState, FROZEN_HOLD_MS, flood
 export { type Asker, type GuardRequest, guardFor, type SendGuard, type SendGuardOptions, sendGuard, sharedJournal, } from "./guard.js";
 export { currentOperation, guardedWrite, type Operated } from "./guarded.js";
 export { type AccountAction, type ChatAction, type SendEntry, SendJournal, type SendKind, type SendOutcome, sendsPathFor, } from "./journal.js";
+export { type KeyedGuard, keyedGuard } from "./keyed-guard.js";
 export { DEFAULT_PACE, type PaceRate, Pacer, pacePathFor } from "./pace.js";
 export { assertOverridesTighten, CEILING_KEY, COMMAND_PATH_KEY, DEFAULT_PERMISSIONS, keyForCommand, keyForWrite, LEVELS, type Level, layerPermissions, levelFor, type PermissionKey, permissionOverrides, readKeysForCommand, skipFlagFor, WRITE_KEYS, } from "./permissions.js";
 export { type Recipient, RecipientList, recipientsPathFor } from "./recipients.js";

package/dist/sends/index.js

@@ -2,6 +2,7 @@ export { FloodMemory, FROZEN_HOLD_MS, floodPathFor, LIMITED_HOLD_MS, } from "./f
 export { guardFor, sendGuard, sharedJournal, } from "./guard.js";
 export { currentOperation, guardedWrite } from "./guarded.js";
 export { SendJournal, sendsPathFor, } from "./journal.js";
+export { keyedGuard } from "./keyed-guard.js";
 export { DEFAULT_PACE, Pacer, pacePathFor } from "./pace.js";
 export { assertOverridesTighten, CEILING_KEY, COMMAND_PATH_KEY, DEFAULT_PERMISSIONS, keyForCommand, keyForWrite, LEVELS, layerPermissions, levelFor, permissionOverrides, readKeysForCommand, skipFlagFor, WRITE_KEYS, } from "./permissions.js";
 export { RecipientList, recipientsPathFor } from "./recipients.js";

package/dist/sends/keyed-guard.d.ts

@@ -0,0 +1,12 @@
+import type { Asker, GuardRequest, SendGuard } from "./guard.js";
+import type { Level, PermissionKey } from "./permissions.js";
+export type KeyedGuard = SendGuard & {
+    /** Refuses the write when one of its keys denies it or is read-only; asks nothing. */
+    refuse(request: GuardRequest): void;
+};
+/**
+ * A guard over a write's main key and its extra keys. A key that refuses refuses before anything is asked, so nobody
+ * answers yes to a write that a stricter key then stops, and one question names every key at `ask`. The extra keys are
+ * probed as reads, never journaled or counted: the write itself holds the one journal line.
+ */
+export declare const keyedGuard: (build: (ask: Asker) => SendGuard, ask: Asker, levelOf: (key: PermissionKey) => Level, extra: readonly PermissionKey[]) => KeyedGuard;

package/dist/sends/keyed-guard.js

@@ -0,0 +1,49 @@
+/**
+ * A guard over a write's main key and its extra keys. A key that refuses refuses before anything is asked, so nobody
+ * answers yes to a write that a stricter key then stops, and one question names every key at `ask`. The extra keys are
+ * probed as reads, never journaled or counted: the write itself holds the one journal line.
+ */
+export const keyedGuard = (build, ask, levelOf, extra) => {
+    let question;
+    let answered = false;
+    const guard = build(async (key, request) => {
+        if (answered)
+            return;
+        await ask(question || key, request);
+        answered = true;
+    });
+    const probes = new WeakMap();
+    const all = (request) => {
+        let found = probes.get(request);
+        if (!found) {
+            found = extra.map((key) => ({ chatId: null, kind: "read", key }));
+            probes.set(request, found);
+        }
+        return [request, ...found];
+    };
+    const levelOfRequest = ({ key }) => levelOf(key ?? "");
+    const refuse = (request) => {
+        const refused = all(request).find((one) => ["deny", "readonly"].includes(levelOfRequest(one)));
+        if (refused)
+            guard.check(refused, { reserve: false });
+    };
+    return {
+        refuse,
+        ask: async (request) => {
+            refuse(request);
+            question = all(request)
+                .filter((one) => levelOfRequest(one) === "ask")
+                .map(({ key }) => key)
+                .join(" and ");
+            for (const one of all(request))
+                await guard.ask?.(one);
+        },
+        check: (request, options) => {
+            for (const one of all(request).slice(1))
+                guard.check(one, { reserve: false });
+            guard.check(request, options);
+        },
+        ...(guard.reserve ? { reserve: guard.reserve } : {}),
+        record: (entry) => guard.record(entry),
+    };
+};

package/dist/services/proposals/kinds/mail-findings.d.ts

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

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

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

package/dist/services/proposals/registry.js

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

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

@@ -64,6 +64,8 @@ export interface ProposalKind {
     readonly stored?: readonly string[];
     /** Whether its proposals have parts decided on their own, as a findings batch has findings. */
     readonly parts?: boolean;
+    /** Only the owner decides it, whatever the host's `agent_decisions` says. */
+    readonly ownerOnly?: boolean;
     /** Bounded: at most `offset + limit` rows, newest first. */
     list(filter: ProposalFilter): Promise<ProposalRow[]>;
     get(id: string): Promise<ProposalRow>;

package/dist/store/decisions.d.ts

@@ -22,7 +22,7 @@ export type Decider = "owner" | {
     reason: string;
 };
 export interface DecisionPolicy {
-    /** The host's `agent_decisions`: `false` keeps every decision with the owner. */
+    /** The host's `agent_decisions`: off unless the owner sets it to `true`; off keeps every decision with the owner. */
     agentDecisions: boolean;
     /** A rule scorer's proposal is the owner's alone to decide. */
     ruleProposalsOwnerOnly: boolean;

package/dist/store/decisions.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-export const DEFAULT_DECISION_POLICY = { agentDecisions: true, ruleProposalsOwnerOnly: true };
+export const DEFAULT_DECISION_POLICY = { agentDecisions: false, ruleProposalsOwnerOnly: true };
 /**
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.

package/dist/store/index.d.ts

@@ -16,6 +16,7 @@ export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./dr
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, type EvidenceFindingsBatch, type EvidenceFindingsDecider, type EvidenceFindingsReceipt, type EvidenceFindingsStore, validateEvidenceFindings, } from "./evidence-findings.js";
 export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
+export { MAIL_FINDINGS_KIND, type MailFindingsBatch, type MailFindingsStore } from "./mail-findings.js";
 export type { MeetingFindingsBatch, MeetingFindingsStore } from "./meeting-findings.js";
 export { MIGRATIONS, type Migration, migrate } from "./migrations.js";
 export { openCache } from "./open.js";

package/dist/store/index.js

@@ -8,6 +8,7 @@ export { applyDocumentTransfer, previewDocumentTransfer } from "./document-trans
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
 export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
+export { MAIL_FINDINGS_KIND } from "./mail-findings.js";
 export { MIGRATIONS, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
 export { storePath } from "./path.js";

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

@@ -0,0 +1,51 @@
+import type { MailFindingsInput } from "../mail/findings.js";
+import type { FindingOutcome, FindingsReceipt } from "../meetings/index.js";
+import type { Decider } from "./decisions.js";
+import type { AccountKey } from "./types.js";
+export declare const MAIL_FINDINGS_KIND = "mail_findings";
+export interface MailFindingsBatch {
+    id: string;
+    account: AccountKey;
+    input: MailFindingsInput;
+    fingerprint: string;
+    status: "proposed" | "reviewed";
+    author: {
+        type: "person" | "bot";
+        id: string;
+        name: string | null;
+        kind: "agent" | "rule" | null;
+    };
+    decidedBy: {
+        type: "person" | "bot";
+        id: string;
+    } | null;
+    decidedAt: string | null;
+    previous: FindingOutcome[];
+    receipt: FindingsReceipt | null;
+}
+/**
+ * What an agent read in new mail — tasks, task updates, facts, memories, links, new contacts — cited and staged for
+ * the owner, one batch per mailbox and run. Only the owner decides one: an agent's mail proposal never becomes the
+ * owner's word without him.
+ */
+export interface MailFindingsStore {
+    stage(account: AccountKey, input: MailFindingsInput, agent: {
+        bot: string;
+        model?: string;
+    }): Promise<MailFindingsBatch>;
+    get(id: string): Promise<MailFindingsBatch>;
+    list(options?: {
+        account?: AccountKey;
+        status?: "proposed" | "reviewed";
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: MailFindingsBatch[];
+        hasMore: boolean;
+    }>;
+    review(id: string, input: {
+        fingerprint: string;
+        accept: string[];
+        by: Decider;
+    }): Promise<MailFindingsBatch>;
+}

package/dist/store/mail-findings.js

@@ -0,0 +1 @@
+export const MAIL_FINDINGS_KIND = "mail_findings";