@wirecat/cli-core 0.376.0 → 0.378.0

package/CHANGELOG.md

@@ -5,7 +5,38 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 0.378.0 — 21.10.2026
+
+### Added
+
+- **`gatherProjectEvidence` reads what a person wrote.** A person given with `senders: [{ provider, id }]` (their
+  stored identities, at most 16; an email identity's id is its address) and a `reference` gets a lane of its own
+  (`kinds: ["sender"]`, `query: null`, `senders`): every message or mail one of those identities wrote in the window,
+  read only through a selected source of that identity's provider. `name` becomes optional for such a person. An
+  item found only that way has `context: "sender"`, ranked between `linked-chat` and `person-only`. The context reader
+  takes the same filter as `senders` (`coverage.matching: "sender"`). Requests without senders keep their
+  fingerprint, so their checkpoints still resume. See [project gathering](docs/dev/PROJECT-GATHERING.md).
+
+### Fixed
+
+- **Discovery search accepts thread context.** `search messages --discover --thread` expands the ranked hits
+  through the shared bounded thread reader instead of refusing inside candidate search. Reply provenance,
+  time context and thread limits are preserved.
+
+## 0.377.0 — 20.10.2026
+
+### Added
+
+- **A document hit says how many other paragraphs match.** `ProjectEvidenceItem.moreMatches` (on a document item
+  with `around`) counts the paragraphs after the one `around` centres on that also name a lane word. See
+  [project gathering](docs/dev/PROJECT-GATHERING.md).
+
+### Fixed
+
+- **A document hit's `around` followed the lane that found it first, not the document.** It centred on that lane's
+  first matching paragraph (in a measured 145 KB document, paragraph 60 found by the key, not paragraph 4 that
+  names the project). It now centres on the first paragraph that names a word of any lane, in document order, as
+  the guide says. No extra reads or charged bytes.
 
 ## 0.376.0 — 20.10.2026
 

package/dist/context/evidence-response.js

@@ -8,7 +8,7 @@ export const validateContextEvidencePage = (page, request) => {
         throw new CliError("invalid_response", "context reader returned invalid or out-of-scope evidence");
     };
     try {
-        const { source, chat, after, before, limit, maxReadBytes } = contextEvidenceRequest(request);
+        const { source, chat, senders, after, before, limit, maxReadBytes } = contextEvidenceRequest(request);
         if (!page || contextSourceKey(contextSource(page.source)) !== contextSourceKey(source))
             fail();
         if (!Array.isArray(page.items) ||
@@ -23,7 +23,7 @@ export const validateContextEvidencePage = (page, request) => {
             typeof c.hasMore !== "boolean" ||
             typeof c.hasUndated !== "boolean" ||
             !["ready", "pending", "missing", "unknown"].includes(c.index) ||
-            c.matching !== (chat === undefined ? "literal-words" : "chat") ||
+            c.matching !== (chat !== undefined ? "chat" : senders !== undefined ? "sender" : "literal-words") ||
             c.completeness !== "unknown" ||
             c.consistency !== "snapshot-per-page")
             fail();

package/dist/context/evidence.d.ts

@@ -12,6 +12,8 @@ export interface ContextEvidenceRequest {
     query?: string;
     /** One stored chat or mail thread of the source's account, by its external id; refused for documents and meetings. */
     chat?: string;
+    /** Messages or mail written by these identities of the source's provider (mail: addresses); no query or chat. */
+    senders?: string[];
     after: number;
     before: number;
     limit?: number;
@@ -55,7 +57,7 @@ export interface ContextEvidencePage {
         hasMore: boolean;
         hasUndated: boolean;
         completeness: "unknown";
-        matching: "literal-words" | "chat";
+        matching: "literal-words" | "chat" | "sender";
         consistency: "snapshot-per-page";
     };
 }
@@ -83,12 +85,13 @@ export declare const fittingRows: (sizes: readonly number[], limit: number, maxR
 export interface ContextRecordReader {
     read(ref: string): Promise<Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision"> | null>;
 }
-export declare const contextCursorScope: (request: Pick<ContextEvidenceRequest, "source" | "query" | "chat" | "after" | "before">) => string;
+export declare const contextCursorScope: (request: Pick<ContextEvidenceRequest, "source" | "query" | "chat" | "senders" | "after" | "before">) => string;
 export declare const contextSource: (value: ContextSource) => ContextSource;
 export declare const contextEvidenceRequest: (input: ContextEvidenceRequest) => {
     source: ContextSource;
     query: string | undefined;
     chat: string | undefined;
+    senders: string[] | undefined;
     words: RegExpMatchArray | [];
     after: number;
     before: number;

package/dist/context/evidence.js

@@ -29,6 +29,7 @@ export const contextCursorScope = (request) => createHash("sha256")
     request.before,
     // Only a chat read hashes its chat, so cursors issued before chat reads existed stay valid.
     ...(request.chat === undefined ? [] : [request.chat]),
+    ...(request.senders === undefined ? [] : [["senders", ...request.senders]]),
 ]))
     .digest("hex");
 const fields = (value, allowed, prefix) => {
@@ -53,7 +54,7 @@ export const contextSource = (value) => {
 };
 export const contextEvidenceRequest = (input) => {
     const source = contextSource(input?.source);
-    fields(input, ["source", "query", "chat", "after", "before", "limit", "maxReadBytes", "cursor", "signal"], "");
+    fields(input, ["source", "query", "chat", "senders", "after", "before", "limit", "maxReadBytes", "cursor", "signal"], "");
     const integer = (value, name, low, high) => {
         if (!Number.isSafeInteger(value) || value < low || value > high)
             throw new CliError("validation_error", `${name} must be a whole number from ${low} to ${high}`);
@@ -72,11 +73,25 @@ export const contextEvidenceRequest = (input) => {
         if (input.query !== undefined)
             throw new CliError("validation_error", "a chat read takes no query");
     }
+    const senders = input.senders;
+    if (senders !== undefined) {
+        if (!Array.isArray(senders) ||
+            !senders.length ||
+            senders.length > 16 ||
+            senders.some((id) => typeof id !== "string" || !id.trim() || Buffer.byteLength(id) > 1024) ||
+            new Set(senders).size !== senders.length)
+            throw new CliError("validation_error", "senders needs 1–16 distinct identity ids");
+        if (source.kind !== "message" && source.kind !== "mail")
+            throw new CliError("validation_error", "only a message or mail source reads by sender");
+        if (input.query !== undefined || chat !== undefined)
+            throw new CliError("validation_error", "a sender read takes no query or chat");
+    }
+    const bare = chat === undefined && senders === undefined;
     const query = input.query;
-    if (chat === undefined && (typeof query !== "string" || !query.trim() || Buffer.byteLength(query) > 2048))
+    if (bare && (typeof query !== "string" || !query.trim() || Buffer.byteLength(query) > 2048))
         throw new CliError("validation_error", "query needs 1–2048 UTF-8 bytes of literal words");
     const words = query?.match(/[\p{L}\p{N}]+/gu) ?? [];
-    if (chat === undefined && (!words.length || words.length > 16))
+    if (bare && (!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, CONTEXT_MAX_READ_BYTES);
@@ -91,7 +106,7 @@ export const contextEvidenceRequest = (input) => {
             id: integer(input.cursor.id, "cursor.id", 1, Number.MAX_SAFE_INTEGER),
             scope: input.cursor.scope,
         };
-    if (cursor && cursor.scope !== contextCursorScope({ source, query, chat, after, before }))
-        throw new CliError("validation_error", "cursor belongs to another source, query, chat or time window");
-    return { source, query, chat, words, after, before, limit, maxReadBytes, cursor, signal: input.signal };
+    if (cursor && cursor.scope !== contextCursorScope({ source, query, chat, senders, after, before }))
+        throw new CliError("validation_error", "cursor belongs to another source, query, chat, senders or time window");
+    return { source, query, chat, senders, words, after, before, limit, maxReadBytes, cursor, signal: input.signal };
 };

package/dist/services/context-evidence.js

@@ -23,6 +23,7 @@ export const createContextEvidenceReader = (port, allowed, limits) => {
                 source: Object.freeze({ ...source }),
                 ...(validated.query === undefined ? {} : { query: validated.query }),
                 ...(validated.chat === undefined ? {} : { chat: validated.chat }),
+                ...(validated.senders === undefined ? {} : { senders: Object.freeze([...validated.senders]) }),
                 after: validated.after,
                 before: validated.before,
                 limit: validated.limit,

package/dist/services/index.d.ts

@@ -9,7 +9,7 @@ export type { ProjectNeighbour, ProjectNeighbourReader } from "./project-gatheri
 export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";
 export type { EvidenceMention, EvidenceMentions } from "./project-gathering-mentions.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
-export type { ProjectFetchState, ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, ProjectLinkedChat, ProjectUnitState, } from "./project-gathering-request.js";
+export type { ProjectFetchState, ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, ProjectLinkedChat, ProjectPerson, ProjectSender, ProjectUnitState, } from "./project-gathering-request.js";
 import { type AccountService } from "./account.js";
 import { type AdminService } from "./admin.js";
 import { type AdminStatisticsService } from "./admin-statistics.js";

package/dist/services/meeting-communications-selection.d.ts

@@ -16,6 +16,7 @@ export declare const captureCommunicationSelections: (port: MeetingCommunication
             source: import("./context-evidence.js").ContextSource;
             query: string | undefined;
             chat: string | undefined;
+            senders: string[] | undefined;
             after: number;
             before: number;
             limit: number;

package/dist/services/messages-archive-search.js

@@ -65,7 +65,7 @@ const searchPage = async (store, account, request, messenger) => {
         throw new CliError("validation_error", "discovery searches the local archive; use backend archive");
     await topUp(store);
     const found = request.discover
-        ? await searchDiscovery(store, account, request, messenger)
+        ? await searchDiscovery(store, account, { ...request, thread: undefined }, messenger)
         : await searchLucene(store, account, request, messenger);
     return withThreads(store, found, request);
 };

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

@@ -20,6 +20,20 @@ export interface ProjectNeighbourReader {
     }[]>;
 }
 export declare const storedMessageNeighbours: (messages: Pick<MessagesStore, "around">) => ProjectNeighbourReader;
+/**
+ * The paragraphs around the first one that names a word of any query, in document order, with the hit's own marked
+ * found, and how many later paragraphs name one too.
+ */
+export declare const documentMatches: (text: string, queries: string[], window: {
+    before: number;
+    after: number;
+}) => {
+    around: {
+        text: string;
+        found: boolean;
+    }[];
+    moreMatches: number;
+};
 /** 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;

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

@@ -19,22 +19,30 @@ 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) => {
+/**
+ * The paragraphs around the first one that names a word of any query, in document order, with the hit's own marked
+ * found, and how many later paragraphs name one too.
+ */
+export const documentMatches = (text, queries, window) => {
     const paragraphs = text
         .split(/\n\s*\n/)
         .map((part) => part.replace(/\s+/g, " ").trim())
         .filter(Boolean);
+    const query = queries.join(" ");
     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 matching = paragraphs.flatMap((part, index) => (wordsOf(part).some((word) => words.has(word)) ? [index] : []));
+    const hit = matching[0];
+    if (hit === undefined || paragraphs.length < 2)
+        return { around: [], moreMatches: 0 };
     const from = Math.max(0, hit - window.before);
-    return paragraphs.slice(from, hit + window.after + 1).map((part, index) => ({
+    const around = paragraphs.slice(from, hit + window.after + 1).map((part, index) => ({
         text: excerpt(part, query, 200, { literal: true }),
         found: from + index === hit,
     }));
+    return { around, moreMatches: matching.length - 1 };
 };
+/** 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) => documentMatches(text, [query], window).around;
 /**
  * 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-request.d.ts

@@ -7,10 +7,7 @@ export interface ProjectGatheringRequest {
         aliases?: string[];
     };
     keywords?: string[];
-    people?: {
-        name: string;
-        reference?: string;
-    }[];
+    people?: ProjectPerson[];
     sources: ContextSource[];
     /** Chats the host confirmed as the project's; each is read whole, through the source of its own account. */
     linkedChats?: ProjectLinkedChat[];
@@ -30,6 +27,20 @@ export interface ProjectGatheringRequest {
     checkpoint?: string;
     signal?: AbortSignal;
 }
+/**
+ * `name` is searched as words; `senders` are the person's stored identities, and every message or mail one of them
+ * wrote in the window is read. A sender lane needs the person's `reference`.
+ */
+export interface ProjectPerson {
+    name?: string;
+    reference?: string;
+    senders?: ProjectSender[];
+}
+/** One stored identity by its provider and the provider's own id; an email identity's id is its address. */
+export interface ProjectSender {
+    provider: string;
+    id: string;
+}
 export interface ProjectLinkedChat {
     provider: string;
     account: string;
@@ -42,13 +53,15 @@ export interface ProjectGatheringBudgets {
     maxElapsedMs?: number;
     maxItems?: number;
 }
-export type ProjectLaneKind = "project" | "key" | "alias" | "keyword" | "person" | "linked-chat";
+export type ProjectLaneKind = "project" | "key" | "alias" | "keyword" | "person" | "sender" | "linked-chat";
 export interface ProjectLane {
     id: string;
     kinds: ProjectLaneKind[];
-    /** Null for a linked chat's lane, which reads every message of the chat. */
+    /** Null for a linked chat's or a sender's lane, which read every message of the chat or of the sender. */
     query: string | null;
     people: string[];
+    /** A sender lane only: the identities whose messages and mail it reads. */
+    senders?: ProjectSender[];
     /** A linked chat's lane only: the chat's reference. */
     chat?: string;
 }
@@ -96,10 +109,18 @@ export declare const projectGatheringRequest: (input: ProjectGatheringRequest, n
         aliases: string[];
     };
     keywords: string[];
-    people: {
+    people: ({
         name: string;
         reference: string | null;
-    }[];
+        senders?: undefined;
+    } | {
+        name: string | null;
+        reference: string | null;
+        senders: {
+            provider: string;
+            id: string;
+        }[];
+    })[];
     lanes: ProjectLane[];
     sources: ContextSource[];
     linkedChats: {
@@ -148,6 +169,7 @@ export declare const projectUnits: (plan: ProjectGatheringPlan, window: {
         before: number;
     };
     chat: string | undefined;
+    senders: string[] | undefined;
 }[];
 export declare const seenKey: (ref: string) => string;
 export declare const encodeCheckpoint: (checkpoint: ProjectGatheringCheckpoint) => string;

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

@@ -6,7 +6,15 @@ import { formatReference } from "../domain/references.js";
 const DAY = 86400000;
 const MAX_TIME = 8_640_000_000_000_000;
 export const CONTEXT_CHUNK_DAYS = 90;
-const LIMITS = { lanes: 16, sources: 32, units: 512, lookbackDays: 730, people: 16, linkedChats: 16 };
+const LIMITS = {
+    lanes: 16,
+    sources: 32,
+    units: 512,
+    lookbackDays: 730,
+    people: 16,
+    linkedChats: 16,
+    senders: 16,
+};
 const BUDGETS = {
     maxReads: [48, 512],
     maxReadBytes: [2097152, 16777216],
@@ -77,11 +85,29 @@ export const projectGatheringRequest = (input, now) => {
     const people = list(input.people, "people", LIMITS.people).map((person, i) => {
         if (!person || typeof person !== "object")
             return fail(`people.${i} needs a name`, `people.${i}`);
-        known(person, ["name", "reference"], `people.${i}.`);
+        known(person, ["name", "reference", "senders"], `people.${i}.`);
         const p = person;
+        const reference = p.reference === undefined ? null : text(p.reference, `people.${i}.reference`, 1024);
+        if (p.senders === undefined)
+            return { name: laneQuery(p.name, `people.${i}.name`), reference };
+        const senders = list(p.senders, `people.${i}.senders`, LIMITS.senders).map((value, j) => {
+            const name = `people.${i}.senders.${j}`;
+            if (!value || typeof value !== "object")
+                return fail(`${name} needs provider and id`, name);
+            known(value, ["provider", "id"], `${name}.`);
+            const given = value;
+            return { provider: text(given.provider, `${name}.provider`, 128), id: text(given.id, `${name}.id`, 1024) };
+        });
+        if (!senders.length)
+            fail(`people.${i}.senders needs at least one identity`, `people.${i}.senders`);
+        if (new Set(senders.map((one) => JSON.stringify([one.provider, one.id]))).size !== senders.length)
+            fail(`people.${i}.senders lists one identity twice`, `people.${i}.senders`);
+        if (reference === null)
+            fail(`people.${i} needs a reference to read by sender`, `people.${i}.reference`);
         return {
-            name: laneQuery(p.name, `people.${i}.name`),
-            reference: p.reference === undefined ? null : text(p.reference, `people.${i}.reference`, 1024),
+            name: p.name === undefined ? null : laneQuery(p.name, `people.${i}.name`),
+            reference,
+            senders,
         };
     });
     if (input.scope !== "explicit" && input.scope !== "all-connected")
@@ -139,7 +165,17 @@ export const projectGatheringRequest = (input, now) => {
     for (const k of keywords)
         lane("keyword", k);
     for (const p of people)
-        lane("person", p.name, p.reference ?? p.name);
+        if (p.name !== null)
+            lane("person", p.name, p.reference ?? p.name);
+    for (const p of people)
+        if (p.senders && p.reference !== null)
+            lanes.push({
+                id: `l${lanes.length + 1}`,
+                kinds: ["sender"],
+                query: null,
+                people: [p.reference],
+                senders: p.senders,
+            });
     if (lanes.length > LIMITS.lanes)
         fail(`at most ${LIMITS.lanes} distinct search lanes`, "keywords");
     for (const linked of linkedChats) {
@@ -248,16 +284,33 @@ export const projectUnits = (plan, window) => {
         sourceIndex,
         chunk,
         chat: undefined,
+        senders: undefined,
     }))));
-    // Appended after every literal unit: a checkpoint from a run without links keeps its unit order, and in each
+    // Only the sources of a sender's own provider: an identity of one messenger never wrote in another.
+    const bySender = chunks.flatMap((chunk) => plan.lanes.flatMap((lane) => plan.sources.flatMap((source, sourceIndex) => {
+        if (!lane.senders || (source.kind !== "message" && source.kind !== "mail"))
+            return [];
+        const ids = lane.senders.filter((one) => one.provider === source.provider).map((one) => one.id);
+        return ids.length ? [{ lane, source, sourceIndex, chunk, chat: undefined, senders: ids }] : [];
+    })));
+    // Appended after every literal and sender unit: a checkpoint from a run without links keeps its unit order, and in each
     // round a literal lane labels a shared hit before the linked chat does.
     const linked = chunks.flatMap((chunk) => plan.linkedChats.flatMap(({ lane, source, chat }) => {
         const found = plan.lanes.find((l) => l.id === lane);
         return found && source !== null
-            ? [{ lane: found, source: plan.sources[source], sourceIndex: source, chunk, chat }]
+            ? [
+                {
+                    lane: found,
+                    source: plan.sources[source],
+                    sourceIndex: source,
+                    chunk,
+                    chat,
+                    senders: undefined,
+                },
+            ]
             : [];
     }));
-    const units = [...literal, ...linked];
+    const units = [...literal, ...bySender, ...linked];
     if (units.length > LIMITS.units)
         fail(`${units.length} lane × source × 90-day reads exceed ${LIMITS.units}; narrow the lanes, sources or window`);
     return units;

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

@@ -36,9 +36,14 @@ export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text"> {
     fingerprint: string;
     around?: ProjectNeighbour[] | null;
     aroundIssue?: string | null;
+    /** A document hit with `around`: how many paragraphs after the one it centres on also name a lane word. */
+    moreMatches?: number;
 }
-/** Strongest first: a hit that names the project, then one only from a linked chat, then one naming only a person. */
-export type ProjectEvidenceContext = "project" | "linked-chat" | "person-only";
+/**
+ * Strongest first: a hit that names the project, then one only from a linked chat, then one a person wrote, then one
+ * naming only a person.
+ */
+export type ProjectEvidenceContext = "project" | "linked-chat" | "sender" | "person-only";
 export type ProjectGatheringStop = "reads" | "read-bytes" | "elapsed" | "items" | null;
 export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, request: ProjectGatheringRequest) => Promise<{
     schemaVersion: 1;

package/dist/services/project-gathering.js

@@ -2,15 +2,17 @@ import { CliError } from "@wirecat/cli-base";
 import { CONTEXT_MAX_READ_BYTES, contextEvidenceFingerprint } from "../context/evidence.js";
 import { createContextEvidenceReader } from "./context-evidence.js";
 import { excerpt } from "./excerpt.js";
-import { attachNeighbours, documentPassage, } from "./project-gathering-around.js";
+import { attachNeighbours, documentMatches, } from "./project-gathering-around.js";
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
-const CONTEXTS = ["person-only", "linked-chat", "project"];
+const CONTEXTS = ["person-only", "sender", "linked-chat", "project"];
 const contextOf = (lane) => lane.kinds.includes("linked-chat")
     ? "linked-chat"
-    : lane.kinds.every((k) => k === "person")
-        ? "person-only"
-        : "project";
+    : lane.kinds.includes("sender")
+        ? "sender"
+        : lane.kinds.every((k) => k === "person")
+            ? "person-only"
+            : "project";
 export const gatherProjectEvidence = async (ports, request) => {
     if (!ports?.evidence || typeof ports.evidence.read !== "function")
         throw new CliError("configuration_error", "stored context reads are unavailable in this store");
@@ -31,6 +33,7 @@ export const gatherProjectEvidence = async (ports, request) => {
         plan.sources.map(() => ({ state: "not-requested", history: null, code: null }));
     const seen = new Set(previous?.seen ?? []);
     const signal = plan.signal;
+    const queries = plan.lanes.flatMap((lane) => (lane.query === null ? [] : [lane.query]));
     if (plan.fetch === "before-read" && !ports.fetcher)
         throw new CliError("configuration_error", "this host cannot fetch source history; use fetch none", {
             param: "fetch",
@@ -114,8 +117,10 @@ export const gatherProjectEvidence = async (ports, request) => {
             context: contextOf(lane),
         };
         if (kind === "document" && lane.query !== null && plan.around.before + plan.around.after) {
+            const passage = documentMatches(item.text, queries, plan.around);
             entry.around = [];
-            for (const part of documentPassage(item.text, lane.query, plan.around)) {
+            entry.moreMatches = passage.moreMatches;
+            for (const part of passage.around) {
                 const bytes = Buffer.byteLength(part.text);
                 if (bytes > plan.budgets.maxReadBytes - usage.readBytes - usage.aroundBytes) {
                     entry.aroundIssue = "read-bytes";
@@ -161,7 +166,11 @@ export const gatherProjectEvidence = async (ports, request) => {
                 try {
                     const page = await reader.read({
                         source: unit.source,
-                        ...(unit.chat === undefined ? { query: unit.lane.query ?? undefined } : { chat: unit.chat }),
+                        ...(unit.chat !== undefined
+                            ? { chat: unit.chat }
+                            : unit.senders !== undefined
+                                ? { senders: unit.senders }
+                                : { query: unit.lane.query ?? undefined }),
                         after: unit.chunk.after,
                         before: unit.chunk.before,
                         limit,

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

@@ -20,6 +20,7 @@ const corpora = {
         join: "JOIN chats c ON c.id=n.chat_id AND c.account_id=n.account_id",
         where: "c.searchable=1",
         chats: "chats",
+        sender: "n.sender_identity_id",
         // A read that names the chat sees it even when it is hidden from search (searchable=0).
         named: "c.external_id=?",
     },
@@ -36,6 +37,7 @@ const corpora = {
         join: "JOIN email_threads c ON c.id=n.email_thread_id AND c.account_id=n.account_id",
         where: "a.provider='email'",
         chats: "email_threads",
+        sender: "n.from_identity_id",
         named: "a.provider='email' AND c.external_id=?",
     },
     document: {
@@ -51,6 +53,7 @@ const corpora = {
         join: "",
         where: "n.body IS NOT NULL AND CASE WHEN json_valid(n.metadata) THEN coalesce(json_extract(n.metadata, '$.catalog.active'),1) ELSE 1 END=1",
         chats: null,
+        sender: null,
         named: null,
     },
 };
@@ -58,11 +61,12 @@ const corpora = {
 export const contextEvidenceOver = ({ database }) => ({
     async read(original) {
         const request = contextEvidenceRequest(original);
-        const { source, words, chat, after, before, limit, maxReadBytes, cursor, signal } = request;
+        const { source, words, chat, senders, after, before, limit, maxReadBytes, cursor, signal } = request;
         if (source.kind === "meeting")
             return readMeetingContextEvidence(database, request);
         const corpus = corpora[source.kind];
-        const scope = contextCursorScope({ source, query: request.query, chat, after, before });
+        const scope = contextCursorScope({ source, query: request.query, chat, senders, after, before });
+        const searched = chat === undefined && senders === undefined;
         signal?.throwIfAborted();
         return read(database, () => {
             const coverage = {
@@ -71,7 +75,7 @@ export const contextEvidenceOver = ({ database }) => ({
                 hasMore: false,
                 hasUndated: false,
                 completeness: "unknown",
-                matching: chat === undefined ? "literal-words" : "chat",
+                matching: chat !== undefined ? "chat" : senders !== undefined ? "sender" : "literal-words",
                 consistency: "snapshot-per-page",
             };
             const empty = () => ({ source, items: [], next: null, readBytes: 0, coverage });
@@ -87,19 +91,27 @@ export const contextEvidenceOver = ({ database }) => ({
                     .get(source.accountId, chat))
                 return empty();
             coverage.available = true;
-            const scopeParams = chat === undefined ? accountParams : [...accountParams, chat];
+            const scopeParams = chat !== undefined
+                ? [...accountParams, chat]
+                : senders !== undefined
+                    ? [...accountParams, ...senders]
+                    : accountParams;
+            const byChat = chat === undefined ? corpus.where : corpus.named;
+            const bySender = senders === undefined
+                ? ""
+                : ` AND ${corpus.sender} IN (SELECT id FROM identities WHERE provider=a.provider AND external_id IN (${senders.map(() => "?").join(",")}))`;
             const base = `FROM ${corpus.table} n JOIN accounts a ON a.id=n.account_id ${corpus.join}
         WHERE n.account_id=? AND a.provider=? AND a.external_id=? AND n.deleted_at IS NULL
-        AND ${chat === undefined ? corpus.where : corpus.named}`;
-            // A chat read uses no word index, so words still waiting for it hide nothing.
-            if (chat !== undefined)
+        AND ${byChat}${bySender}`;
+            // A chat or sender read uses no word index, so words still waiting for it hide nothing.
+            if (!searched)
                 coverage.index = "ready";
             else if (!database.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(corpus.index)) {
                 coverage.index = "missing";
                 return empty();
             }
             coverage.hasUndated = Boolean(database.prepare(`SELECT 1 ${base} AND ${corpus.at} IS NULL LIMIT 1`).get(...scopeParams));
-            if (chat === undefined && source.kind === "message") {
+            if (searched && source.kind === "message") {
                 const state = database
                     .prepare("SELECT watermark,filled_through FROM search_index_state WHERE name='message_words'")
                     .get();
@@ -112,7 +124,7 @@ export const contextEvidenceOver = ({ database }) => ({
                         ? "pending"
                         : "ready";
             }
-            else if (chat === undefined) {
+            else if (searched) {
                 coverage.index = database
                     .prepare(`SELECT 1 ${base} AND ${corpus.at}>=? AND ${corpus.at}<?
           AND EXISTS(SELECT 1 FROM ${source.kind === "mail" ? "email" : "document"}_index_pending p
@@ -125,12 +137,12 @@ export const contextEvidenceOver = ({ database }) => ({
         ${corpus.title} AS title,${corpus.body} AS body,${corpus.url} AS url,${corpus.at} AS at,
         n.updated_at,${corpus.revision} AS revision,${corpus.timeKind} AS time_kind ${base}
         AND ${corpus.at}>=? AND ${corpus.at}<?
-        ${chat !== undefined ? "" : `AND n.id IN (SELECT rowid FROM ${corpus.index} WHERE ${corpus.index} MATCH ?)`}
-        ${chat !== undefined ? "" : source.kind === "message" ? `AND n.normalized_text IS NOT NULL AND n.normalizer_version=${NORMALIZER_VERSION}` : `AND NOT EXISTS(SELECT 1 FROM ${source.kind === "mail" ? "email" : "document"}_index_pending p WHERE p.id=n.id AND p.indexable_type='${source.kind === "mail" ? "email" : "document"}')`}
+        ${!searched ? "" : `AND n.id IN (SELECT rowid FROM ${corpus.index} WHERE ${corpus.index} MATCH ?)`}
+        ${!searched ? "" : source.kind === "message" ? `AND n.normalized_text IS NOT NULL AND n.normalizer_version=${NORMALIZER_VERSION}` : `AND NOT EXISTS(SELECT 1 FROM ${source.kind === "mail" ? "email" : "document"}_index_pending p WHERE p.id=n.id AND p.indexable_type='${source.kind === "mail" ? "email" : "document"}')`}
         ${cursor ? `AND (${corpus.at}<? OR (${corpus.at}=? AND n.id<?))` : ""}
         ORDER BY ${corpus.at} DESC,n.id DESC LIMIT ?`;
             const params = [...scopeParams, after, before];
-            if (chat === undefined)
+            if (searched)
                 params.push(words.map((w) => `normalized_text:"${normalize(w)}"`).join(" AND "));
             if (cursor)
                 params.push(cursor.at, cursor.at, cursor.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.376.0",
+  "version": "0.378.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",