@wirecat/cli-core 0.362.0 → 0.364.0

package/CHANGELOG.md

@@ -7,6 +7,33 @@ shape of this file.
 
 ## Unreleased
 
+## 0.364.0 — 19.10.2026
+
+### Fixed
+
+- **More warnings in `serve`'s log now carry a code.** A flood wait (`flood_wait`, with `counts.seconds`),
+  a long wait for the profile's pace (`pace_wait`, with `counts.seconds`), a held account (`account_frozen`,
+  `account_limited`, `account_banned`), a wait that could not be remembered (`wait_not_remembered`), a send missing
+  from the send journal (`send_not_journaled`), a recipient list that could not be re-keyed or read
+  (`recipients_not_rekeyed`, `recipients_not_read`), the reply audience warnings (`audience_person_on_both_lists`,
+  `audience_chat_on_both_lists`, `audience_allow_unused`, `audience_allow_empty`) and the reply template warnings
+  (`reply_legacy_placeholders`, `reply_legacy_may_reword`, `reply_template_warning`) each log their code and
+  operation instead of a bare `serve.warning`. The record never holds the sentence, a chat id, a name or an error
+  message; the sentence at a terminal is unchanged.
+
+## 0.363.0 — 19.10.2026
+
+### Added
+
+- **`store.evidenceFindings`: cited facts and follow-ups about one project from stored messages, mail and
+  documents, staged by an agent and reviewed** — reviewed meeting findings' rules over any stored reference. A
+  review is the owner's or an agent's deciding for the owner (`by: { bot, reason }`), recorded in the receipt.
+  Evidence is checked against the current text by fingerprint: project evidence items carry `fingerprint`, and
+  `store.contextRecords.read(ref)` reproduces it. Meeting and evidence findings share their validation and review
+  code (`validateFindings`); meeting findings behave as before. A host reads a staged batch from snake_case JSON
+  with `parseEvidenceFindingsJson` from `./cli`. `./services` also exports `contextEvidenceFingerprint`,
+  `ContextRecordReader` and `excerpt`, for a host that shows a cited record's text.
+
 ## 0.362.0 — 19.10.2026
 
 ### Changed — may break callers

package/dist/cli/index.d.ts

@@ -65,7 +65,7 @@ export { bufferedInput, type InputPolicy, inputPolicy, MAX_BUFFERED_INPUT, MAX_S
 export { answerFields, checkJson, type EntityFields, entityFields, type JsonFieldsResolver, type JsonRequest, liftJson, } from "./json-fields.js";
 export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTerms, pagedList, pageOf, type QueryWords, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
 export { addMeetingBatchCommand, formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
-export { parseMeetingFindingsJson } from "./meeting-findings-input.js";
+export { parseEvidenceFindingsJson, parseMeetingFindingsJson } from "./meeting-findings-input.js";
 export { meetingPreparationAnswer } from "./meeting-preparation-answer.js";
 export { addMeetingPreparationCommand } from "./meeting-preparation-command.js";
 export { type MeetingPreparationReader, meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";

package/dist/cli/index.js

@@ -60,7 +60,7 @@ export { bufferedInput, inputPolicy, MAX_BUFFERED_INPUT, MAX_SECRET_INPUT, provi
 export { answerFields, checkJson, entityFields, liftJson, } from "./json-fields.js";
 export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTerms, pagedList, pageOf, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
 export { addMeetingBatchCommand, formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
-export { parseMeetingFindingsJson } from "./meeting-findings-input.js";
+export { parseEvidenceFindingsJson, parseMeetingFindingsJson } from "./meeting-findings-input.js";
 export { meetingPreparationAnswer } from "./meeting-preparation-answer.js";
 export { addMeetingPreparationCommand } from "./meeting-preparation-command.js";
 export { meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";

package/dist/cli/meeting-findings-input.d.ts

@@ -1,2 +1,3 @@
-import { type MeetingFindingsInput } from "../meetings/index.js";
+import { type FindingsInput, type MeetingFindingsInput } from "../meetings/index.js";
 export declare const parseMeetingFindingsJson: (text: string) => MeetingFindingsInput;
+export declare const parseEvidenceFindingsJson: (text: string) => FindingsInput;

package/dist/cli/meeting-findings-input.js

@@ -1,24 +1,25 @@
 import { CliError } from "@wirecat/cli-base";
 import { validateMeetingFindings } from "../meetings/index.js";
+import { validateEvidenceFindings } from "../store/evidence-findings.js";
 const keys = {
     schema_version: "schemaVersion",
     due_at: "dueAt",
     due_evidence: "dueEvidence",
     assignee_evidence: "assigneeEvidence",
 };
-export const parseMeetingFindingsJson = (text) => {
+const parseFindingsJson = (text, label, validate) => {
     if (Buffer.byteLength(text, "utf8") > 65536)
-        throw new CliError("validation_error", "meeting findings take at most 65536 UTF-8 bytes");
+        throw new CliError("validation_error", `${label} take at most 65536 UTF-8 bytes`);
     let raw;
     try {
         raw = JSON.parse(text);
     }
     catch {
-        throw new CliError("validation_error", "meeting findings input must be valid JSON");
+        throw new CliError("validation_error", `${label} input must be valid JSON`);
     }
     const decode = (value, depth = 0) => {
         if (depth > 16)
-            throw new CliError("validation_error", "meeting findings JSON is nested too deeply");
+            throw new CliError("validation_error", `${label} JSON is nested too deeply`);
         if (Array.isArray(value))
             return value.map((item) => decode(item, depth + 1));
         if (value === null || typeof value !== "object")
@@ -26,13 +27,15 @@ export const parseMeetingFindingsJson = (text) => {
         const output = {};
         for (const [key, item] of Object.entries(value)) {
             if (/[A-Z]/.test(key))
-                throw new CliError("validation_error", "meeting findings JSON fields use snake_case");
+                throw new CliError("validation_error", `${label} JSON fields use snake_case`);
             const name = keys[key] ?? key;
             if (Object.hasOwn(output, name))
-                throw new CliError("validation_error", "duplicate meeting findings field");
+                throw new CliError("validation_error", `duplicate ${label} field`);
             Object.defineProperty(output, name, { value: decode(item, depth + 1), enumerable: true });
         }
         return output;
     };
-    return validateMeetingFindings(decode(raw));
+    return validate(decode(raw));
 };
+export const parseMeetingFindingsJson = (text) => parseFindingsJson(text, "meeting findings", validateMeetingFindings);
+export const parseEvidenceFindingsJson = (text) => parseFindingsJson(text, "evidence findings", validateEvidenceFindings);

package/dist/cli/messenger/context.d.ts

@@ -1,7 +1,7 @@
 import type { Command } from "commander";
 import type { AdminRight, GroupSettingKey, Id, Message, PollVote, PrivacyKey, Provider } from "../../domain/models.js";
 import type { MessengerAdapter } from "../../ports/messenger.js";
-import type { EventSink } from "../../runs/events.js";
+import type { EventSink, Warn } from "../../runs/events.js";
 import { type Asker, type SendGuard } from "../../sends/guard.js";
 import { type PaceRate } from "../../sends/pace.js";
 import { type PermissionKey } from "../../sends/permissions.js";
@@ -186,7 +186,7 @@ export interface Messenger extends ServiceMessenger {
      * `ask`, when given, answers a write at level `ask` instead of the messenger's own prompt: the MCP
      * server has no terminal to ask at.
      */
-    guard?: (command: Command, settings: Settings, warn: (message: string) => void, ask?: Asker) => SendGuard;
+    guard?: (command: Command, settings: Settings, warn: Warn, ask?: Asker) => SendGuard;
     /** The permission key of one of this CLI's own commands, when `keyForCommand` does not know it. */
     permissionKey?: PermissionKeyOf;
     /** The CLI's SKILL.md, which the MCP server also serves as `<command>://skill`. */

package/dist/cli/messenger/context.js

@@ -169,7 +169,11 @@ const rekeyRecipients = async (app, profile, env, warn, from, to) => {
         await new RecipientList(recipientsPathFor(app, profile, env), app.command, REKEY_LOCK_WAIT_MS).rekey(from, to);
     }
     catch (error) {
-        warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`);
+        warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`, {
+            event: "warning",
+            code: "recipients_not_rekeyed",
+            operation: "recipients.rekey",
+        });
     }
 };
 const waitsOf = (command) => {
@@ -344,7 +348,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
         base.renderer.warn(`permissions.${key} names no command and does nothing — \`config unset permissions.${key}\``);
     }
     // Read when warning, not now: serve swaps the renderer's methods for log records after this.
-    const warn = (text) => base.renderer.warn(text);
+    const warn = (text, warning) => base.renderer.warn(text, warning);
     const accountFor = () => {
         const account = messenger.accountOf?.(command) ?? recalledAccount(app, provider, profile, base.env);
         if (!account)

package/dist/cli/messenger/flooded.d.ts

@@ -1,4 +1,5 @@
 import { type MessengerAdapter } from "../../ports/messenger.js";
+import { type Warn } from "../../runs/events.js";
 import { type FloodMemory } from "../../sends/flood.js";
 import type { Pacer } from "../../sends/pace.js";
 /**
@@ -9,6 +10,6 @@ import type { Pacer } from "../../sends/pace.js";
  */
 export declare const flooded: (messenger: MessengerAdapter, memory: FloodMemory, { name, warn, pacer }: {
     name: string;
-    warn: (message: string) => void;
+    warn: Warn;
     pacer?: Pacer;
 }) => MessengerAdapter;

package/dist/cli/messenger/flooded.js

@@ -19,12 +19,16 @@ const chatOf = (args) => typeof args[0] === "string" && /^-?\d+$/.test(args[0])
  * waits for its turn in the profile's pace, and a wait the messenger asks for holds the whole profile.
  */
 export const flooded = (messenger, memory, { name, warn, pacer }) => {
-    const kept = async (what) => {
+    const kept = async (operation, what) => {
         try {
             await what();
         }
         catch (error) {
-            warn(`could not remember ${name}'s wait (${error instanceof Error ? error.message : String(error)})`);
+            warn(`could not remember ${name}'s wait (${error instanceof Error ? error.message : String(error)})`, {
+                event: "warning",
+                code: "wait_not_remembered",
+                operation,
+            });
         }
     };
     const noted = async (operation, chatId, error) => {
@@ -33,13 +37,17 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
         const details = error.details ?? {};
         const standing = details.standing;
         if (standing && BLOCKING.has(standing.state)) {
-            await kept(() => {
+            await kept(operation, () => {
                 const block = memory.block({
                     state: standing.state,
                     hint: standing.hint ?? error.message,
                     ...(standing.until ? { until: standing.until } : {}),
                 });
-                warn(`writes from this profile are held ${holdEnd(block)}: ${block.hint}`);
+                warn(`writes from this profile are held ${holdEnd(block)}: ${block.hint}`, {
+                    event: "warning",
+                    code: `account_${block.state}`,
+                    operation,
+                });
             });
             return;
         }
@@ -47,23 +55,28 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
         if (error.code !== "rate_limited" || details.remembered === true || !Number.isFinite(waitMs) || waitMs <= 0)
             return;
         const providerError = providerErrorKey(details.provider_error);
-        await kept(() => {
+        await kept(operation, () => {
             const deadline = memory.remember({
                 operation,
                 ...(chatId ? { chatId } : {}),
                 ...(providerError ? { providerError } : {}),
                 waitMs,
             });
-            warn(`${name} asked to wait before ${operation} again — until ${deadline.until}`);
+            warn(`${name} asked to wait before ${operation} again — until ${deadline.until}`, {
+                event: "warning",
+                code: "flood_wait",
+                operation,
+                counts: { seconds: Math.ceil(waitMs / 1000) },
+            });
         });
         if (pacer)
-            await kept(() => pacer.holdFor(waitMs));
+            await kept(operation, () => pacer.holdFor(waitMs));
     };
-    const turn = async () => {
+    const turn = async (operation) => {
         if (!pacer)
             return;
         let at = Date.now();
-        await kept(async () => {
+        await kept(operation, async () => {
             at = await pacer.reserve();
         });
         const waitMs = at - Date.now();
@@ -72,8 +85,15 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
         if (waitMs > LONGEST_PACE_WAIT_MS) {
             throw new CliError("rate_limited", `${name} asked this profile to wait, ${Math.ceil(waitMs / 1000)} s are left — nothing was sent to ${name}`, { retry_after_ms: waitMs, retry_at: new Date(at).toISOString(), remembered: true });
         }
-        if (waitMs >= ANNOUNCE_WAIT_MS)
-            warn(`waiting ${Math.ceil(waitMs / 1000)} s to keep this profile's pace with ${name}`);
+        if (waitMs >= ANNOUNCE_WAIT_MS) {
+            const seconds = Math.ceil(waitMs / 1000);
+            warn(`waiting ${seconds} s to keep this profile's pace with ${name}`, {
+                event: "warning",
+                code: "pace_wait",
+                operation,
+                counts: { seconds },
+            });
+        }
         await new Promise((resolve) => setTimeout(resolve, waitMs));
     };
     return throughWrapper(messenger, {}, (operation, call) => {
@@ -101,7 +121,7 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
                     ...(owed.providerError ? { provider_error: owed.providerError } : {}),
                 });
             }
-            await turn();
+            await turn(operation);
             try {
                 return await call(...args);
             }

package/dist/cli/messenger/replies-command.js

@@ -43,8 +43,9 @@ export const repliesCommand = (messenger) => {
         if (rules.length === 0) {
             renderer.note(`no reply rules yet — they live in ${path}`);
         }
-        for (const warning of audienceWarnings(audience))
-            renderer.warn(warning);
+        const warn = renderer.warn;
+        for (const { text, warning } of audienceWarnings(audience))
+            warn(text, warning);
         const found = await context.withStore((store, account) => dryRun(store, account, rules, {
             since,
             audience,
@@ -103,8 +104,9 @@ export const repliesCommand = (messenger) => {
         const { settings, renderer, env } = context;
         const { rules, audience } = readReplies(repliesPathFor(messenger.app, settings.profile, env), messenger.provider);
         const warnings = audienceWarnings(audience);
-        for (const warning of warnings)
-            renderer.warn(warning);
+        const warn = renderer.warn;
+        for (const { text, warning } of warnings)
+            warn(text, warning);
         const state = readRepliesState(repliesStatePathFor(messenger.app, settings.profile, env));
         const level = levelFor(settings.permissions ?? {}, "replies.send").level;
         if (level !== "allow")
@@ -117,7 +119,7 @@ export const repliesCommand = (messenger) => {
                 allow: audience.allow.people.length + audience.allow.chats.length,
                 deny: audience.deny.people.length + audience.deny.chats.length,
             },
-            warnings,
+            warnings: warnings.map(({ text }) => text),
             rules: rules.map(({ id, on }) => ({ id, on })),
         }));
     });

package/dist/cli/messenger/replies-edit-command.js

@@ -78,8 +78,9 @@ export const addReplyEditors = (replies, messenger) => {
         const context = messengerContext(this, messenger);
         const { settings, renderer, env } = context;
         const answer = editAudience(repliesPathFor(messenger.app, settings.profile, env), messenger.provider, this.opts());
-        for (const warning of audienceWarnings(answer))
-            renderer.warn(warning);
+        const warn = renderer.warn;
+        for (const { text, warning } of audienceWarnings(answer))
+            warn(text, warning);
         renderItem(this, context, answer);
     });
     replies.addCommand(audience);

package/dist/cli/messenger/serve-command.js

@@ -162,9 +162,10 @@ const replying = (context, messenger, since) => {
     // A file that does not read is said on each message instead; it must not stop serve.
     try {
         const { rules, audience } = readReplies(repliesPathFor(app, profile, env), provider);
+        const warn = renderer.warn;
         if (rules.length > 0)
-            for (const warning of audienceWarnings(audience))
-                renderer.warn(warning);
+            for (const { text, warning } of audienceWarnings(audience))
+                warn(text, warning);
     }
     catch { }
     const handle = async (message) => {

package/dist/cli/messenger/serve-relay.d.ts

@@ -85,7 +85,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         officialStats?: boolean;
         tracksMembers?: boolean;
         speechModels?: readonly string[];
-        guard?: (command: Command, settings: import("../settings.js").Settings, warn: (message: string) => void, ask?: import("../../sends/guard.js").Asker) => import("../../sends/guard.js").SendGuard;
+        guard?: (command: Command, settings: import("../settings.js").Settings, warn: import("../../runs/events.js").Warn, ask?: import("../../sends/guard.js").Asker) => import("../../sends/guard.js").SendGuard;
         permissionKey?: import("../permission-keys.js").PermissionKeyOf;
         skill?: URL;
         diagnose?: (command: Command, context: import("../context.js").BaseContext) => Promise<Record<string, unknown>>;

package/dist/cli/messenger/stored.js

@@ -461,7 +461,11 @@ const announceStoredChats = async (messenger, store, account, events, warn, reci
         listed = recipientIds?.() ?? [];
     }
     catch (error) {
-        warn(`the messenger was not told the recipient list: ${error instanceof Error ? error.message : String(error)}`);
+        warn(`the messenger was not told the recipient list: ${error instanceof Error ? error.message : String(error)}`, {
+            event: "warning",
+            code: "recipients_not_read",
+            operation: "history.stored_chats",
+        });
     }
     try {
         const opened = await store();

package/dist/context/evidence.d.ts

@@ -63,6 +63,12 @@ export interface ContextIndex {
         documents: number;
     }>;
 }
+/** Changes whenever the cited text, its title or its revision does; a staged finding citing an older one is stale. */
+export declare const contextEvidenceFingerprint: (item: Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision">) => string;
+/** One stored message, email or document as the context reader returns it, by its reference. */
+export interface ContextRecordReader {
+    read(ref: string): Promise<Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision"> | null>;
+}
 export declare const contextCursorScope: (request: Pick<ContextEvidenceRequest, "source" | "query" | "after" | "before">) => string;
 export declare const contextSource: (value: ContextSource) => ContextSource;
 export declare const contextEvidenceRequest: (input: ContextEvidenceRequest) => {

package/dist/context/evidence.js

@@ -1,6 +1,10 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
 export const CONTEXT_SOURCE_KINDS = ["message", "mail", "document", "meeting"];
+/** Changes whenever the cited text, its title or its revision does; a staged finding citing an older one is stale. */
+export const contextEvidenceFingerprint = (item) => createHash("sha256")
+    .update(JSON.stringify(["context-evidence-v1", item.ref, item.title, item.text, item.revision]))
+    .digest("hex");
 export const contextCursorScope = (request) => createHash("sha256")
     .update(JSON.stringify([
     "context-evidence-v1",

package/dist/errors/reasons.js

@@ -18,6 +18,8 @@ const OTHERS = [
     validation("context.read-budget", "the selected context reads exceed their text or request allowance"),
     validation("meeting-findings.stale", "meeting findings changed since they were read; stage a new batch"),
     validation("meeting-findings.dedicated-review", "review meeting findings through the dedicated findings command"),
+    validation("evidence-findings.stale", "evidence findings changed since they were read; stage a new batch"),
+    validation("evidence-findings.dedicated-review", "review evidence findings through the dedicated findings command"),
     validation("document.changed", "the document changed while it was read; nothing was saved"),
     ["document.not-imported", "not_found", "the document is not imported in this source account"],
     ["extraction.invalid-proposals", "invalid_response", "the model's memory proposals could not be used"],

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

@@ -0,0 +1,60 @@
+import { MEETING_FACT_TYPES as FACT_TYPES } from "./meeting-context.js";
+declare const TASK_TYPES: readonly ["bug", "feature", "chore"];
+export interface FindingEvidence {
+    reference: string;
+    fingerprint: string;
+}
+interface FindingBase {
+    id: string;
+    project: string;
+    evidence: FindingEvidence[];
+}
+export interface FactFinding extends FindingBase {
+    kind: "fact";
+    type: (typeof FACT_TYPES)[number];
+    statement: string;
+}
+export interface TaskFinding extends FindingBase {
+    kind: "task";
+    type: (typeof TASK_TYPES)[number];
+    title: string;
+    reason: string;
+    commitment: "explicit" | "inferred";
+    dueAt?: string;
+    dueEvidence?: string[];
+    assignee?: string;
+    assigneeEvidence?: string[];
+}
+export type Finding = FactFinding | TaskFinding;
+export interface FindingsInput {
+    schemaVersion: 1;
+    key: string;
+    extractor: string;
+    findings: Finding[];
+}
+export interface FindingOutcome {
+    id: string;
+    fingerprint: string;
+    status: "accepted" | "rejected";
+    reference: string | null;
+    reused: boolean;
+}
+export interface FindingsReceipt {
+    previewFingerprint: string;
+    accepted: string[];
+    items: FindingOutcome[];
+}
+export declare const findingHash: (value: unknown) => string;
+/** What differs between findings kinds: their wording and what one cited reference must look like. */
+export interface FindingsRules {
+    /** "meeting findings" */
+    plural: string;
+    /** "meeting finding" */
+    singular: string;
+    /** "cue" */
+    cited: string;
+    reference: (raw: string) => string;
+}
+export declare const validateFindings: (input: FindingsInput, rules: FindingsRules) => FindingsInput;
+export declare const findingFingerprint: ({ id: _id, ...finding }: Finding) => string;
+export {};

package/dist/meetings/findings-rules.js

@@ -0,0 +1,117 @@
+import { createHash } from "node:crypto";
+import { CliError } from "@wirecat/cli-base";
+import { MEETING_FACT_TYPES as FACT_TYPES } from "./meeting-context.js";
+import { meetingTimestamp } from "./timestamp.js";
+const TASK_TYPES = ["bug", "feature", "chore"];
+const invalid = (message) => {
+    throw new CliError("validation_error", message);
+};
+const text = (value, limit) => {
+    if (typeof value !== "string" || !value.trim() || value.includes("\0") || value.length > limit)
+        return invalid(`finding text must contain 1–${limit} characters without NUL`);
+    return value.trim();
+};
+export const findingHash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const fields = (value, allowed, noun) => {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        invalid(`unknown ${noun} field`);
+};
+export const validateFindings = (input, rules) => {
+    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}`);
+    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 = text(finding.project, 64);
+        if (!/^project:[1-9]\d*$/.test(project))
+            return invalid("a finding names a project reference");
+        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, evidence };
+        if (finding.kind === "fact") {
+            fields(finding, ["id", "project", "evidence", "kind", "type", "statement"], rules.singular);
+            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 !== "task")
+            return invalid("a finding is a fact 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) }),
+        };
+    });
+    return { schemaVersion: 1, key, extractor: text(input.extractor, 200), findings };
+};
+export const findingFingerprint = ({ id: _id, ...finding }) => findingHash(finding);

package/dist/meetings/findings.d.ts

@@ -1,51 +1,13 @@
-import { MEETING_FACT_TYPES } from "./meeting-context.js";
-declare const MEETING_TASK_TYPES: readonly ["bug", "feature", "chore"];
+import { type FactFinding, type Finding, type FindingsInput, type FindingsReceipt, findingFingerprint } from "./findings-rules.js";
+export type { FindingEvidence, FindingOutcome } from "./findings-rules.js";
+export { findingHash } from "./findings-rules.js";
 export declare const MEETING_FINDINGS_KIND = "meeting_findings";
-export interface FindingEvidence {
-    reference: string;
-    fingerprint: string;
-}
-interface FindingBase {
-    id: string;
-    project: string;
-    evidence: FindingEvidence[];
-}
-export interface MeetingFactFinding extends FindingBase {
-    kind: "fact";
-    type: (typeof MEETING_FACT_TYPES)[number];
-    statement: string;
-}
-export interface MeetingTaskFinding extends FindingBase {
+export type MeetingFactFinding = FactFinding;
+export type MeetingTaskFinding = Extract<Finding, {
     kind: "task";
-    type: (typeof MEETING_TASK_TYPES)[number];
-    title: string;
-    reason: string;
-    commitment: "explicit" | "inferred";
-    dueAt?: string;
-    dueEvidence?: string[];
-    assignee?: string;
-    assigneeEvidence?: string[];
-}
-export type MeetingFinding = MeetingFactFinding | MeetingTaskFinding;
-export interface MeetingFindingsInput {
-    schemaVersion: 1;
-    key: string;
-    extractor: string;
-    findings: MeetingFinding[];
-}
-export interface FindingOutcome {
-    id: string;
-    fingerprint: string;
-    status: "accepted" | "rejected";
-    reference: string | null;
-    reused: boolean;
-}
-export interface MeetingFindingsReceipt {
-    previewFingerprint: string;
-    accepted: string[];
-    items: FindingOutcome[];
-}
-export declare const findingHash: (value: unknown) => string;
+}>;
+export type MeetingFinding = Finding;
+export type MeetingFindingsInput = FindingsInput;
+export type MeetingFindingsReceipt = FindingsReceipt;
 export declare const validateMeetingFindings: (input: MeetingFindingsInput) => MeetingFindingsInput;
-export declare const meetingFindingFingerprint: ({ id: _id, ...finding }: MeetingFinding) => string;
-export {};
+export declare const meetingFindingFingerprint: typeof findingFingerprint;