@wirecat/cli-core 0.347.0 → 0.349.0

package/dist/runs/scope.js

@@ -21,6 +21,11 @@ export const currentRun = () => {
     return processScope;
 };
 export const inRun = (scope, body) => scopes.run(scope, body);
+/**
+ * A command as a person types it: `max personal store migrate`. A hint without the profile fails when copied,
+ * since no profile is assumed; outside a run with a profile it stays `max store migrate`.
+ */
+export const typedCommand = (tool, words, profile = currentRun().profile) => [tool, profile, words].filter((part) => part !== undefined && part !== "").join(" ");
 /**
  * For a one-shot command whose action runs outside `inRun` — max's `max bot`, recorded from commander's hooks, which
  * cannot wrap the action — so its answers' `meta.run_id` names the run `runs show` finds. Never in a server.

package/dist/services/archive.js

@@ -1,6 +1,7 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { CliError } from "@wirecat/cli-base";
 import { capability } from "../ports/messenger.js";
+import { typedCommand } from "../runs/scope.js";
 import { fetchedKey, historyStartKey, } from "../store/store.js";
 import { estimateBackfill } from "./backfill-estimate.js";
 import { actionable, batchProgress } from "./batch.js";
@@ -11,7 +12,7 @@ import { catchUpSearch, validateCatchUp } from "./search-catchup.js";
 const pushed = (deps, what) => {
     if (deps.reads === "store") {
         throw new CliError("validation_error", `${what} asks for older history, and this messenger pushes its history instead — keep ` +
-            `\`${deps.messenger.app.command} serve\` running`);
+            `\`${typedCommand(deps.messenger.app.command, "serve")}\` running`);
     }
 };
 /** The most messages a provider hands out per history request — Telegram's cap. */

package/dist/services/chats.js

@@ -4,6 +4,7 @@ import { botCheckService } from "../botcheck/service.js";
 import { threadIdOf } from "../domain/thread.js";
 import { capability } from "../ports/messenger.js";
 import { syncsOneChat } from "../ports/traits.js";
+import { typedCommand } from "../runs/scope.js";
 import { codeOf, guardedWrite } from "../sends/guarded.js";
 import { newOperationId } from "../sends/send-id.js";
 import { CHAT_COLUMNS, queryFilter, } from "../store/store.js";
@@ -147,7 +148,7 @@ export const chatsService = (deps) => ({
         const counted = counts.length > 0 ? { ...known, memberCounts: counts } : known;
         return completeness.state === "complete" || !syncsOneChat(deps.messenger)
             ? counted
-            : { ...counted, fetch: `${deps.messenger.app.command} messages sync ${chatId}` };
+            : { ...counted, fetch: typedCommand(deps.messenger.app.command, `messages sync ${chatId}`) };
     },
     sendAs: async (chat) => {
         if (deps.offline) {
@@ -180,7 +181,7 @@ export const chatsService = (deps) => ({
             unknown,
             ...(stored?.completeness ? { completeness: stored.completeness } : {}),
             ...(stored?.completeness && stored.completeness.state !== "complete" && syncsOneChat(deps.messenger)
-                ? { fetch: `${deps.messenger.app.command} messages sync ${id}` }
+                ? { fetch: typedCommand(deps.messenger.app.command, `messages sync ${id}`) }
                 : {}),
             items,
         };

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

@@ -5,5 +5,5 @@ 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, ContextSource, } from "../context/evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextSource, } from "../context/evidence.js";
 export type { ContextReadLimits, ContextReadUsage } from "../context/read-budget.js";

package/dist/services/conversations.js

@@ -5,6 +5,7 @@ import { linkMessages, RULES_VERSION } from "../conversations/link.js";
 import { formatLocator } from "../domain/locator.js";
 import { formatReference } from "../domain/references.js";
 import { conversation } from "../entities/conversation.js";
+import { typedCommand } from "../runs/scope.js";
 import { CONVERSATION_COLUMNS, queryFilter, } from "../store/store.js";
 import { accountStore } from "./deps.js";
 import { chatIdIn } from "./message-resolution.js";
@@ -38,7 +39,7 @@ export const conversationsService = (deps) => {
         const store = await accountStore(deps);
         return { store, chatId: await chatIdIn(deps.messenger, chat, store) };
     };
-    const notBuilt = (chatId) => new CliError("not_found", `chat ${chatId} has no conversations yet — \`${deps.messenger.app.command} conversations build --chat ${chatId}\``);
+    const notBuilt = (chatId) => new CliError("not_found", `chat ${chatId} has no conversations yet — \`${typedCommand(deps.messenger.app.command, `conversations build --chat ${chatId}`)}\``);
     return {
         build: async (chat, { maxMessages, check } = {}) => {
             check?.();

package/dist/services/deps.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { isCliFailure } from "../errors/failures.js";
+import { typedCommand } from "../runs/scope.js";
 /** The store with the running account bound: the default for a service's reads and writes. */
 export const accountStore = async (deps) => (await deps.store()).forAccount(await deps.account());
 /**
@@ -49,7 +50,7 @@ export const storeIfOpen = async (deps) => {
 /** Whether `chats`, `messages list|context` and `contacts` answer from the store instead of the messenger. */
 export const fromStore = (deps) => deps.offline || deps.reads === "store";
 /** What a store-mode read answers for a chat the store holds nothing of. */
-export const nothingStored = (messenger) => `nothing stored for this chat yet — keep \`${messenger.app.command} serve\` running`;
+export const nothingStored = (messenger) => `nothing stored for this chat yet — keep \`${typedCommand(messenger.app.command, "serve")}\` running`;
 /** Where a store-mode messenger's history comes from, for what it cannot do. */
 export const PUSHED = "this messenger's history is read from the local store";
 export const OFFLINE = "--offline answers only from what is kept locally: `chats list|show`, `messages list|show|context` and `contacts list|show`";

package/dist/services/embeddings-maintenance.js

@@ -6,6 +6,7 @@ import { DEFAULT_TEXT_MODEL, textModel, vectorModelKey } from "../embeddings/mod
 import { remoteKey } from "../embeddings/remote.js";
 import { CONTEXT_MESSAGES, CONTEXT_MINUTES } from "../images/context/index.js";
 import { registeredImageProviders } from "../images/registry.js";
+import { typedCommand } from "../runs/scope.js";
 import { conversationsService } from "./conversations.js";
 import { storedChatId } from "./message-resolution.js";
 /** How much one run without `--chat` does at most, by default. */
@@ -16,11 +17,11 @@ const PER_SESSION = 8;
 const PER_REQUEST = 256;
 /** e5's tokenizer reads ~3.7 characters a token in Russian; 3 keeps the bound above the real count. */
 const CHARS_PER_TOKEN_AT_LEAST = 3;
-const notDownloaded = (deps, id) => new CliError("not_found", `${id} is not downloaded — \`${deps.messenger.app.command} models text download ${id}\``, {
+const notDownloaded = (deps, id) => new CliError("not_found", `${id} is not downloaded — \`${typedCommand(deps.messenger.app.command, `models text download ${id}`)}\``, {
     reason: "model.not-downloaded",
     model: id,
 });
-export const notBuiltError = (deps, chatId) => new CliError("not_found", `chat ${chatId} has no conversations yet — \`${deps.messenger.app.command} conversations build --chat ${chatId}\``);
+export const notBuiltError = (deps, chatId) => new CliError("not_found", `chat ${chatId} has no conversations yet — \`${typedCommand(deps.messenger.app.command, `conversations build --chat ${chatId}`)}\``);
 export const embeddingTarget = (deps, choice = DEFAULT_TEXT_MODEL) => {
     if (typeof choice !== "string") {
         const { remote, apiKey, concurrency = 4 } = choice;

package/dist/services/index.d.ts

@@ -1,10 +1,12 @@
 import { type BotCheckService } from "../botcheck/service.js";
-export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextReadLimits, ContextReadUsage, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
+export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextReadLimits, ContextReadUsage, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { createContextEvidenceReader } from "./context-evidence.js";
 export { type DownloadedModel, downloadImageModel, downloadTextModel, type ModelDownloadOptions, } from "./model-downloads.js";
-export type { ProjectEvidenceItem, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectSourceFetcher, } from "./project-gathering.js";
+export type { ProjectEvidenceItem, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectIndexCatchUp, ProjectSourceFetcher, } from "./project-gathering.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
-export type { ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, } from "./project-gathering-request.js";
+export type { ProjectNeighbour, ProjectNeighbourReader } from "./project-gathering-around.js";
+export { storedMessageNeighbours } from "./project-gathering-around.js";
+export type { ProjectFetchState, ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, 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";
@@ -156,7 +158,7 @@ export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, type ProposalTaskStore, proposalSource } from "./proposal-tasks.js";
 export type { RetentionQuery, RetentionService } from "./retention.js";
 export { retentionService } from "./retention.js";
-export { RESOURCES_SEARCHED, type SearchAllFound, type SearchAllItem, type SearchAllRequest, type SearchedResource, searchAll, } from "./search-all.js";
+export { RESOURCES_SEARCHED, type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type SearchedResource, searchAll, } from "./search-all.js";
 export { type MeetingSearchCoverage, type MeetingSearchCursor, type MeetingSearchItem, RESOURCES_SEARCHED_WITH_MEETINGS, type ResourceWithMeetings, type SearchAllIncludingMeetingsFound, type SearchAllIncludingMeetingsRequest, type SearchAllWithMeetingsRequest, searchAllIncludingMeetings, searchAllWithMeetings, } from "./search-all-meetings.js";
 export { CATCH_UP_BOUNDS, type CatchUpOptions, type CatchUpResult, catchUpSearch, validateCatchUp, } from "./search-catchup.js";
 export { accountsOfKind, listContextOf, type SearchKind } from "./search-kind.js";

package/dist/services/index.js

@@ -2,6 +2,7 @@ import { botCheckService } from "../botcheck/service.js";
 export { createContextEvidenceReader } from "./context-evidence.js";
 export { downloadImageModel, downloadTextModel, } from "./model-downloads.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
+export { storedMessageNeighbours } from "./project-gathering-around.js";
 import { accountService } from "./account.js";
 import { adminService } from "./admin.js";
 import { adminStatisticsService } from "./admin-statistics.js";

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

@@ -0,0 +1,37 @@
+import type { MessagesStore } from "../store/messages.js";
+export interface ProjectNeighbour {
+    ref: string;
+    at: number;
+    sender: string | null;
+    text: string;
+    found: boolean;
+}
+/** The stored messages next to a hit in its chat, oldest first, without the hit itself. */
+export interface ProjectNeighbourReader {
+    around(ref: string, window: {
+        before: number;
+        after: number;
+    }): Promise<{
+        ref: string;
+        at: number;
+        sender: string | null;
+        text: string;
+    }[]>;
+}
+export declare const storedMessageNeighbours: (messages: Pick<MessagesStore, "around">) => ProjectNeighbourReader;
+/**
+ * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
+ * the run's read bytes.
+ */
+export declare const attachNeighbours: (items: {
+    ref: string;
+    kind: string;
+    around?: ProjectNeighbour[] | null;
+    aroundIssue?: string | null;
+}[], reader: ProjectNeighbourReader | undefined, window: {
+    before: number;
+    after: number;
+}, budget: {
+    remaining: () => number;
+    charge: (bytes: number) => void;
+}, known: (ref: string) => boolean, signal?: AbortSignal) => Promise<void>;

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

@@ -0,0 +1,57 @@
+import { CliError } from "@wirecat/cli-base";
+import { formatLocator, parseLocator } from "../domain/locator.js";
+import { excerpt } from "./excerpt.js";
+export const storedMessageNeighbours = (messages) => ({
+    async around(ref, window) {
+        const at = parseLocator(ref);
+        const rows = await messages.around({ provider: at.provider, account: at.account }, at.chat, at.message, window);
+        return rows
+            .filter((row) => !row.anchor)
+            .map((row) => ({
+            ref: formatLocator({ ...at, message: row.id }),
+            at: Date.parse(row.timestamp),
+            sender: row.senderName,
+            text: row.text ?? "",
+        }));
+    },
+});
+/**
+ * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
+ * the run's read bytes.
+ */
+export const attachNeighbours = async (items, reader, window, budget, known, signal) => {
+    if (!reader || window.before + window.after === 0)
+        return;
+    for (const item of items) {
+        if (item.kind !== "message")
+            continue;
+        if (budget.remaining() <= 0) {
+            item.around = null;
+            item.aroundIssue = "read-bytes";
+            continue;
+        }
+        signal?.throwIfAborted();
+        try {
+            const rows = await reader.around(item.ref, window);
+            const around = [];
+            for (const row of rows.slice(0, window.before + window.after)) {
+                const text = excerpt(row.text, "", 200);
+                const bytes = Buffer.byteLength(text);
+                if (bytes > budget.remaining()) {
+                    item.aroundIssue = "read-bytes";
+                    break;
+                }
+                budget.charge(bytes);
+                around.push({ ...row, text, found: known(row.ref) });
+            }
+            item.around = around;
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            if (!(error instanceof CliError))
+                throw error;
+            item.around = null;
+            item.aroundIssue = error.code;
+        }
+    }
+};

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

@@ -2,6 +2,7 @@ import { type ContextSource } from "../context/evidence.js";
 export interface ProjectGatheringRequest {
     project: {
         name: string;
+        key?: string;
         background?: string;
         aliases?: string[];
     };
@@ -17,6 +18,11 @@ export interface ProjectGatheringRequest {
     before?: number;
     asOf?: number;
     fetch?: "none" | "before-read";
+    index?: "update" | "as-is";
+    around?: {
+        before: number;
+        after: number;
+    };
     budgets?: ProjectGatheringBudgets;
     runKey?: string;
     checkpoint?: string;
@@ -29,7 +35,7 @@ export interface ProjectGatheringBudgets {
     maxElapsedMs?: number;
     maxItems?: number;
 }
-export type ProjectLaneKind = "project" | "alias" | "keyword" | "person";
+export type ProjectLaneKind = "project" | "key" | "alias" | "keyword" | "person";
 export interface ProjectLane {
     id: string;
     kinds: ProjectLaneKind[];
@@ -73,6 +79,7 @@ export declare const CONTEXT_CHUNK_DAYS = 90;
 export declare const projectGatheringRequest: (input: ProjectGatheringRequest, now: number) => {
     project: {
         name: string;
+        key: string | null;
         background: string | null;
         aliases: string[];
     };
@@ -91,6 +98,11 @@ export declare const projectGatheringRequest: (input: ProjectGatheringRequest, n
         asOf: number;
     };
     fetch: "before-read" | "none";
+    index: "as-is" | "update";
+    around: {
+        before: number;
+        after: number;
+    };
     budgets: Required<ProjectGatheringBudgets>;
     fingerprint: string;
     runKey: string;

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

@@ -55,6 +55,8 @@ export const projectGatheringRequest = (input, now) => {
         "before",
         "asOf",
         "fetch",
+        "index",
+        "around",
         "budgets",
         "runKey",
         "checkpoint",
@@ -62,9 +64,10 @@ export const projectGatheringRequest = (input, now) => {
     ], "");
     if (!input.project || typeof input.project !== "object")
         fail("project needs a name", "project");
-    known(input.project, ["name", "background", "aliases"], "project.");
+    known(input.project, ["name", "key", "background", "aliases"], "project.");
     const project = {
         name: text(input.project.name, "project.name", 512),
+        key: input.project.key === undefined ? null : text(input.project.key, "project.key", 64),
         background: input.project.background === undefined ? null : text(input.project.background, "project.background", 8192),
         aliases: list(input.project.aliases, "project.aliases", LIMITS.lanes).map((a, i) => text(a, `project.aliases.${i}`, 512)),
     };
@@ -104,6 +107,8 @@ export const projectGatheringRequest = (input, now) => {
             found.people.push(person);
     };
     lane("project", laneQuery(project.name, "project.name"));
+    if (project.key)
+        lane("key", laneQuery(project.key, "project.key"));
     for (const [i, a] of project.aliases.entries())
         lane("alias", laneQuery(a, `project.aliases.${i}`));
     for (const k of keywords)
@@ -113,19 +118,30 @@ export const projectGatheringRequest = (input, now) => {
     if (lanes.length > LIMITS.lanes)
         fail(`at most ${LIMITS.lanes} distinct search lanes`, "keywords");
     const fetch = input.fetch ?? "none";
+    const index = input.index ?? "update";
+    if (index !== "update" && index !== "as-is")
+        fail("index must be update or as-is", "index");
+    if (input.around !== undefined && (!input.around || typeof input.around !== "object"))
+        fail("around needs before and after", "around");
+    if (input.around)
+        known(input.around, ["before", "after"], "around.");
+    const around = {
+        before: whole(input.around?.before ?? 2, "around.before", 0, 5),
+        after: whole(input.around?.after ?? 2, "around.after", 0, 5),
+    };
     if (fetch !== "none" && fetch !== "before-read")
         fail("fetch must be none or before-read", "fetch");
     const explicit = input.after !== undefined || input.before !== undefined;
     if (explicit && input.lookbackDays !== undefined)
         fail("give lookbackDays or after/before, not both", "lookbackDays");
-    if (explicit && (input.after === undefined || input.before === undefined))
-        fail("an explicit window needs both after and before", input.after === undefined ? "after" : "before");
+    if (explicit && input.after === undefined)
+        fail("an explicit window needs after; before defaults to asOf", "after");
     const asOf = input.asOf === undefined ? null : whole(input.asOf, "asOf", 1, MAX_TIME);
     const lookbackDays = explicit ? null : whole(input.lookbackDays ?? 60, "lookbackDays", 1, LIMITS.lookbackDays);
     const window = explicit
         ? (() => {
             const after = whole(input.after, "after", 0, MAX_TIME);
-            const before = whole(input.before, "before", after + 1, MAX_TIME);
+            const before = whole(input.before ?? asOf ?? now, "before", after + 1, MAX_TIME);
             if (before - after > LIMITS.lookbackDays * DAY)
                 fail(`window must not exceed ${LIMITS.lookbackDays} days`, "after");
             return { after, before, asOf: asOf ?? before };
@@ -150,7 +166,7 @@ export const projectGatheringRequest = (input, now) => {
         sources.map(contextSourceKey),
         input.scope,
         lookbackDays,
-        explicit ? [window.after, window.before] : null,
+        explicit ? [window.after, input.before ?? null] : null,
         asOf,
         fetch,
     ]))
@@ -168,6 +184,8 @@ export const projectGatheringRequest = (input, now) => {
         lookbackDays,
         window,
         fetch,
+        index,
+        around,
         budgets,
         fingerprint,
         runKey,

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

@@ -1,4 +1,5 @@
-import type { ContextEvidenceItem, ContextEvidenceReader, ContextSource } from "../context/evidence.js";
+import type { ContextEvidenceItem, ContextEvidenceReader, ContextIndex, ContextSource } from "../context/evidence.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. */
 export interface ProjectSourceFetcher {
@@ -15,8 +16,16 @@ export interface ProjectSourceFetcher {
 export interface ProjectGatheringPorts {
     evidence: ContextEvidenceReader;
     fetcher?: ProjectSourceFetcher;
+    index?: ContextIndex;
+    neighbours?: ProjectNeighbourReader;
     now?: () => number;
 }
+export interface ProjectIndexCatchUp {
+    state: "updated" | "as-is" | "unavailable" | "failed";
+    mail: number;
+    documents: number;
+    code: string | null;
+}
 export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text"> {
     kind: ContextSource["kind"];
     source: number;
@@ -24,6 +33,8 @@ export interface ProjectEvidenceItem extends Omit<ContextEvidenceItem, "text"> {
     textTruncated: boolean;
     lanes: string[];
     context: "project" | "person-only";
+    around?: ProjectNeighbour[] | null;
+    aroundIssue?: string | null;
 }
 export type ProjectGatheringStop = "reads" | "read-bytes" | "elapsed" | "items" | null;
 export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, request: ProjectGatheringRequest) => Promise<{
@@ -33,6 +44,7 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
     resumed: boolean;
     project: {
         name: string;
+        key: string | null;
         background: string | null;
         aliases: string[];
     };
@@ -55,6 +67,7 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
         code: string | null;
         source: number;
     }[];
+    index: ProjectIndexCatchUp;
     units: {
         lane: string;
         source: number;
@@ -72,6 +85,7 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
     usage: {
         reads: number;
         readBytes: number;
+        aroundBytes: number;
         items: number;
         elapsedMs: number;
     };

package/dist/services/project-gathering.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { createContextEvidenceReader } from "./context-evidence.js";
 import { excerpt } from "./excerpt.js";
+import { attachNeighbours } 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) => {
@@ -12,6 +13,9 @@ export const gatherProjectEvidence = async (ports, request) => {
     const previous = plan.checkpoint === undefined ? null : decodeCheckpoint(plan.checkpoint, plan);
     const window = previous ?? plan.window;
     const units = projectUnits(plan, window);
+    // A default that cannot finish one round would leave whole searches or sources unread; an explicit one is kept.
+    if (request.budgets?.maxReads === undefined)
+        plan.budgets.maxReads = Math.min(512, Math.max(48, units.length));
     if (previous && (previous.units.length !== units.length || previous.fetched.length !== plan.sources.length))
         throw new CliError("validation_error", "invalid project gathering checkpoint", { param: "checkpoint" });
     const progress = previous?.units.map((u) => ({ ...u })) ??
@@ -43,7 +47,27 @@ export const gatherProjectEvidence = async (ports, request) => {
                 fetched[index] = { state: "failed", history: null, code: error.code };
             }
         }
-    const usage = { reads: 0, readBytes: 0, items: 0 };
+    const indexed = { state: "as-is", mail: 0, documents: 0, code: null };
+    const kinds = [...new Set(plan.sources.map((source) => source.kind))].filter((kind) => kind !== "message");
+    if (plan.index === "update" && kinds.length) {
+        signal?.throwIfAborted();
+        if (!ports.index || typeof ports.index.catchUp !== "function")
+            indexed.state = "unavailable";
+        else
+            try {
+                const done = await ports.index.catchUp({ kinds, signal });
+                if (!Number.isSafeInteger(done?.mail) || !Number.isSafeInteger(done?.documents))
+                    throw new CliError("invalid_response", "index catch-up returned invalid counts");
+                Object.assign(indexed, { state: "updated", mail: done.mail, documents: done.documents });
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                if (!(error instanceof CliError))
+                    throw error;
+                Object.assign(indexed, { state: "failed", code: error.code });
+            }
+    }
+    const usage = { reads: 0, readBytes: 0, aroundBytes: 0, items: 0 };
     const items = [];
     const byRef = new Map();
     const matchedAgain = new Map();
@@ -145,6 +169,12 @@ export const gatherProjectEvidence = async (ports, request) => {
             }
         }
     }
+    await attachNeighbours(items, ports.neighbours, plan.around, {
+        remaining: () => plan.budgets.maxReadBytes - usage.readBytes - usage.aroundBytes,
+        charge: (bytes) => {
+            usage.aroundBytes += bytes;
+        },
+    }, (ref) => byRef.has(ref) || seen.has(seenKey(ref)), signal);
     const totals = {
         reads: (previous?.totals.reads ?? 0) + usage.reads,
         readBytes: (previous?.totals.readBytes ?? 0) + usage.readBytes,
@@ -181,6 +211,7 @@ export const gatherProjectEvidence = async (ports, request) => {
         scope: { origin: plan.scope, sources: plan.sources },
         lanes: plan.lanes,
         fetch: fetched.map((f, index) => ({ source: index, ...f })),
+        index: indexed,
         units: units.map((unit, index) => ({
             lane: unit.lane.id,
             source: unit.sourceIndex,

package/dist/services/search-all-meetings.d.ts

@@ -1,8 +1,7 @@
 import type { SearchHit } from "../meetings/index.js";
-import type { MessengerTraits } from "../ports/traits.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
 import type { SearchFound, SearchQuery } from "./messages.js";
-import { type SearchAllFound, type SearchAllItem, type SearchAllRequest, type Skipped } from "./search-all.js";
+import { type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type Skipped } from "./search-all.js";
 export declare const RESOURCES_SEARCHED_WITH_MEETINGS: readonly ["messages", "mail", "notes", "meetings"];
 export type ResourceWithMeetings = (typeof RESOURCES_SEARCHED_WITH_MEETINGS)[number];
 export interface MeetingSearchItem {
@@ -55,7 +54,7 @@ export interface SearchAllIncludingMeetingsFound extends Omit<SearchAllFound, "i
     meetings?: MeetingSearchCoverage;
 }
 /** Opt-in fusion of the existing unified ranking and one explicitly scoped meeting archive. */
-export declare const searchAllIncludingMeetings: (store: MessageStore, account: AccountKey, request: SearchAllIncludingMeetingsRequest, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app">>, searchMessages?: (query: SearchQuery) => Promise<SearchFound>) => Promise<SearchAllIncludingMeetingsFound>;
+export declare const searchAllIncludingMeetings: (store: MessageStore, account: AccountKey, request: SearchAllIncludingMeetingsRequest, messenger?: SearchAllMessenger, searchMessages?: (query: SearchQuery) => Promise<SearchFound>) => Promise<SearchAllIncludingMeetingsFound>;
 export interface SearchAllWithMeetingsRequest extends Omit<SearchAllIncludingMeetingsRequest, "meetingAccount"> {
     /**
      * `--source`: each kind reads the accounts the list names of it and a kind it names none of is skipped.
@@ -66,4 +65,4 @@ export interface SearchAllWithMeetingsRequest extends Omit<SearchAllIncludingMee
 /** Meetings have no index to search every account at once, so they are read only when named. */
 export declare const MEETINGS_UNNAMED = "meetings are searched only when --source names a meeting account, zoom or meetings";
 /** `search all`: every kind but meetings, unless `--source` names a meeting account. */
-export declare const searchAllWithMeetings: (store: MessageStore, account: AccountKey, request: SearchAllWithMeetingsRequest, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app">>, searchMessages?: (query: SearchQuery) => Promise<SearchFound>) => Promise<SearchAllIncludingMeetingsFound>;
+export declare const searchAllWithMeetings: (store: MessageStore, account: AccountKey, request: SearchAllWithMeetingsRequest, messenger?: SearchAllMessenger, searchMessages?: (query: SearchQuery) => Promise<SearchFound>) => Promise<SearchAllIncludingMeetingsFound>;

package/dist/services/search-all.d.ts

@@ -81,9 +81,16 @@ export interface SearchAllRequest {
     /** The accounts `--source` chose, per kind; a kind left out reads every account of its own. */
     scope?: Partial<Record<SearchedResource, AccountKey[]>>;
 }
+export type SearchAllMessenger = Partial<Pick<MessengerTraits, "savedChatId" | "app">> & {
+    /**
+     * The tool named in a model-download hint, when it is not `app.command`: memo passes tg's identity for `group:`
+     * lists but has no `models` command. `null` names the tools that have one.
+     */
+    hintCommand?: string | null;
+};
 /**
  * `search all`: messages, mail and notes from the local store — messages also from the messenger's
  * server, as `search messages` asks it — each list best first, merged by reciprocal rank so no
  * resource's own scores have to be compared with another's.
  */
-export declare const searchAll: (store: MessageStore, account: AccountKey, request: SearchAllRequest, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app">>, searchMessages?: (query: SearchQuery) => Promise<SearchFound>) => Promise<SearchAllFound>;
+export declare const searchAll: (store: MessageStore, account: AccountKey, request: SearchAllRequest, messenger?: SearchAllMessenger, searchMessages?: (query: SearchQuery) => Promise<SearchFound>) => Promise<SearchAllFound>;

package/dist/services/search-all.js

@@ -21,7 +21,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     // Each resource is read deep enough for the merged page, then the merge is cut.
     const window = offset + request.limit;
     const only = request.only ?? RESOURCES_SEARCHED;
-    const command = messenger.app?.command;
+    const command = messenger.hintCommand === undefined ? messenger.app?.command : (messenger.hintCommand ?? undefined);
     const lists = [];
     const searched = [];
     const accounts = [];

package/dist/speech/transcribe.js

@@ -1,6 +1,7 @@
 import { CliError, isCliError } from "@wirecat/cli-base";
 import { fromFile } from "../cli/settings.js";
 import { capability } from "../ports/messenger.js";
+import { typedCommand } from "../runs/scope.js";
 import { installedBytes, isInstalled, megabytes, modelPath, modelsDirectory, vadPath } from "./install.js";
 import { orderedModels, speechModel } from "./models.js";
 /** `messenger`: its own recognition (Telegram Premium). `local`: a model on this machine. `auto`: the first, then the second. */
@@ -20,7 +21,7 @@ export const choose = (messenger, settings, flags, env = process.env) => {
 };
 /** Never a download: a model is hundreds of MB, and whether to fetch one is the owner's call. */
 export const notDownloaded = (messenger, model) => new CliError("not_found", `the speech model ${model.id} is not on this machine — the owner downloads it once with ` +
-    `\`${messenger.app.command} models audio download ${model.id}\` (${megabytes(installedBytes(model))})`, { reason: "model.not-downloaded", model: model.id });
+    `\`${typedCommand(messenger.app.command, `models audio download ${model.id}`)}\` (${megabytes(installedBytes(model))})`, { reason: "model.not-downloaded", model: model.id });
 /**
  * Over an open connection: the messenger's own transcript, or the recording's bytes for a local model.
  * The model runs after the connection closes — a minute of speech should not hold a socket open.

package/dist/store/chats.d.ts

@@ -1,5 +1,5 @@
 import type { ChannelTagMatch } from "../domain/channel-tags.js";
-import type { Chat, ChatKind, Id, Page } from "../domain/models.js";
+import type { Chat, ChatKind, ChatUpdate, Id, Page } from "../domain/models.js";
 import { type ChatRekey } from "./sqlite/chat-rekey.js";
 import type { ChatMetadata } from "./sqlite/chats.js";
 import type { ChatCompleteness } from "./sqlite/completeness.js";
@@ -7,7 +7,7 @@ import type { StoreContext } from "./sqlite/open.js";
 import type { Where } from "./sqlite/query-filter.js";
 import type { AccountKey, ChatActivity, ChatStats, StoredChatFilter } from "./types.js";
 export interface ChatsStore {
-    saveChats(key: AccountKey, chats: Chat[]): Promise<void>;
+    saveChats(key: AccountKey, chats: ChatUpdate[]): Promise<void>;
     /** Newest first. `query` matches three letters or more of a title; `unread` keeps chats with unread messages. */
     chats(key: AccountKey, window: {
         limit?: number;

package/dist/store/sqlite/chats.d.ts

@@ -1,5 +1,5 @@
 import type { ChannelTagMatch } from "../../domain/channel-tags.js";
-import type { Chat, Id, Member, Page } from "../../domain/models.js";
+import type { Chat, ChatUpdate, Id, Member, Page } from "../../domain/models.js";
 import type { AccountKey, StoredChatFilter } from "../types.js";
 import type { StoreContext } from "./open.js";
 /** The chat's own id, when the store key is a chat of this account. */
@@ -7,7 +7,7 @@ export declare const chatOf: ({ orm }: StoreContext, accountKey: number, chatKey
 export declare const findChatPk: ({ orm }: StoreContext, accountKey: number, chatId: Id) => number | undefined;
 /** A chat known only from its messages, until the chat list names it. */
 export declare const chatPkFor: (context: StoreContext, accountKey: number, chatId: Id) => number;
-export declare const upsertChat: (context: StoreContext, accountKey: number, chat: Chat) => void;
+export declare const upsertChat: (context: StoreContext, accountKey: number, chat: ChatUpdate) => void;
 /** Replaces who is in the chat, whole. */
 export declare const writeMembers: (context: StoreContext, key: AccountKey, accountKey: number, chatId: Id, memberIds: Id[]) => void;
 export declare const members: ({ orm }: StoreContext, chatKey: number) => Member[];