@wirecat/cli-core 0.494.0 → 0.495.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@ shape of this file.
 
 ## Unreleased
 
+## 0.495.0 — 31.10.2026
+
+### Changed — may break callers
+
+- **`gatherProjectEvidence` says what the store holds of each linked chat, and which ones the run never reached.** A new
+  optional port `coverage(account, chatIds)` (pass `chatCoverage` over the store) fills each `linkedChats` row with
+  `title` (the chat row's, also for a chat with no stored message), `completeness` and `held`; without it they are `null` and `completeness` stays `"unknown"`. The top-level
+  `completeness` is `partial` when any linked chat is `partial`, `unknown` when none is but one is `unknown` (a chat the
+  store has no row for counts), and `complete` only when every linked chat in scope is. `complete` keeps its meaning,
+  "the planned reads finished"; a host's `meta.complete` is `complete && completeness === "complete"`. A linked chat
+  none of whose reads has started is `state: "pending"` and has no `items` or `capped`, where it said `in-scope` with
+  `items: 0, capped: false`. `ChatCoverage.title` now comes from the chat row when the chat has no message, through the
+  new `store.chats.chatTitle`.
+
 ## 0.494.0 — 31.10.2026
 
 ### Security

package/dist/services/chat-coverage.d.ts

@@ -3,7 +3,7 @@ import type { AccountKey, ChatCompleteness, MessageStore } from "../store/store.
 /** What the store holds of one chat, and how far that goes: never message text. */
 export interface ChatCoverage {
     chatId: Id;
-    /** `null` while the store holds no message of the chat: titles come with the stats. */
+    /** The chat row's title; `null` when the store has no row for the chat or the row has none. */
     title: string | null;
     completeness: ChatCompleteness;
     held: {

package/dist/services/chat-coverage.js

@@ -9,6 +9,7 @@ export const chatCoverage = async (store, account, chatIds) => {
     const found = new Map((await store.chats.chatCompleteness(account, ids)).map((one) => [one.chatId, one]));
     return Promise.all(ids.map(async (chatId) => {
         const [stats] = await store.chats.chatStats(account, chatId);
+        const title = stats?.title ?? (await store.chats.chatTitle(account, chatId));
         const completeness = found.get(chatId) ?? {
             chatId,
             state: "unknown",
@@ -19,7 +20,7 @@ export const chatCoverage = async (store, account, chatIds) => {
         };
         return {
             chatId,
-            title: stats?.title ?? null,
+            title,
             completeness,
             held: { messages: stats?.messages ?? 0, oldestAt: stats?.oldestAt ?? null, newestAt: stats?.newestAt ?? null },
         };

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

@@ -1,4 +1,6 @@
 import type { ContextEvidenceItem, ContextEvidenceReader, ContextIndex, ContextSource } from "../context/evidence.js";
+import type { AccountKey } from "../store/types.js";
+import type { ChatCoverage } from "./chat-coverage.js";
 import { type ProjectNeighbour, type ProjectNeighbourReader } from "./project-gathering-around.js";
 import { type ProjectFetchState, type ProjectGatheringRequest, type ProjectLane } from "./project-gathering-request.js";
 /** A connector's history fetch into the store; the store reads that follow find what it saved. */
@@ -18,6 +20,8 @@ export interface ProjectGatheringPorts {
     fetcher?: ProjectSourceFetcher;
     index?: ContextIndex;
     neighbours?: ProjectNeighbourReader;
+    /** What the store holds of the named chats of one account, e.g. `chatCoverage` over the store. */
+    coverage?: (account: AccountKey, chatIds: string[]) => Promise<ChatCoverage[]>;
     now?: () => number;
 }
 export interface ProjectIndexCatchUp {
@@ -88,9 +92,16 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
         ref: string;
         source: number | null;
         lane: string | null;
-        state: "in-scope" | "out-of-scope" | "unavailable";
-        items: number;
-        capped: boolean;
+        state: "in-scope" | "out-of-scope" | "pending" | "unavailable";
+        title: string | null;
+        completeness: import("../store/exports.js").ChatCompleteness | null;
+        held: {
+            messages: number;
+            oldestAt: string | null;
+            newestAt: string | null;
+        } | null;
+        items?: number | undefined;
+        capped?: boolean | undefined;
     }[];
     fetch: {
         state: ProjectFetchState;
@@ -136,7 +147,7 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
     };
     stopped: ProjectGatheringStop;
     complete: boolean;
-    completeness: "unknown";
+    completeness: "complete" | "partial" | "unknown";
     checkpoint: string | null;
 }>;
 export type ProjectGathering = Awaited<ReturnType<typeof gatherProjectEvidence>>;

package/dist/services/project-gathering.js

@@ -264,6 +264,20 @@ export const gatherProjectEvidence = async (ports, request) => {
         },
     }, (ref) => byRef.has(ref) || seen.has(seenKey(ref)), signal);
     const people = peopleOf(items, senderOf);
+    const coverageOf = new Map();
+    if (ports.coverage) {
+        const byAccount = new Map();
+        for (const { provider, account, chat, source } of plan.linkedChats) {
+            if (source === null)
+                continue;
+            const group = byAccount.get(JSON.stringify([provider, account])) ?? { account: { provider, account }, chats: [] };
+            group.chats.push(chat);
+            byAccount.set(JSON.stringify([provider, account]), group);
+        }
+        for (const [key, { account, chats }] of byAccount)
+            for (const row of await ports.coverage(account, chats))
+                coverageOf.set(`${key}${row.chatId}`, row);
+    }
     const totals = {
         reads: (previous?.totals.reads ?? 0) + usage.reads,
         readBytes: (previous?.totals.readBytes ?? 0) + usage.readBytes,
@@ -284,6 +298,39 @@ export const gatherProjectEvidence = async (ports, request) => {
         seen: [...seen],
         totals,
     };
+    const linkedRows = plan.linkedChats.map(({ provider, account, chat, ref, source, lane }) => {
+        const laneUnits = units.flatMap((unit, index) => (unit.lane.id === lane ? [progress[index]] : []));
+        const state = source === null
+            ? "out-of-scope"
+            : laneUnits.every((u) => u?.state === "unavailable")
+                ? "unavailable"
+                : laneUnits.every((u) => u?.state === "pending")
+                    ? "pending"
+                    : "in-scope";
+        const row = coverageOf.get(`${JSON.stringify([provider, account])}${chat}`);
+        return {
+            provider,
+            account,
+            chat,
+            ref,
+            source,
+            lane,
+            state,
+            title: row?.title ?? null,
+            completeness: row?.completeness ?? null,
+            held: row?.held ?? null,
+            ...(state === "pending" ? {} : { items: lane === null ? 0 : (linkedTaken.get(lane) ?? 0) }),
+            ...(state === "pending" ? {} : { capped: lane !== null && capped.has(lane) }),
+        };
+    });
+    const states = linkedRows.flatMap((row) => (row.completeness ? [row.completeness.state] : []));
+    const completeness = !states.length
+        ? "unknown"
+        : states.includes("partial")
+            ? "partial"
+            : states.includes("unknown") || states.length < linkedRows.filter((row) => row.source !== null).length
+                ? "unknown"
+                : "complete";
     return {
         schemaVersion: 1,
         runKey: plan.runKey,
@@ -300,21 +347,7 @@ export const gatherProjectEvidence = async (ports, request) => {
         },
         scope: { origin: plan.scope, sources: plan.sources },
         lanes: plan.lanes,
-        linkedChats: plan.linkedChats.map(({ provider, account, chat, ref, source, lane }) => ({
-            provider,
-            account,
-            chat,
-            ref,
-            source,
-            lane,
-            state: source === null
-                ? "out-of-scope"
-                : units.every((unit, index) => unit.lane.id !== lane || progress[index]?.state === "unavailable")
-                    ? "unavailable"
-                    : "in-scope",
-            items: lane === null ? 0 : (linkedTaken.get(lane) ?? 0),
-            capped: lane !== null && capped.has(lane),
-        })),
+        linkedChats: linkedRows,
         fetch: fetched.map((f, index) => ({ source: index, ...f })),
         index: indexed,
         units: units.map((unit, index) => ({
@@ -335,7 +368,7 @@ export const gatherProjectEvidence = async (ports, request) => {
         totals,
         stopped,
         complete: !resumable,
-        completeness: "unknown",
+        completeness,
         checkpoint: resumable ? encodeCheckpoint(checkpoint) : null,
     };
 };

package/dist/store/chats.d.ts

@@ -66,6 +66,8 @@ export interface ChatsStore {
     renamedChatId(key: AccountKey, chatId: Id): Promise<Id | undefined>;
     /** A stored chat's kind, with or without messages; `undefined` when the store does not know the chat. */
     chatKind(key: AccountKey, chatId: Id): Promise<ChatKind | undefined>;
+    /** A stored chat's title, with or without messages; `null` when it has none or the store does not know the chat. */
+    chatTitle(key: AccountKey, chatId: Id): Promise<string | null>;
     /** Per chat that spoke since `since` (ms): its newest message and who sent it when stored, never the text. */
     /** `where` is a `tasks agenda` query compiled over `AGENDA_COLUMNS`. */
     chatActivity(key: AccountKey, since: number, where?: Where): Promise<{

package/dist/store/chats.js

@@ -94,6 +94,15 @@ export const chatsStoreOver = (context) => {
                 .get(accountKey, chatId);
             return row ? String(row.kind) : undefined;
         },
+        chatTitle: async (key, chatId) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined)
+                return null;
+            const row = context.database
+                .prepare("SELECT title FROM chats WHERE account_id = ? AND external_id = ?")
+                .get(accountKey, chatId);
+            return row?.title == null ? null : String(row.title);
+        },
         chatActivity: async (key, since, where) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined

package/package.json

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