@wirecat/cli-core 0.416.0 → 0.418.0

package/CHANGELOG.md

@@ -7,6 +7,22 @@ shape of this file.
 
 ## Unreleased
 
+## 0.418.0 — 25.10.2026
+
+### Added
+
+- **Project evidence says who wrote it.** `gatherProjectEvidence` returns `people`: who sent the run's message and mail items, person by person from the stored contacts (identities a person holds across messengers and mail count as one), with an item count split by context, the owner left out, at most 20 entries and `peopleOmitted` for the rest. It never matches names in the text. The context reader's message and mail items carry `sender` (identity, linked person, `owner`) to make that possible; project and meeting preparation items do not repeat it. See `docs/dev/PROJECT-GATHERING.md`.
+
+### Fixed
+
+- **YAML front matter at the top of a Markdown file is no longer read as a rule and a heading.** `markdownBlocks` leaves it out, so a mirrored Doc does not show it, and a Doc edit written back to the file keeps it byte for byte. A `---` line further down is still a rule.
+
+## 0.417.0 — 25.10.2026
+
+### Fixed
+
+- **`--discover` finds messages for a question that ends with "?".** When the question planner left a question as written ("Why did we drop Manchester?", «Почему поменяли цену?»), its "?" parsed as a one-character wildcard and discovery fell back to strict search, which found nothing. In discovery, a "?" after a word and before a space or the end is now punctuation. Strict search is unchanged.
+
 ## 0.416.0 — 25.10.2026
 
 ### Fixed

package/dist/cli/meeting-communications.d.ts

@@ -39,6 +39,7 @@ export declare const mapPreparationCommunications: ({ items, ...section }: Meeti
         text: string;
         timeKind: "sent" | "source-modified" | "stored-update" | "meeting-start";
         revision: number | null;
+        sender?: import("../context/evidence.js").ContextEvidenceSender | null;
         selectionId: string;
         textTruncated: boolean;
         at: string;

package/dist/context/evidence-response.js

@@ -62,6 +62,15 @@ export const validateContextEvidencePage = (page, request) => {
                 ? !["source-modified", "stored-update"].includes(item.timeKind)
                 : item.timeKind !== (source.kind === "meeting" ? "meeting-start" : "sent"))
                 fail();
+            const sender = item.sender;
+            if (sender != null &&
+                (typeof sender !== "object" ||
+                    typeof sender.provider !== "string" ||
+                    typeof sender.id !== "string" ||
+                    typeof sender.owner !== "boolean" ||
+                    [sender.name, sender.person, sender.personName].some((v) => v !== null && typeof v !== "string") ||
+                    (sender.person !== null && !/^person:[1-9]\d*$/.test(sender.person))))
+                fail();
             const text = [item.text, item.title, item.url, item.provider, item.account, item.timeKind];
             if (text.some((value) => value !== null && typeof value !== "string"))
                 fail();

package/dist/context/evidence.d.ts

@@ -36,6 +36,19 @@ export interface ContextEvidenceItem {
     timeKind: "sent" | "source-modified" | "stored-update" | "meeting-start";
     updatedAt: number;
     revision: number | null;
+    /** Who wrote a message or email, as stored; absent for documents and meeting cues. */
+    sender?: ContextEvidenceSender | null;
+}
+export interface ContextEvidenceSender {
+    provider: string;
+    /** The identity's id in its provider; an email address for mail. */
+    id: string;
+    name: string | null;
+    /** `person:<id>` when the store links the identity to a person. */
+    person: string | null;
+    personName: string | null;
+    /** The identity is the owner's: linked to the owner person, or the account's own. */
+    owner: boolean;
 }
 export interface ContextEvidencePage {
     source: ContextSource;

package/dist/documents/markdown-blocks.js

@@ -8,8 +8,11 @@ const loadParser = () => (parser ??= Promise.all([
 ]).then(([{ fromMarkdown }, { gfmFromMarkdown }, { gfm }]) => (markdown) => fromMarkdown(markdown, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] })));
 /** Markdown (CommonMark + GFM tables, task lists and strikethrough) as the blocks a provider can write natively. */
 export const markdownBlocks = async (markdown) => (await placedMarkdownBlocks(markdown)).map((placed) => placed.block);
+// YAML front matter is the file's metadata, not its text: CommonMark alone reads it as a rule and a heading.
+const FRONT_MATTER = /^---[ \t]*\r?\n(?:[^\n]*\n)*?---[ \t]*(?=\r?\n|$)/;
 export const placedMarkdownBlocks = async (markdown) => {
-    const tree = (await loadParser())(markdown);
+    // Blanked, not cut, so every offset and column still points into the file as written.
+    const tree = (await loadParser())(markdown.replace(FRONT_MATTER, (matter) => matter.replace(/[^\n]/g, " ")));
     const definitions = new Map();
     const collect = (node) => {
         if (node.type === "definition")

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

@@ -5,6 +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, ContextRecordReader, ContextSource, } from "../context/evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, 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/index.d.ts

@@ -1,5 +1,5 @@
 import { type BotCheckService } from "../botcheck/service.js";
-export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
 export type { MediaArchiveOptions, MediaArchivePorts } from "./media-archive.js";
@@ -8,7 +8,7 @@ export type { MediaArchiveEntry, MediaIdentity } from "./media-archive-manifest.
 export type { MoveMediaArchiveOptions } from "./media-archive-move.js";
 export { moveMediaArchive } from "./media-archive-move.js";
 export { type DownloadedModel, downloadImageModel, downloadTextModel, type ModelDownloadOptions, } from "./model-downloads.js";
-export type { ProjectEvidenceContext, ProjectEvidenceItem, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectIndexCatchUp, ProjectSourceFetcher, } from "./project-gathering.js";
+export type { ProjectEvidenceContext, ProjectEvidenceItem, ProjectEvidencePerson, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectIndexCatchUp, ProjectSourceFetcher, } from "./project-gathering.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
 export type { ProjectNeighbour, ProjectNeighbourReader } from "./project-gathering-around.js";
 export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";

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

@@ -55,7 +55,8 @@ export const readPreparationCommunications = async (plan, signal) => {
                 const text = excerpt(item.text, plan.input.query, 300, { literal: true });
                 // excerpt() puts every text on one line, so only a shorter result means words were cut.
                 const whole = item.text.replace(/\s+/g, " ").trim();
-                items.push({ ...item, text, selectionId: read.id, textTruncated: text !== whole });
+                const { sender: _, ...rest } = item;
+                items.push({ ...rest, text, selectionId: read.id, textTruncated: text !== whole });
             }
         }
         catch (error) {

package/dist/services/messages-discovery.d.ts

@@ -1,4 +1,4 @@
 import type { MessengerTraits } from "../ports/traits.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
 import type { SearchFound, SearchQuery } from "./messages.js";
-export declare const searchDiscovery: (store: MessageStore, account: AccountKey, request: SearchQuery, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app" | "history" | "provider">>) => Promise<SearchFound>;
+export declare const searchDiscovery: (store: MessageStore, account: AccountKey, asked: SearchQuery, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app" | "history" | "provider">>) => Promise<SearchFound>;

package/dist/services/messages-discovery.js

@@ -5,7 +5,11 @@ import { exhausted, QUERY_LIMITS } from "../search/lucene/types.js";
 import { planQuestion, words } from "../search/question-plan.js";
 import { searchCombined } from "./messages-combined.js";
 import { prepareLucene, searchLucene } from "./messages-search.js";
-export const searchDiscovery = async (store, account, request, messenger = {}) => {
+export const searchDiscovery = async (store, account, asked, messenger = {}) => {
+    // A question's own "?" would parse as a one-character wildcard and send it to strict search (BUG-395).
+    const request = asked.ast !== undefined || asked.exact || !asked.text
+        ? asked
+        : { ...asked, text: asked.text.replace(/(?<=\p{L})\?(?=\s|$)/gu, "") };
     const original = await prepareLucene(store, account, request, messenger);
     const text = request.text ?? "";
     const plan = planQuestion(text, request.ast !== undefined || !!request.exact || !!request.newest);

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

@@ -26,7 +26,7 @@ export interface ProjectIndexCatchUp {
     documents: number;
     code: string | null;
 }
-export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text"> {
+export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text" | "sender"> {
     kind: ContextSource["kind"];
     source: number;
     text: string;
@@ -44,6 +44,18 @@ export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text"> {
  * naming only a person.
  */
 export type ProjectEvidenceContext = "project" | "linked-chat" | "sender" | "person-only";
+/** Who wrote this run's message and mail items: one stored person, or one identity linked to none. */
+export interface ProjectEvidencePerson {
+    person: string | null;
+    name: string;
+    identities: {
+        provider: string;
+        account: string;
+        id: string;
+    }[];
+    items: number;
+    contexts: Partial<Record<ProjectEvidenceContext, number>>;
+}
 export type ProjectGatheringStop = "reads" | "read-bytes" | "elapsed" | "items" | null;
 export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, request: ProjectGatheringRequest) => Promise<{
     schemaVersion: 1;
@@ -97,6 +109,8 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
         issue: string | null;
     }[];
     items: ProjectEvidenceItem[];
+    people: ProjectEvidencePerson[];
+    peopleOmitted: number;
     oversized: {
         ref: string;
         lanes: string[];

package/dist/services/project-gathering.js

@@ -6,6 +6,7 @@ import { attachNeighbours, documentMatches, } from "./project-gathering-around.j
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
 const PAGE = 20;
+const PEOPLE = 20;
 const CONTEXTS = ["person-only", "sender", "linked-chat", "project"];
 const contextOf = (lane) => lane.kinds.includes("linked-chat")
     ? "linked-chat"
@@ -81,6 +82,7 @@ export const gatherProjectEvidence = async (ports, request) => {
     const usage = { reads: 0, readBytes: 0, aroundBytes: 0, items: 0 };
     const items = [];
     const byRef = new Map();
+    const senderOf = new Map();
     const matchedAgain = new Map();
     const oversized = new Map();
     let stopped = null;
@@ -117,8 +119,11 @@ export const gatherProjectEvidence = async (ports, request) => {
         seen.add(seenKey(item.ref));
         const short = excerpt(item.text, lane.query ?? "", 300, { literal: true });
         const fingerprint = contextEvidenceFingerprint(item);
+        const { sender, ...stored } = item;
+        if (sender)
+            senderOf.set(item.ref, sender);
         const entry = {
-            ...item,
+            ...stored,
             kind,
             source,
             text: short,
@@ -258,6 +263,7 @@ export const gatherProjectEvidence = async (ports, request) => {
             usage.aroundBytes += bytes;
         },
     }, (ref) => byRef.has(ref) || seen.has(seenKey(ref)), signal);
+    const people = peopleOf(items, senderOf);
     const totals = {
         reads: (previous?.totals.reads ?? 0) + usage.reads,
         readBytes: (previous?.totals.readBytes ?? 0) + usage.readBytes,
@@ -321,6 +327,8 @@ export const gatherProjectEvidence = async (ports, request) => {
             issue: progress[index]?.code ?? null,
         })),
         items,
+        people: people.slice(0, PEOPLE),
+        peopleOmitted: Math.max(0, people.length - PEOPLE),
         oversized: [...oversized.values()],
         matchedAgain: [...matchedAgain].map(([ref, lanes]) => ({ ref, lanes: [...lanes] })),
         usage: { ...usage, elapsedMs: now() - started },
@@ -331,3 +339,26 @@ export const gatherProjectEvidence = async (ports, request) => {
         checkpoint: resumable ? encodeCheckpoint(checkpoint) : null,
     };
 };
+/** The owner's own messages say nothing about who else is involved, so they are left out. */
+const peopleOf = (items, senderOf) => {
+    const byKey = new Map();
+    for (const item of items) {
+        const sender = senderOf.get(item.ref);
+        if (!sender || sender.owner)
+            continue;
+        const key = sender.person ?? JSON.stringify([sender.provider, sender.id]);
+        const found = byKey.get(key) ?? {
+            person: sender.person,
+            name: sender.personName ?? sender.name ?? sender.id,
+            identities: [],
+            items: 0,
+            contexts: {},
+        };
+        byKey.set(key, found);
+        if (!found.identities.some((i) => i.provider === sender.provider && i.account === item.account && i.id === sender.id))
+            found.identities.push({ provider: sender.provider, account: item.account, id: sender.id });
+        found.items++;
+        found.contexts[item.context] = (found.contexts[item.context] ?? 0) + 1;
+    }
+    return [...byKey.values()].sort((a, b) => b.items - a.items || a.name.localeCompare(b.name));
+};

package/dist/store/index.d.ts

@@ -1,4 +1,4 @@
-export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextSource, } from "../context/evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextSource, } from "../context/evidence.js";
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
 export type { TagConsolidationOptions, TagConsolidationPreview, TagConsolidationStore, } from "../domain/tag-consolidation.js";
 export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } from "../domain/tag-redirects.js";

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

@@ -100,9 +100,19 @@ export const contextEvidenceOver = ({ database }) => ({
             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
+            const from = `FROM ${corpus.table} n JOIN accounts a ON a.id=n.account_id ${corpus.join}`;
+            const where = `WHERE n.account_id=? AND a.provider=? AND a.external_id=? AND n.deleted_at IS NULL
         AND ${byChat}${bySender}`;
+            const base = `${from} ${where}`;
+            const author = corpus.sender === null
+                ? { join: "", columns: "NULL AS sender_id" }
+                : {
+                    join: `LEFT JOIN identities si ON si.id=${corpus.sender} LEFT JOIN identity_links sl ON sl.identity_id=si.id
+                LEFT JOIN persons sp ON sp.id=sl.person_id`,
+                    columns: `si.provider AS sender_provider,si.external_id AS sender_id,si.name AS sender_name,
+                sp.id AS sender_person,sp.name AS sender_person_name,
+                coalesce(sp.owner=1,0) OR (si.provider=a.provider AND si.external_id=a.external_id) AS sender_owner`,
+                };
             // A chat or sender read uses no word index, so words still waiting for it hide nothing.
             if (!searched)
                 coverage.index = "ready";
@@ -135,7 +145,8 @@ export const contextEvidenceOver = ({ database }) => ({
             }
             const selection = `SELECT n.id,n.external_id,${corpus.chat} AS chat,a.provider,a.external_id AS account,
         ${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}
+        n.updated_at,${corpus.revision} AS revision,${corpus.timeKind} AS time_kind,${author.columns}
+        ${from} ${author.join} ${where}
         AND ${corpus.at}>=? AND ${corpus.at}<?
         ${!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"}')`}
@@ -198,6 +209,20 @@ export const contextEvidenceOver = ({ database }) => ({
                     timeKind: row.time_kind,
                     updatedAt: Number(row.updated_at),
                     revision: row.revision == null ? null : Number(row.revision),
+                    ...(corpus.sender === null
+                        ? {}
+                        : {
+                            sender: row.sender_id == null
+                                ? null
+                                : {
+                                    provider: String(row.sender_provider),
+                                    id: String(row.sender_id),
+                                    name: row.sender_name == null ? null : String(row.sender_name),
+                                    person: row.sender_person == null ? null : `person:${row.sender_person}`,
+                                    personName: row.sender_person_name == null ? null : String(row.sender_person_name),
+                                    owner: Boolean(row.sender_owner),
+                                },
+                        }),
                 })),
             };
         });

package/package.json

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