@wirecat/cli-core 0.366.0 → 0.367.0

package/CHANGELOG.md

@@ -7,6 +7,27 @@ shape of this file.
 
 ## Unreleased
 
+## 0.367.0 — 20.10.2026
+
+### Added
+
+- **A document hit in project gathering carries the paragraphs around it.** `around` holds, in document order, up
+  to `around.before` and `around.after` paragraphs next to the first one naming a searched word, plus that one
+  marked `found`. The bytes count as `usage.aroundBytes`, as a message's neighbours do.
+
+### Fixed
+
+- **An evidence findings review accepts the findings whose own evidence is unchanged.** Before, one changed text
+  anywhere in a batch refused accepting any of it, so the agent had to stage the whole batch again. Now only the
+  accepted findings' project, assignee and cited texts are rechecked; the rest can be rejected in the same review.
+  Batches keep one hash per checked record for this; a batch staged earlier is still checked as a whole.
+
+- **Project gathering moves past large documents instead of stalling.** A page of evidence now holds the records
+  that fit its byte budget together, rather than failing when they do not. A record larger than the page is read
+  alone, up to 256 KiB. One larger still is listed in the new `oversized` result field by reference and skipped,
+  so a resume no longer retries the same page and charges its budget each time. The context reader's page gains
+  the same optional `oversized`. Meeting preparation reports such a record as `read-limited` and continues past it.
+
 ## 0.366.0 — 20.10.2026
 
 ### Added

package/dist/context/evidence-response.js

@@ -34,6 +34,14 @@ export const validateContextEvidencePage = (page, request) => {
             fail();
         if (page.next)
             contextEvidenceRequest({ ...request, cursor: page.next });
+        const big = page.oversized;
+        if (big !== undefined &&
+            (!big ||
+                page.items.length ||
+                typeof big.ref !== "string" ||
+                !Number.isSafeInteger(big.bytes) ||
+                big.bytes <= maxReadBytes))
+            fail();
         let actual = 0;
         for (const item of page.items) {
             if (!item ||

package/dist/context/evidence.d.ts

@@ -1,3 +1,4 @@
+export declare const CONTEXT_MAX_READ_BYTES = 262144;
 export declare const CONTEXT_SOURCE_KINDS: readonly ["message", "mail", "document", "meeting"];
 export interface ContextSource {
     kind: (typeof CONTEXT_SOURCE_KINDS)[number];
@@ -40,6 +41,11 @@ export interface ContextEvidencePage {
         scope: string;
     } | null;
     readBytes: number;
+    /** The next record alone is larger than maxReadBytes: it was not read, and next moves past it. */
+    oversized?: {
+        ref: string;
+        bytes: number;
+    };
     coverage: {
         available: boolean;
         index: "ready" | "pending" | "missing" | "unknown";
@@ -65,6 +71,11 @@ export interface ContextIndex {
 }
 /** 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;
+/** How many rows, in reading order, fit the allowance together; none when the first alone is larger. */
+export declare const fittingRows: (sizes: readonly number[], limit: number, maxReadBytes: number) => {
+    count: number;
+    bytes: number;
+};
 /** 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>;

package/dist/context/evidence.js

@@ -1,10 +1,22 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
+export const CONTEXT_MAX_READ_BYTES = 262144;
 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");
+/** How many rows, in reading order, fit the allowance together; none when the first alone is larger. */
+export const fittingRows = (sizes, limit, maxReadBytes) => {
+    let count = 0, bytes = 0;
+    for (const size of sizes.slice(0, limit)) {
+        if (!(bytes + size <= maxReadBytes))
+            break;
+        bytes += size;
+        count++;
+    }
+    return { count, bytes };
+};
 export const contextCursorScope = (request) => createHash("sha256")
     .update(JSON.stringify([
     "context-evidence-v1",
@@ -56,7 +68,7 @@ export const contextEvidenceRequest = (input) => {
     if (!words.length || words.length > 16)
         throw new CliError("validation_error", "query needs 1–16 literal words");
     const limit = integer(input.limit ?? 10, "limit", 1, 20);
-    const maxReadBytes = integer(input.maxReadBytes ?? 65536, "maxReadBytes", 1, 262144);
+    const maxReadBytes = integer(input.maxReadBytes ?? 65536, "maxReadBytes", 1, CONTEXT_MAX_READ_BYTES);
     if (input.cursor !== undefined && (!input.cursor || typeof input.cursor !== "object"))
         throw new CliError("validation_error", "cursor needs at, id and scope");
     if (input.cursor)

package/dist/services/meeting-communications-preparation.js

@@ -41,6 +41,10 @@ export const readPreparationCommunications = async (plan, signal) => {
                 coverage.state = "unavailable";
                 coverage.issue = "not_found";
             }
+            else if (page.oversized) {
+                coverage.state = "read-limited";
+                coverage.issue = "validation_error";
+            }
             else if (page.coverage.index !== "ready")
                 coverage.issue = "configuration_error";
             const refs = new Set();

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

@@ -20,6 +20,14 @@ export interface ProjectNeighbourReader {
     }[]>;
 }
 export declare const storedMessageNeighbours: (messages: Pick<MessagesStore, "around">) => ProjectNeighbourReader;
+/** The paragraphs around the first one that names the query, in document order; the hit's own is marked found. */
+export declare const documentPassage: (text: string, query: string, window: {
+    before: number;
+    after: number;
+}) => {
+    text: string;
+    found: boolean;
+}[];
 /**
  * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
  * the run's read bytes.

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

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator, parseLocator } from "../domain/locator.js";
+import { fold } from "../store/normalize.js";
 import { excerpt } from "./excerpt.js";
 export const storedMessageNeighbours = (messages) => ({
     async around(ref, window) {
@@ -17,6 +18,23 @@ export const storedMessageNeighbours = (messages) => ({
         }));
     },
 });
+const wordsOf = (text) => (text.match(/[\p{L}\p{N}\p{M}]+/gu) ?? []).map(fold);
+/** The paragraphs around the first one that names the query, in document order; the hit's own is marked found. */
+export const documentPassage = (text, query, window) => {
+    const paragraphs = text
+        .split(/\n\s*\n/)
+        .map((part) => part.replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+    const words = new Set(wordsOf(query));
+    const hit = paragraphs.findIndex((part) => wordsOf(part).some((word) => words.has(word)));
+    if (hit < 0 || paragraphs.length < 2)
+        return [];
+    const from = Math.max(0, hit - window.before);
+    return paragraphs.slice(from, hit + window.after + 1).map((part, index) => ({
+        text: excerpt(part, query, 200, { literal: true }),
+        found: from + index === hit,
+    }));
+};
 /**
  * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
  * the run's read bytes.

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

@@ -79,6 +79,12 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
         issue: string | null;
     }[];
     items: ProjectEvidenceItem[];
+    oversized: {
+        ref: string;
+        lanes: string[];
+        source: number;
+        bytes: number;
+    }[];
     matchedAgain: {
         ref: string;
         lanes: string[];

package/dist/services/project-gathering.js

@@ -1,8 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
-import { contextEvidenceFingerprint } from "../context/evidence.js";
+import { CONTEXT_MAX_READ_BYTES, contextEvidenceFingerprint } from "../context/evidence.js";
 import { createContextEvidenceReader } from "./context-evidence.js";
 import { excerpt } from "./excerpt.js";
-import { attachNeighbours } from "./project-gathering-around.js";
+import { attachNeighbours, documentPassage, } from "./project-gathering-around.js";
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
 export const gatherProjectEvidence = async (ports, request) => {
@@ -72,6 +72,7 @@ export const gatherProjectEvidence = async (ports, request) => {
     const items = [];
     const byRef = new Map();
     const matchedAgain = new Map();
+    const oversized = new Map();
     let stopped = null;
     const open = (u) => !terminal.has(u.state) && u.state !== "read-limited";
     const take = (item, lane, kind, source) => {
@@ -101,6 +102,18 @@ export const gatherProjectEvidence = async (ports, request) => {
             lanes: [lane.id],
             context: lane.kinds.every((k) => k === "person") ? "person-only" : "project",
         };
+        if (kind === "document" && plan.around.before + plan.around.after) {
+            entry.around = [];
+            for (const part of documentPassage(item.text, lane.query, plan.around)) {
+                const bytes = Buffer.byteLength(part.text);
+                if (bytes > plan.budgets.maxReadBytes - usage.readBytes - usage.aroundBytes) {
+                    entry.aroundIssue = "read-bytes";
+                    break;
+                }
+                usage.aroundBytes += bytes;
+                entry.around.push({ ref: item.ref, at: item.at, sender: null, ...part });
+            }
+        }
         byRef.set(item.ref, entry);
         items.push(entry);
         usage.items++;
@@ -126,24 +139,49 @@ export const gatherProjectEvidence = async (ports, request) => {
                                 : null;
             if (stopped)
                 break;
-            const allowance = Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes);
-            const reader = createContextEvidenceReader(ports.evidence, [unit.source], {
-                maxReads: 1,
-                maxTotalReadBytes: allowance,
-            });
-            usage.reads++;
-            try {
-                const page = await reader.read({
-                    source: unit.source,
-                    query: unit.lane.query,
-                    after: unit.chunk.after,
-                    before: unit.chunk.before,
-                    limit: 20,
-                    maxReadBytes: allowance,
-                    ...(state.cursor ? { cursor: state.cursor } : {}),
-                    signal,
+            const readPage = async (allowance, limit) => {
+                const reader = createContextEvidenceReader(ports.evidence, [unit.source], {
+                    maxReads: 1,
+                    maxTotalReadBytes: allowance,
                 });
-                usage.readBytes += page.readBytes;
+                usage.reads++;
+                try {
+                    const page = await reader.read({
+                        source: unit.source,
+                        query: unit.lane.query,
+                        after: unit.chunk.after,
+                        before: unit.chunk.before,
+                        limit,
+                        maxReadBytes: allowance,
+                        ...(state.cursor ? { cursor: state.cursor } : {}),
+                        signal,
+                    });
+                    usage.readBytes += page.readBytes;
+                    return page;
+                }
+                catch (error) {
+                    usage.readBytes += reader.usage().chargedBytes;
+                    throw error;
+                }
+            };
+            try {
+                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), 20);
+                const big = page.oversized;
+                if (big && big.bytes <= CONTEXT_MAX_READ_BYTES) {
+                    if (big.bytes > plan.budgets.maxReadBytes - usage.readBytes || usage.reads >= plan.budgets.maxReads) {
+                        state.state = "read-limited";
+                        state.code = "validation_error";
+                        continue;
+                    }
+                    page = await readPage(big.bytes, 1);
+                }
+                else if (big) {
+                    const known = oversized.get(big.ref);
+                    if (!known)
+                        oversized.set(big.ref, { ref: big.ref, lanes: [unit.lane.id], source: unit.sourceIndex, bytes: big.bytes });
+                    else if (!known.lanes.includes(unit.lane.id))
+                        known.lanes.push(unit.lane.id);
+                }
                 state.pages++;
                 state.code = page.coverage.index === "ready" ? null : `index-${page.coverage.index}`;
                 for (const item of page.items)
@@ -161,7 +199,6 @@ export const gatherProjectEvidence = async (ports, request) => {
             }
             catch (error) {
                 signal?.throwIfAborted();
-                usage.readBytes += reader.usage().chargedBytes;
                 if (!(error instanceof CliError))
                     throw error;
                 if (error.code === "validation_error" && error.details?.reason === "context.read-budget")
@@ -225,6 +262,7 @@ export const gatherProjectEvidence = async (ports, request) => {
             issue: progress[index]?.code ?? null,
         })),
         items,
+        oversized: [...oversized.values()],
         matchedAgain: [...matchedAgain].map(([ref, lanes]) => ({ ref, lanes: [...lanes] })),
         usage: { ...usage, elapsedMs: now() - started },
         totals,

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

@@ -1,5 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
-import { contextCursorScope, contextEvidenceRequest, } from "../../context/evidence.js";
+import { contextCursorScope, contextEvidenceRequest, fittingRows, } from "../../context/evidence.js";
 import { formatLocator, parseLocator } from "../../domain/locator.js";
 import { NORMALIZER_VERSION, normalize } from "../normalize.js";
 import { contextDocumentTime, contextDocumentTimeKind, contextDocumentUrl } from "./context-document-source.js";
@@ -122,38 +121,48 @@ export const contextEvidenceOver = ({ database }) => ({
             if (cursor)
                 params.push(cursor.at, cursor.at, cursor.id);
             params.push(limit + 1);
-            const probe = database
-                .prepare(`SELECT coalesce(sum(
+            const sized = database
+                .prepare(`SELECT id,at,provider,account,chat,external_id,
         length(CAST(coalesce(title,'') AS BLOB))+length(CAST(coalesce(body,'') AS BLOB))+
         length(CAST(coalesce(url,'') AS BLOB))+length(CAST(provider AS BLOB))+
         length(CAST(account AS BLOB))+length(CAST(external_id AS BLOB))+
-        length(CAST(coalesce(chat,'') AS BLOB))+length(CAST(time_kind AS BLOB))),0) AS bytes FROM (${selection})`)
-                .get(...params);
-            const readBytes = Number(probe?.bytes);
-            if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
-                throw new CliError("validation_error", "context evidence exceeds maxReadBytes before hydration", {
-                    reason: "context.read-budget",
+        length(CAST(coalesce(chat,'') AS BLOB))+length(CAST(time_kind AS BLOB)) AS bytes FROM (${selection})`)
+                .all(...params);
+            const refOf = (row) => source.kind === "document"
+                ? `document:${row.id}`
+                : formatLocator({
+                    provider: String(row.provider),
+                    account: String(row.account),
+                    chat: String(row.chat),
+                    message: String(row.external_id),
                 });
+            const past = (row) => ({ at: Number(row.at), id: Number(row.id), scope });
+            const fit = fittingRows(sized.map((row) => Number(row.bytes)), limit, maxReadBytes);
+            const first = sized[0];
+            if (!fit.count && first) {
+                coverage.hasMore = sized.length > 1;
+                return {
+                    source,
+                    items: [],
+                    readBytes: 0,
+                    coverage,
+                    next: coverage.hasMore ? past(first) : null,
+                    oversized: { ref: refOf(first), bytes: Number(first.bytes) },
+                };
+            }
             signal?.throwIfAborted();
-            const rows = database.prepare(selection).all(...params);
+            params[params.length - 1] = fit.count;
+            const selected = fit.count ? database.prepare(selection).all(...params) : [];
             signal?.throwIfAborted();
-            coverage.hasMore = rows.length > limit;
-            const selected = rows.slice(0, limit);
+            coverage.hasMore = sized.length > selected.length;
             const last = selected.at(-1);
             return {
                 source,
-                readBytes,
+                readBytes: fit.bytes,
                 coverage,
-                next: coverage.hasMore && last ? { at: Number(last.at), id: Number(last.id), scope } : null,
+                next: coverage.hasMore && last ? past(last) : null,
                 items: selected.map((row) => ({
-                    ref: source.kind === "document"
-                        ? `document:${row.id}`
-                        : formatLocator({
-                            provider: String(row.provider),
-                            account: String(row.account),
-                            chat: String(row.chat),
-                            message: String(row.external_id),
-                        }),
+                    ref: refOf(row),
                     provider: String(row.provider),
                     account: String(row.account),
                     title: row.title == null ? null : String(row.title),

package/dist/store/sqlite/context-meeting-source.js

@@ -1,5 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
-import { contextCursorScope } from "../../context/evidence.js";
+import { contextCursorScope, fittingRows, } from "../../context/evidence.js";
 import { normalize } from "../normalize.js";
 import { read } from "./transaction.js";
 /** Transcript cues keep their retained revision reference; a meeting title alone is not a transcript match. */
@@ -57,29 +56,40 @@ export const readMeetingContextEvidence = (database, request) => {
         if (cursor)
             params.push(cursor.at, cursor.at, cursor.id);
         params.push(limit + 1);
-        const probe = database
-            .prepare(`SELECT coalesce(sum(length(CAST(coalesce(title,'') AS BLOB))+
+        const sized = database
+            .prepare(`SELECT id,at,ref,length(CAST(coalesce(title,'') AS BLOB))+
         length(CAST(text AS BLOB))+length(CAST(provider AS BLOB))+
-        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start')),0) AS bytes FROM (${selection})`)
-            .get(...params);
-        const readBytes = Number(probe?.bytes);
-        if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
-            throw new CliError("validation_error", "meeting context evidence exceeds maxReadBytes before hydration", {
-                reason: "context.read-budget",
-            });
+        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start') AS bytes FROM (${selection})`)
+            .all(...params);
+        const past = (row) => ({
+            at: Number(row.at),
+            id: Number(row.id),
+            scope: contextCursorScope(request),
+        });
+        const fit = fittingRows(sized.map((row) => Number(row.bytes)), limit, maxReadBytes);
+        const first = sized[0];
+        if (!fit.count && first) {
+            coverage.hasMore = sized.length > 1;
+            return {
+                source,
+                items: [],
+                readBytes: 0,
+                coverage,
+                next: coverage.hasMore ? past(first) : null,
+                oversized: { ref: String(first.ref), bytes: Number(first.bytes) },
+            };
+        }
         signal?.throwIfAborted();
-        const rows = database.prepare(selection).all(...params);
+        params[params.length - 1] = fit.count;
+        const selected = fit.count ? database.prepare(selection).all(...params) : [];
         signal?.throwIfAborted();
-        coverage.hasMore = rows.length > limit;
-        const selected = rows.slice(0, limit);
+        coverage.hasMore = sized.length > selected.length;
         const last = selected.at(-1);
         return {
             source,
-            readBytes,
+            readBytes: fit.bytes,
             coverage,
-            next: coverage.hasMore && last
-                ? { at: Number(last.at), id: Number(last.id), scope: contextCursorScope(request) }
-                : null,
+            next: coverage.hasMore && last ? past(last) : null,
             items: selected.map((row) => ({
                 ref: String(row.ref),
                 provider: String(row.provider),

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

@@ -54,9 +54,9 @@ export const evidenceFindingsStoreOver = (context) => {
             receipt: proposal.result,
         };
     };
-    const snapshot = (input) => {
+    const cite = () => {
         let readBytes = 0;
-        return core.snapshot(input, (evidence, _finding, _project, seen) => {
+        return (evidence, _finding, _project, seen) => {
             if (seen.has(evidence.reference)) {
                 if (seen.get(evidence.reference) !== evidence.fingerprint)
                     return stale();
@@ -72,8 +72,9 @@ export const evidenceFindingsStoreOver = (context) => {
             if (fingerprint !== evidence.fingerprint)
                 return stale();
             seen.set(evidence.reference, fingerprint);
-        });
+        };
     };
+    const snapshot = (input) => core.snapshot(input, cite());
     const decider = (by) => {
         if (by === undefined || by === "owner")
             return { author: "owner", decision: { by: "owner" } };
@@ -109,6 +110,7 @@ export const evidenceFindingsStoreOver = (context) => {
                     return view(proposal);
                 }
                 const snapshotHash = snapshot(input);
+                const snapshotParts = core.snapshotParts(input, cite());
                 const fingerprints = input.findings.map(findingFingerprint);
                 if (new Set(fingerprints).size !== fingerprints.length)
                     return invalid("the batch contains duplicate findings");
@@ -116,7 +118,7 @@ export const evidenceFindingsStoreOver = (context) => {
                     kind: EVIDENCE_FINDINGS_KIND,
                     by,
                     target: [...projects][0],
-                    payload: { ...input, inputHash, snapshotHash, agentModel: by.model ?? null },
+                    payload: { ...input, inputHash, snapshotHash, snapshotParts, agentModel: by.model ?? null },
                 }));
             });
         },
@@ -152,9 +154,21 @@ export const evidenceFindingsStoreOver = (context) => {
                 return batch;
             }
             const input = proposal.payload;
-            // Rejecting creates nothing, so a batch whose evidence changed can still be closed.
-            if (accepted.length && snapshot(batch.input) !== input.snapshotHash)
-                return stale();
+            // Rejecting creates nothing, so a batch whose evidence changed can still be closed. Accepting needs only the
+            // accepted findings' own project, assignee and evidence unchanged; a batch staged before parts were kept needs all.
+            if (accepted.length) {
+                const parts = input.snapshotParts;
+                if (!parts) {
+                    if (snapshot(batch.input) !== input.snapshotHash)
+                        return stale();
+                }
+                else {
+                    const chosen = { ...batch.input, findings: batch.input.findings.filter((f) => accepted.includes(f.id)) };
+                    const now = core.snapshotParts(chosen, cite());
+                    if (Object.entries(now).some(([key, hash]) => parts[key] !== hash))
+                        return stale();
+                }
+            }
             if (proposal.proposedBy.type !== "bot" || !proposal.proposedBy.name)
                 return invalid("a findings author must be an agent");
             const agent = {

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

@@ -12,6 +12,7 @@ export declare const findingsAgent: (agent: FindingsAgent) => FindingsAgent;
  */
 export declare const findingsCoreOver: (context: StoreContext, kind: string) => {
     snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => string;
+    snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => Record<string, string>;
     previous: (account: number | null, fingerprint: string) => FindingOutcome | undefined;
     outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent) => FindingOutcome[];
 };

package/dist/store/sqlite/findings-core.js

@@ -27,7 +27,7 @@ export const findingsCoreOver = (context, kind) => {
     const { database } = context;
     const facts = factOperationsOver(context);
     const tasks = workTaskOperationsOver(context);
-    const snapshot = (input, cite) => {
+    const cited = (input, cite) => {
         const seen = new Map();
         for (const finding of input.findings) {
             const project = requiredThing(database, finding.project, "the project");
@@ -51,8 +51,11 @@ export const findingsCoreOver = (context, kind) => {
             for (const evidence of finding.evidence)
                 cite(evidence, finding, String(project.id), seen);
         }
-        return findingHash([...seen].sort(([a], [b]) => a.localeCompare(b)));
+        return seen;
     };
+    const snapshot = (...args) => findingHash([...cited(...args)].sort(([a], [b]) => a.localeCompare(b)));
+    /** The same snapshot, one hash per project, person and cited reference, so part of a batch can be checked alone. */
+    const snapshotParts = (...args) => Object.fromEntries([...cited(...args)].map(([key, value]) => [key, findingHash(value)]));
     const previous = (account, fingerprint) => {
         const row = database
             .prepare("SELECT substr(j.value,1,4096) AS item FROM proposed_actions p,json_each(p.result,'$.items') j WHERE p.account_id IS ? AND p.kind=? AND p.status='approved' AND json_extract(j.value,'$.fingerprint')=? ORDER BY p.id LIMIT 1")
@@ -104,5 +107,5 @@ export const findingsCoreOver = (context, kind) => {
             reused: false,
         };
     });
-    return { snapshot, previous, outcomes };
+    return { snapshot, snapshotParts, previous, outcomes };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.366.0",
+  "version": "0.367.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",