@wirecat/cli-core 0.362.0 → 0.363.0

package/CHANGELOG.md

@@ -7,6 +7,19 @@ shape of this file.
 
 ## Unreleased
 
+## 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/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;

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/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",