@wirecat/cli-core 0.362.0 → 0.364.0

package/dist/meetings/findings.js

@@ -1,119 +1,13 @@
-import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
-import { MEETING_FACT_TYPES } from "./meeting-context.js";
+import { findingFingerprint, validateFindings, } from "./findings-rules.js";
 import { canonicalMeetingReference, parseMeetingReference } from "./reference.js";
-import { meetingTimestamp } from "./timestamp.js";
-const MEETING_TASK_TYPES = ["bug", "feature", "chore"];
+export { findingHash } from "./findings-rules.js";
 export const MEETING_FINDINGS_KIND = "meeting_findings";
-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) => {
-    if (Object.keys(value).some((key) => !allowed.includes(key)))
-        invalid("unknown meeting finding field");
-};
-export const validateMeetingFindings = (input) => {
-    if (!input || typeof input !== "object" || Buffer.byteLength(JSON.stringify(input), "utf8") > 65536)
-        return invalid("meeting findings take at most 65536 UTF-8 bytes");
-    fields(input, ["schemaVersion", "key", "extractor", "findings"]);
-    if (input.schemaVersion !== 1 ||
-        !Array.isArray(input.findings) ||
-        input.findings.length < 1 ||
-        input.findings.length > 16)
-        return invalid("schemaVersion 1 takes 1–16 meeting findings");
-    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 cues");
-        const evidence = finding.evidence
-            .map((item) => {
-            if (!item || typeof item !== "object")
-                return invalid("finding evidence is a reference and fingerprint");
-            fields(item, ["reference", "fingerprint"]);
-            if (typeof item.reference !== "string" || typeof item.fingerprint !== "string")
-                return invalid("evidence requires a reference and fingerprint");
-            const reference = canonicalMeetingReference(item.reference);
-            if (parseMeetingReference(reference).cuePosition === undefined || !/^[a-f0-9]{64}$/.test(item.fingerprint))
-                return invalid("finding evidence requires exact cue 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 cue");
-        const base = { id, project, evidence };
-        if (finding.kind === "fact") {
-            fields(finding, ["id", "project", "evidence", "kind", "type", "statement"]);
-            if (!MEETING_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",
-        ]);
-        if (!MEETING_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 meetingFindingFingerprint = ({ id: _id, ...finding }) => findingHash(finding);
+const cue = (raw) => {
+    const reference = canonicalMeetingReference(raw);
+    if (parseMeetingReference(reference).cuePosition === undefined)
+        throw new CliError("validation_error", "finding evidence requires exact cue references and fingerprints");
+    return reference;
+};
+export const validateMeetingFindings = (input) => validateFindings(input, { plural: "meeting findings", singular: "meeting finding", cited: "cue", reference: cue });
+export const meetingFindingFingerprint = findingFingerprint;

package/dist/meetings/index.d.ts

@@ -5,6 +5,7 @@ export { type MeetingCueIdentity, meetingCueFingerprint } from "./cue-fingerprin
 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, validateFindings, } from "./findings-rules.js";
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_QUERY, type MeetingItem, type MeetingOwner, meeting, meetingItem } from "./item.js";
 export { createMeetingContext, MEETING_FACT_TYPES, type MeetingContextAction, type MeetingContextChange, type MeetingContextOperation, type MeetingContextPorts, type MeetingContextReceipt, validateMeetingContextChange, } from "./meeting-context.js";

package/dist/meetings/index.js

@@ -3,6 +3,7 @@ export { meetingCueFingerprint } from "./cue-fingerprint.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 { importFiles } from "./import.js";
 export { MEETING_QUERY, meeting, meetingItem } from "./item.js";
 export { createMeetingContext, MEETING_FACT_TYPES, validateMeetingContextChange, } from "./meeting-context.js";

package/dist/replies/rendering.d.ts

@@ -2,6 +2,7 @@ import { type KeyringStore } from "@wirecat/cli-base";
 import type { Chat, Message } from "../domain/models.js";
 import { type ModelSettings } from "../models/index.js";
 import type { AppIdentity } from "../ports/app.js";
+import type { Warn } from "../runs/events.js";
 import type { ReplyRule } from "./rules.js";
 import { type TemplateResult } from "./template.js";
 export type ReplyChat = Pick<Chat, "id" | "kind"> & {
@@ -10,7 +11,7 @@ export type ReplyChat = Pick<Chat, "id" | "kind"> & {
 export type ReplyRender = (rule: ReplyRule, message: Message, chat: ReplyChat, now: number) => Promise<TemplateResult>;
 export declare const replyRenderer: (app: AppIdentity, profile: string, settings: () => {
     models?: ModelSettings;
-}, env: NodeJS.ProcessEnv, warn: (message: string) => void, options?: {
+}, env: NodeJS.ProcessEnv, warn: Warn, options?: {
     ai?: boolean;
     preview?: boolean;
     signal?: AbortSignal;

package/dist/replies/rendering.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { embeddingKeys, endpointKeyName } from "../embeddings/keys.js";
 import { modelGateway, modelTarget } from "../models/index.js";
 import { mayModelReply, replyConsentPathFor, replyModelIdentity } from "./consents.js";
-import { renderReplyTemplate } from "./template.js";
+import { renderReplyTemplate, templateWarning } from "./template.js";
 export const replyRenderer = (app, profile, settings, env, warn, options = {
     ai: true,
 }) => async (rule, message, chat, now) => {
@@ -48,6 +48,6 @@ export const replyRenderer = (app, profile, settings, env, warn, options = {
         },
     });
     for (const warning of result.warnings)
-        warn(warning);
+        warn(warning, templateWarning(warning));
     return result;
 };

package/dist/replies/rules.d.ts

@@ -1,5 +1,6 @@
 import * as v from "valibot";
 import type { AppIdentity } from "../ports/app.js";
+import type { WarningEvent } from "../runs/events.js";
 export declare const REPLY_ACTIONS: readonly ["reply", "task"];
 export declare const REPLY_MODELS: readonly ["fill-only", "may-reword"];
 export type ReplyAction = (typeof REPLY_ACTIONS)[number];
@@ -199,8 +200,12 @@ export interface Replies {
 export declare const EVERYONE: Audience;
 /** Why nobody may be answered here, or `null` when the audience lets the reply go. */
 export declare const outsideAudience: (audience: Audience, person: string | null, chat: string) => string | null;
+export interface AudienceWarning {
+    text: string;
+    warning: WarningEvent;
+}
 /** What in the audience does not do what it seems to say — said, never refused. */
-export declare const audienceWarnings: ({ reply, allow, deny }: Audience) => string[];
+export declare const audienceWarnings: ({ reply, allow, deny }: Audience) => AudienceWarning[];
 /** The owner's rules, in file order. No file is no rules; a file that does not check out refuses, naming the field. */
 export declare const readReplyRules: (path: string) => ReplyRule[];
 /** `provider`: the messenger reading the file, which an older file's `testers` may have named. */

package/dist/replies/rules.js

@@ -112,19 +112,27 @@ export const outsideAudience = (audience, person, chat) => {
     const listed = (person !== null && audience.allow.people.includes(person)) || audience.allow.chats.includes(chat);
     return listed ? null : "not on the allow list";
 };
+const audienceWarning = (code, text) => ({
+    text,
+    warning: { event: "warning", code, operation: "replies.audience" },
+});
 /** What in the audience does not do what it seems to say — said, never refused. */
 export const audienceWarnings = ({ reply, allow, deny }) => [
     ...allow.people
         .filter((id) => deny.people.includes(id))
-        .map((id) => `person ${id} is on both lists: deny wins, nobody answers them`),
+        .map((id) => audienceWarning("audience_person_on_both_lists", `person ${id} is on both lists: deny wins, nobody answers them`)),
     ...allow.chats
         .filter((id) => deny.chats.includes(id))
-        .map((id) => `chat ${id} is on both lists: deny wins, nothing is answered there`),
+        .map((id) => audienceWarning("audience_chat_on_both_lists", `chat ${id} is on both lists: deny wins, nothing is answered there`)),
     ...(reply === "all" && allow.people.length + allow.chats.length > 0
-        ? ['the allow list does nothing while audience.reply is "all" — set it to "listed" to answer only those']
+        ? [
+            audienceWarning("audience_allow_unused", 'the allow list does nothing while audience.reply is "all" — set it to "listed" to answer only those'),
+        ]
         : []),
     ...(reply === "listed" && allow.people.length + allow.chats.length === 0
-        ? ['audience.reply is "listed" and the allow list is empty: nobody is answered']
+        ? [
+            audienceWarning("audience_allow_empty", 'audience.reply is "listed" and the allow list is empty: nobody is answered'),
+        ]
         : []),
 ];
 /** The owner's rules, in file order. No file is no rules; a file that does not check out refuses, naming the field. */

package/dist/replies/serve.d.ts

@@ -1,4 +1,5 @@
 import type { Id, Message } from "../domain/models.js";
+import type { Warn } from "../runs/events.js";
 import type { ReplyChat, ReplyRender } from "./rendering.js";
 export declare const NOT_ALLOWED = "replies.send is not allow";
 export declare const NO_RULES = "no rules";
@@ -27,7 +28,7 @@ export interface Replier {
     allowed: () => boolean;
     chatOf: (chat: Id) => Promise<ReplyChat>;
     render?: ReplyRender;
-    warn?: (message: string) => void;
+    warn?: Warn;
     senderOf: (person: Id) => Promise<{
         isBot: boolean;
         isContact: boolean;

package/dist/replies/serve.js

@@ -2,7 +2,7 @@ import { codeOf } from "../sends/guarded.js";
 import { decide } from "./decide.js";
 import { outsideAudience, readReplies } from "./rules.js";
 import { readRepliesState, recordReply, writeRepliesState } from "./state.js";
-import { renderReplyTemplate } from "./template.js";
+import { renderReplyTemplate, templateWarning } from "./template.js";
 export const NOT_ALLOWED = "replies.send is not allow";
 export const NO_RULES = "no rules";
 export const ONLY_TASK = "opened a task, sent nothing";
@@ -69,7 +69,7 @@ export const replyTo = async (deps, message) => {
                 data: message.text,
             });
         for (const warning of rendered.warnings)
-            deps.warn?.(warning);
+            deps.warn?.(warning, templateWarning(warning));
         if (rendered.text === null)
             return { skip: rendered.reason ?? "reply template produced no reply", ...opened };
         // Pause and consent can be revoked while an async model request is in flight.

package/dist/replies/template.d.ts

@@ -1,3 +1,4 @@
+import type { WarningEvent } from "../runs/events.js";
 import type { ReplyRule } from "./rules.js";
 export declare const TEMPLATE_LIMITS: {
     parse: number;
@@ -34,4 +35,6 @@ export interface TemplateInput {
     }>;
     limits?: Partial<typeof TEMPLATE_LIMITS>;
 }
+/** A rendering warning as a log keeps it: a renderer a CLI hands in may warn in words this module does not know. */
+export declare const templateWarning: (text: string) => WarningEvent;
 export declare const renderReplyTemplate: (reply: ReplyRule["reply"], input: TemplateInput) => Promise<TemplateResult>;

package/dist/replies/template.js

@@ -9,6 +9,18 @@ export const TEMPLATE_LIMITS = {
     aiOutput: 1_024,
     calls: 4,
 };
+const LEGACY_PLACEHOLDERS = "legacy reply placeholders: use {{ sender.firstName }} and {{ sender.name }}";
+const LEGACY_REWORD = "legacy may-reword: use an ai block with an explicit fallback";
+const WARNING_CODES = {
+    [LEGACY_PLACEHOLDERS]: "reply_legacy_placeholders",
+    [LEGACY_REWORD]: "reply_legacy_may_reword",
+};
+/** A rendering warning as a log keeps it: a renderer a CLI hands in may warn in words this module does not know. */
+export const templateWarning = (text) => ({
+    event: "warning",
+    code: WARNING_CODES[text] ?? "reply_template_warning",
+    operation: "replies.render",
+});
 export const renderReplyTemplate = async (reply, input) => {
     const limits = { ...TEMPLATE_LIMITS, ...input.limits };
     const blocks = [];
@@ -16,11 +28,11 @@ export const renderReplyTemplate = async (reply, input) => {
     let source = reply.template;
     const legacy = /(?<!\{)\{(firstName|name)\}(?!\})/g;
     if (legacy.test(source)) {
-        warnings.push("legacy reply placeholders: use {{ sender.firstName }} and {{ sender.name }}");
+        warnings.push(LEGACY_PLACEHOLDERS);
         source = source.replace(legacy, (_, name) => `{{ sender.${name} }}`);
     }
     if (reply.model === "may-reword") {
-        warnings.push("legacy may-reword: use an ai block with an explicit fallback");
+        warnings.push(LEGACY_REWORD);
         if (!/\{%[-]?\s*ai\b/.test(source))
             source = `{% ai %}${source}{% else %}${source}{% endai %}`;
     }

package/dist/sends/guard.d.ts

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import type { Id } from "../domain/models.js";
 import { type AppIdentity } from "../ports/app.js";
+import type { Warn } from "../runs/events.js";
 import { FloodMemory } from "./flood.js";
 import { type AccountAction, type ChatAction, type SendEntry, SendJournal, type SendKind } from "./journal.js";
 import { type Level, type PermissionKey } from "./permissions.js";
@@ -66,7 +67,7 @@ export interface SendGuardOptions {
     recipients: RecipientList;
     /** Where a messenger's "this account may not write" is remembered; without it nothing is held. */
     flood?: FloodMemory;
-    warn: (message: string) => void;
+    warn: Warn;
     now?: () => Date;
 }
 /** A write the profile's level refuses, worded alike by the guard and by the check before connecting. */
@@ -96,7 +97,7 @@ export interface GuardSettings {
  * The guard a profile's configuration asks for — the command's, and a background server's for every
  * write it forwards. Built per request there, so `config set permissions.messages readonly` needs no restart.
  */
-export declare const guardFor: (app: AppIdentity, settings: GuardSettings, warn: (message: string) => void, env?: NodeJS.ProcessEnv, ask?: Asker) => SendGuard;
+export declare const guardFor: (app: AppIdentity, settings: GuardSettings, warn: Warn, env?: NodeJS.ProcessEnv, ask?: Asker) => SendGuard;
 /**
  * Over a background server, the server journals what it forwards, with the outcome it saw; the command
  * writes only the refusals of its own check, which never reached the server.

package/dist/sends/guard.js

@@ -227,7 +227,11 @@ export const sendGuard = ({ profile, recipients, command = recipients.command, r
                 journal.append({ at: now().toISOString(), profile, ...kept, ...(settles ? { reservation: settles } : {}) });
             }
             catch (error) {
-                warn(`this send is not in the send journal: ${journalFailure(error)}`);
+                warn(`this send is not in the send journal: ${journalFailure(error)}`, {
+                    event: "warning",
+                    code: "send_not_journaled",
+                    operation: "sends.journal",
+                });
             }
         },
     };

package/dist/services/context-evidence.d.ts

@@ -5,5 +5,6 @@ export interface ScopedContextEvidenceReader extends ContextEvidenceReader {
     usage(): ContextReadUsage;
 }
 export declare const createContextEvidenceReader: (port: ContextEvidenceReader, allowed: readonly ContextSource[], limits?: ContextReadLimits) => ScopedContextEvidenceReader;
-export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextSource, } from "../context/evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextRecordReader, ContextSource, } from "../context/evidence.js";
+export { contextEvidenceFingerprint } from "../context/evidence.js";
 export type { ContextReadLimits, ContextReadUsage } from "../context/read-budget.js";

package/dist/services/context-evidence.js

@@ -43,3 +43,4 @@ export const createContextEvidenceReader = (port, allowed, limits) => {
         },
     };
 };
+export { contextEvidenceFingerprint } from "../context/evidence.js";

package/dist/services/index.d.ts

@@ -1,6 +1,7 @@
 import { type BotCheckService } from "../botcheck/service.js";
-export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextReadLimits, ContextReadUsage, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
-export { createContextEvidenceReader } from "./context-evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
+export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
+export { excerpt } from "./excerpt.js";
 export { type DownloadedModel, downloadImageModel, downloadTextModel, type ModelDownloadOptions, } from "./model-downloads.js";
 export type { ProjectEvidenceItem, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectIndexCatchUp, ProjectSourceFetcher, } from "./project-gathering.js";
 export { gatherProjectEvidence } from "./project-gathering.js";

package/dist/services/index.js

@@ -1,5 +1,6 @@
 import { botCheckService } from "../botcheck/service.js";
-export { createContextEvidenceReader } from "./context-evidence.js";
+export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
+export { excerpt } from "./excerpt.js";
 export { downloadImageModel, downloadTextModel, } from "./model-downloads.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
 export { storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";

package/dist/services/project-gathering.d.ts

@@ -33,6 +33,7 @@ export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text"> {
     textTruncated: boolean;
     lanes: string[];
     context: "project" | "person-only";
+    fingerprint: string;
     around?: ProjectNeighbour[] | null;
     aroundIssue?: string | null;
 }

package/dist/services/project-gathering.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { contextEvidenceFingerprint } from "../context/evidence.js";
 import { createContextEvidenceReader } from "./context-evidence.js";
 import { excerpt } from "./excerpt.js";
 import { attachNeighbours } from "./project-gathering-around.js";
@@ -89,12 +90,14 @@ export const gatherProjectEvidence = async (ports, request) => {
         }
         seen.add(key);
         const short = excerpt(item.text, lane.query, 300, { literal: true });
+        const fingerprint = contextEvidenceFingerprint(item);
         const entry = {
             ...item,
             kind,
             source,
             text: short,
             textTruncated: short !== item.text.replace(/\s+/g, " ").trim(),
+            fingerprint,
             lanes: [lane.id],
             context: lane.kinds.every((k) => k === "person") ? "person-only" : "project",
         };

package/dist/services/proposal-tasks.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { MEETING_FINDINGS_KIND } from "../meetings/index.js";
+import { EVIDENCE_FINDINGS_KIND } from "../store/evidence-findings.js";
 import { createTaskService } from "../tasks/index.js";
 import { taskAccount } from "./task-rules.js";
 /** The source a proposal's task keeps: found again on a retry, so one proposal never makes two tasks. */
@@ -14,6 +15,10 @@ export const approveAsTask = async (store, id) => {
         throw new CliError("validation_error", "review meeting findings through the dedicated findings command", {
             reason: "meeting-findings.dedicated-review",
         });
+    if (proposal.kind === EVIDENCE_FINDINGS_KIND)
+        throw new CliError("validation_error", "review evidence findings through the dedicated findings command", {
+            reason: "evidence-findings.dedicated-review",
+        });
     if (proposal.status !== "proposed")
         throw new CliError("validation_error", `a ${proposal.status} action cannot be approved`, {
             reason: "proposal.wrong-state",

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

@@ -0,0 +1,63 @@
+import { type FindingOutcome, type FindingsInput, type FindingsReceipt } from "../meetings/index.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 interface EvidenceFindingsReceipt extends FindingsReceipt {
+    decision: {
+        by: "owner";
+    } | {
+        by: "agent";
+        bot: string;
+        model: string | null;
+        reason: string;
+    };
+}
+export interface EvidenceFindingsBatch {
+    id: string;
+    project: string;
+    input: FindingsInput;
+    fingerprint: string;
+    status: "proposed" | "reviewed";
+    author: {
+        type: "person" | "bot";
+        id: string;
+        name: string | null;
+    };
+    decidedBy: {
+        type: "person" | "bot";
+        id: string;
+    } | null;
+    decidedAt: string | null;
+    previous: FindingOutcome[];
+    receipt: EvidenceFindingsReceipt | null;
+}
+/**
+ * Cited facts and follow-ups about one project from stored messages, mail and documents, staged by an agent for
+ * review. A sibling of meeting findings: the same rules, evidence checked against the current stored text.
+ */
+export interface EvidenceFindingsStore {
+    stage(input: FindingsInput, agent: {
+        bot: string;
+        model?: string;
+    }): Promise<EvidenceFindingsBatch>;
+    get(id: string): Promise<EvidenceFindingsBatch>;
+    list(options?: {
+        project?: string;
+        limit?: number;
+        offset?: number;
+        status?: "proposed" | "reviewed";
+    }): Promise<{
+        items: EvidenceFindingsBatch[];
+        hasMore: boolean;
+    }>;
+    review(id: string, input: {
+        fingerprint: string;
+        accept: string[];
+        by?: EvidenceFindingsDecider;
+    }): Promise<EvidenceFindingsBatch>;
+}

package/dist/store/evidence-findings.js

@@ -0,0 +1,15 @@
+import { CliError } from "@wirecat/cli-base";
+import { formatLocator, parseLocator } from "../domain/locator.js";
+import { validateFindings } from "../meetings/index.js";
+export const EVIDENCE_FINDINGS_KIND = "evidence_findings";
+const reference = (raw) => {
+    if (/^document:[1-9]\d*$/.test(raw))
+        return raw;
+    try {
+        return formatLocator(parseLocator(raw));
+    }
+    catch {
+        throw new CliError("validation_error", "finding evidence is a msg: or document: reference");
+    }
+};
+export const validateEvidenceFindings = (input) => validateFindings(input, { plural: "evidence findings", singular: "evidence finding", cited: "reference", reference });

package/dist/store/index.d.ts

@@ -9,6 +9,7 @@ export type { DocumentTransferOptions, DocumentTransferPreview, DocumentTransfer
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./driver.js";
 export { PRAGMAS } from "./driver.js";
+export { EVIDENCE_FINDINGS_KIND, type EvidenceFindingsBatch, type EvidenceFindingsDecider, type EvidenceFindingsReceipt, type EvidenceFindingsStore, validateEvidenceFindings, } from "./evidence-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

@@ -2,6 +2,7 @@ export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export { PRAGMAS } from "./driver.js";
+export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
 export { MIGRATIONS, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
 export { storePath } from "./path.js";

package/dist/store/sqlite/context-evidence.d.ts

@@ -1,7 +1,15 @@
-import { type ContextEvidenceReader, type ContextIndex } from "../../context/evidence.js";
+import { type ContextEvidenceReader, type ContextIndex, type ContextRecordReader } from "../../context/evidence.js";
 import type { Stemmer, Stemmers } from "../../search/stem.js";
 import type { StoreContext } from "./open.js";
 /** No index fills, model loads or record hydration outside the read transaction. */
 export declare const contextEvidenceOver: ({ database }: Pick<StoreContext, "database">) => ContextEvidenceReader;
 /** The same fills a mail search and the notes search run before reading; a message is indexed when it is saved. */
 export declare const contextIndexOver: ({ database }: Pick<StoreContext, "database">, stemmerFor: (stemmers: Stemmers) => Stemmer) => ContextIndex;
+/** The cited record by reference, read with the context reader's own columns, so fingerprints agree. */
+export declare const contextRecordOf: (database: StoreContext["database"], ref: string) => {
+    ref: string;
+    title: string | null;
+    text: string;
+    revision: number | null;
+} | null;
+export declare const contextRecordsOver: ({ database }: Pick<StoreContext, "database">) => ContextRecordReader;

package/dist/store/sqlite/context-evidence.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { contextCursorScope, contextEvidenceRequest, } from "../../context/evidence.js";
-import { formatLocator } from "../../domain/locator.js";
+import { formatLocator, parseLocator } from "../../domain/locator.js";
 import { NORMALIZER_VERSION, normalize } from "../normalize.js";
 import { contextDocumentTime, contextDocumentTimeKind, contextDocumentUrl } from "./context-document-source.js";
 import { readMeetingContextEvidence } from "./context-meeting-source.js";
@@ -178,3 +178,45 @@ export const contextIndexOver = ({ database }, stemmerFor) => ({
         return { mail, documents };
     },
 });
+/** The cited record by reference, read with the context reader's own columns, so fingerprints agree. */
+export const contextRecordOf = (database, ref) => {
+    if (typeof ref !== "string")
+        return null;
+    const document = /^document:([1-9]\d*)$/.exec(ref);
+    if (document) {
+        const corpus = corpora.document;
+        const row = database
+            .prepare(`SELECT ${corpus.title} AS title,${corpus.body} AS body,${corpus.revision} AS revision FROM documents n
+         WHERE n.id=? AND n.deleted_at IS NULL AND ${corpus.where}`)
+            .get(Number(document[1]));
+        return row
+            ? {
+                ref,
+                title: row.title == null ? null : String(row.title),
+                text: String(row.body),
+                revision: row.revision == null ? null : Number(row.revision),
+            }
+            : null;
+    }
+    let at;
+    try {
+        at = parseLocator(ref);
+    }
+    catch {
+        return null;
+    }
+    const corpus = at.provider === "email" ? corpora.mail : corpora.message;
+    const row = database
+        .prepare(`SELECT ${corpus.title} AS title,${corpus.body} AS body FROM ${corpus.table} n JOIN accounts a ON a.id=n.account_id
+       ${corpus.join} WHERE a.provider=? AND a.external_id=? AND c.external_id=? AND n.external_id=?
+       AND n.deleted_at IS NULL AND ${corpus.where}`)
+        .get(at.provider, at.account, at.chat, at.message);
+    return row
+        ? { ref, title: row.title == null ? null : String(row.title), text: String(row.body), revision: null }
+        : null;
+};
+export const contextRecordsOver = ({ database }) => ({
+    async read(ref) {
+        return read(database, () => contextRecordOf(database, ref));
+    },
+});

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

@@ -0,0 +1,3 @@
+import { type EvidenceFindingsStore } from "../evidence-findings.js";
+import type { StoreContext } from "./open.js";
+export declare const evidenceFindingsStoreOver: (context: StoreContext) => EvidenceFindingsStore;