@wirecat/cli-core 0.592.0 → 0.593.0

package/CHANGELOG.md

@@ -7,6 +7,33 @@ shape of this file.
 
 ## Unreleased
 
+## 0.593.0 — 06.11.2026
+
+### Added
+
+- **`questionLookup` is public** (`@wirecat/cli-core/services`): the rule `search all` uses to search a question
+  typed as a sentence with discovery, so a CLI's own message search can do the same and find a short reply by the
+  message it answers.
+- **`schedule agent` and `schedule command` take `--to <route>`, repeatable.** After the run, when `--notify-on`
+  says so, the scheduler sends the result through the owner's own CLI: `telegram-bot:<profile>/<chat id or
+  user:id>` runs `tg <profile> bot messages send`, `email:<profile>/<address>` runs `mail <profile> messages send`.
+  A finished run sends its output (an agent's report, a command's log): to a bot as one message up to 4096
+  characters, else as a file with its first lines as the caption; by mail as the body, the title as the subject. A
+  failed run sends one line: exit code, reason id, the log's path. The run itself stays read-only; nothing it prints
+  can change where the result goes; a run under `<PREFIX>_READ_ONLY` sends nothing. Each route's outcome is in
+  `last.json` as `deliveries` (`to`, `ok`, a dotted `reason`, the sending CLI's error code); a failed send never fails
+  the run, and `schedule list` shows it. `ServerSystem.run` takes an optional `{ input, timeoutMs }`.
+- **`store.mail.writtenTo(addresses)`.** Of these addresses, the ones the owner wrote to: To or Cc of a live outgoing
+  email in any account, in lower case, in one read.
+
+### Fixed
+
+- **`search all` finds mail by meaning through the vector index.** The mail half of the meaning lane read every mail
+  vector of each mailbox (`store.mail.nearest`, #2471), most of a `search all` on a large store: 9.5 s warm and
+  44–71 s with a cold disk on the owner's store. It now asks the model's vector index for the nearest
+  thread pieces and attachments, with the same results, and scans only when the index is not ready or a thread is
+  named (3.9 s warm on the same query).
+
 ## 0.592.0 — 06.11.2026
 
 ## 0.591.0 — 06.11.2026
@@ -30,17 +57,6 @@ shape of this file.
   in `@wirecat/cli-core`.
 - **`DealFilter.account` and `offset`, `pipelines({ account })`.** A list reads the owner's own (`"own"`) or one CRM
   account's copies, a page at a time.
-- **`schedule agent` and `schedule command` take `--to <route>`, repeatable.** After the run, when `--notify-on`
-  says so, the scheduler sends the result through the owner's own CLI: `telegram-bot:<profile>/<chat id or
-  user:id>` runs `tg <profile> bot messages send`, `email:<profile>/<address>` runs `mail <profile> messages send`.
-  A finished run sends its output (an agent's report, a command's log): to a bot as one message up to 4096
-  characters, else as a file with its first lines as the caption; by mail as the body, the title as the subject. A
-  failed run sends one line: exit code, reason id, the log's path. The run itself stays read-only; nothing it prints
-  can change where the result goes; a run under `<PREFIX>_READ_ONLY` sends nothing. Each route's outcome is in
-  `last.json` as `deliveries` (`to`, `ok`, a dotted `reason`, the sending CLI's error code); a failed send never fails
-  the run, and `schedule list` shows it. `ServerSystem.run` takes an optional `{ input, timeoutMs }`.
-- **`store.mail.writtenTo(addresses)`.** Of these addresses, the ones the owner wrote to: To or Cc of a live outgoing
-  email in any account, in lower case, in one read.
 
 - **`syncCrm` and the `CrmSource` port, in `@wirecat/cli-core/crm`.** A CRM CLI writes an adapter (`pipelines(kind)`,
   `changes(kind, cursor, page)` answering a page or `{ reset: true }`, and `ids(kind, page)` when the CRM does not name

package/dist/services/index.d.ts

@@ -154,6 +154,7 @@ export declare const servicesFor: (deps: ServiceDeps) => Services;
 export { entriesOfList, type ListContext, type ListedEntry } from "../search/account-list.js";
 export { FIELD_VERSION, QUERY_FIELDS, QUERY_OPERATORS, validateAst } from "../search/lucene/registry.js";
 export { QUERY_LIMITS, QUERY_VERSION } from "../search/lucene/types.js";
+export { questionLookup } from "../search/question-plan.js";
 export { type SearchTotal, TOTAL_CAP } from "../search/total.js";
 export { TASK_KINDS, TASK_ORIGINS, type TaskKind, type TaskOrigin } from "../tasks/index.js";
 export type { AdminFound, AdminQuery, AdminSelection, AdminStatisticsService } from "./admin-statistics.js";

package/dist/services/index.js

@@ -119,6 +119,7 @@ export const servicesFor = (deps) => {
 export { entriesOfList } from "../search/account-list.js";
 export { FIELD_VERSION, QUERY_FIELDS, QUERY_OPERATORS, validateAst } from "../search/lucene/registry.js";
 export { QUERY_LIMITS, QUERY_VERSION } from "../search/lucene/types.js";
+export { questionLookup } from "../search/question-plan.js";
 export { TOTAL_CAP } from "../search/total.js";
 export { TASK_KINDS, TASK_ORIGINS } from "../tasks/index.js";
 export { adminStatisticsService } from "./admin-statistics.js";

package/dist/store/sqlite/emails.js

@@ -8,6 +8,7 @@ import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, s
 import { bool, flag, fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
 import { ensurePerson } from "./identities.js";
+import { nearestMailPieces } from "./mail-nearest.js";
 import { mailRulesOver } from "./mail-rules.js";
 import { attachmentOf, saveAttachment, wordsQuery } from "./meetings.js";
 import { stemmerCache } from "./stems.js";
@@ -15,7 +16,6 @@ import { writeState } from "./sync.js";
 import { threadRows } from "./thread-columns.js";
 import { write } from "./transaction.js";
 import { dropUnusedVectors } from "./vector-index.js";
-import { dot } from "./vectors.js";
 /** A thread as a conversation: the summary `search conversations` and `related` answer for an email. */
 export const threadConversation = (place, builtAt) => ({
     id: `email:${place.emailId}`,
@@ -590,28 +590,10 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
     },
     async nearest(model, query, { accountId, limit, threadExternalId, since }) {
         drainEmailIndex(database, stemmerFor);
-        const page = database.prepare(`SELECT p.id, p.type, p.owner, p.position, p.email_id AS email, v.vector FROM ${MAIL_PIECES}
-         JOIN embeddings v ON v.model = ? AND v.content_hash = p.content_hash
-        WHERE p.id > ? AND p.account_id = ?
-          AND (? IS NULL OR p.thread_id IN (SELECT id FROM email_threads WHERE account_id = p.account_id AND external_id = ?))
-          AND (? IS NULL OR p.occurred_at >= ?)
-        ORDER BY p.id LIMIT 500`);
-        const best = new Map();
-        for (let after = 0;;) {
-            const rows = page.all(model, after, accountId, threadExternalId ?? null, threadExternalId ?? null, since ?? null, since ?? null);
-            for (const row of rows) {
-                const score = dot(query, row.vector);
-                const key = row.type === "email_thread" ? `${row.owner}:${row.position}` : `email:${row.email}`;
-                if (score > (best.get(key) ?? Number.NEGATIVE_INFINITY))
-                    best.set(key, score);
-            }
-            if (rows.length < 500)
-                break;
-            after = Number(rows.at(-1)?.id);
-        }
+        const best = nearestMailPieces(database, model, query, { accountId, threadExternalId, since }, limit * 2);
         const threads = new Map();
         const emails = new Map();
-        for (const [key, score] of [...best.entries()].sort(([, a], [, b]) => b - a)) {
+        for (const [key, score] of best) {
             if (emails.size >= limit)
                 break;
             const [owner, position] = key.split(":");

package/dist/store/sqlite/mail-nearest.d.ts

@@ -0,0 +1,12 @@
+import type { CacheDatabase } from "../driver.js";
+interface MailPieceFilter {
+    accountId: number;
+    threadExternalId?: string | undefined;
+    since?: number | undefined;
+}
+/**
+ * Each mail piece of the account (a thread's piece or an email's attachment) by its best score against `query`, best
+ * first. Without a thread the index gives the best `depth` of each kind; a thread, or an index not ready, scans.
+ */
+export declare const nearestMailPieces: (database: CacheDatabase, model: string, query: Float32Array, filter: MailPieceFilter, depth: number) => (readonly [string, number])[];
+export {};

package/dist/store/sqlite/mail-nearest.js

@@ -0,0 +1,73 @@
+import { MAIL_PIECES } from "./email-index.js";
+import { searchIndex } from "./vector-index.js";
+import { dot } from "./vectors.js";
+const MAIL_PIECE_ROWS = `SELECT p.id, p.content_hash AS hash, p.type, p.owner, p.position, p.email_id AS email, v.vector
+    FROM ${MAIL_PIECES} JOIN embeddings v ON v.model = ? AND v.content_hash = p.content_hash
+   WHERE p.account_id = ?
+     AND (? IS NULL OR p.thread_id IN (SELECT id FROM email_threads WHERE account_id = p.account_id AND external_id = ?))
+     AND (? IS NULL OR p.occurred_at >= ?)`;
+const pieceKey = (row) => row.type === "email_thread" ? `${row.owner}:${row.position}` : `email:${row.email}`;
+const filterParams = (model, { accountId, threadExternalId, since }) => [
+    model,
+    accountId,
+    threadExternalId ?? null,
+    threadExternalId ?? null,
+    since ?? null,
+    since ?? null,
+];
+const byScore = (best) => [...best.entries()].map(([key, { score }]) => [key, score]).sort(([, a], [, b]) => b - a);
+/** Every mail piece of the account scored against `query`: each thread piece or attachment keeps its best score. */
+const scannedMailPieces = (database, model, query, filter) => {
+    const page = database.prepare(`${MAIL_PIECE_ROWS} AND p.id > ? ORDER BY p.id LIMIT 500`);
+    const best = new Map();
+    for (let after = 0;;) {
+        const rows = page.all(...filterParams(model, filter), after);
+        for (const row of rows) {
+            const score = dot(query, row.vector);
+            const key = pieceKey(row);
+            if (score > (best.get(key)?.score ?? Number.NEGATIVE_INFINITY))
+                best.set(key, { score });
+        }
+        if (rows.length < 500)
+            break;
+        after = Number(rows.at(-1)?.id);
+    }
+    return byScore(best);
+};
+/**
+ * The best `depth` pieces of each kind by the model's vector index, or `undefined` when the index cannot answer and
+ * the caller scans. Reading every mail vector of a large mailbox took most of a `search all`.
+ */
+const indexedMailPieces = (database, model, query, filter, depth) => {
+    const candidates = database.prepare(`${MAIL_PIECE_ROWS} AND p.id IN (SELECT value FROM json_each(?)) ORDER BY p.id`);
+    const merged = new Map();
+    for (const kind of ["email_thread", "attachment"]) {
+        const found = searchIndex(database, model, { kind, account: filter.accountId, ...(filter.since === undefined ? {} : { since: filter.since }) }, query, depth, (near) => {
+            const hashes = new Map(near.map(({ id, hash }) => [id, hash]));
+            const best = new Map();
+            for (const row of candidates.all(...filterParams(model, filter), JSON.stringify([...hashes.keys()]))) {
+                if (hashes.get(Number(row.id)) !== row.hash)
+                    continue;
+                const score = dot(query, row.vector);
+                const key = pieceKey(row);
+                if (score > (best.get(key)?.score ?? Number.NEGATIVE_INFINITY))
+                    best.set(key, { score, chunk: Number(row.id) });
+            }
+            const results = byScore(best)
+                .slice(0, depth)
+                .map(([key]) => [key, best.get(key)]);
+            return { results, best: results.map(([, { chunk }]) => chunk) };
+        });
+        if (!found)
+            return undefined;
+        for (const [key, held] of found)
+            merged.set(key, held);
+    }
+    return byScore(merged);
+};
+/**
+ * Each mail piece of the account (a thread's piece or an email's attachment) by its best score against `query`, best
+ * first. Without a thread the index gives the best `depth` of each kind; a thread, or an index not ready, scans.
+ */
+export const nearestMailPieces = (database, model, query, filter, depth) => (filter.threadExternalId === undefined ? indexedMailPieces(database, model, query, filter, depth) : undefined) ??
+    scannedMailPieces(database, model, query, filter);

package/package.json

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