@wirecat/cli-core 0.505.0 → 0.507.0

package/dist/services/messages-meaning.js

@@ -6,7 +6,7 @@ import { plainWords } from "./pictures.js";
  * Discovery's meaning half: the default local model over each message's own vector. It runs only when the model is
  * on disk and vectors exist — never a download, never a remote model — and any failure leaves the words alone.
  */
-export const meaningLane = (deps) => async (question, accounts, shared) => {
+export const meaningLane = (deps) => async (question, accounts, shared, within) => {
     const target = embeddingTarget(deps, DEFAULT_TEXT_MODEL);
     const skipped = (reason, step) => ({
         skipped: { reason, model: target.id, ...(step ? { step } : {}) },
@@ -24,14 +24,17 @@ export const meaningLane = (deps) => async (question, accounts, shared) => {
     try {
         const ranked = [];
         if (words) {
+            const pks = await within?.();
             const lookUp = async (embedder) => {
                 const [query] = await embedder.embed([words], "query");
                 for (const one of ready) {
-                    const near = await store.vectors.nearestMessages(one, {
-                        model: target.key,
-                        limit: MEANING_DEPTH,
-                        query: query,
-                    });
+                    const near = pks
+                        ? await store.vectors.scoreMessages(one, { model: target.key, query: query, pks })
+                        : await store.vectors.nearestMessages(one, {
+                            model: target.key,
+                            limit: MEANING_DEPTH,
+                            query: query,
+                        });
                     for (const { chatId, messageId, score } of near)
                         ranked.push({ ...one, chatId, id: messageId, score });
                 }

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

@@ -8,7 +8,8 @@ import type { SearchRefreshed } from "./search-refresh.js";
 export interface QueryMetadata {
     language: "lucene-v1";
     discovery?: {
-        method: "lexical-partial";
+        /** `lexical-strict` when the query's own syntax (-, OR, NOT, groups…) chose the word hits, not a relaxed OR. */
+        method: "lexical-partial" | "lexical-strict";
         candidateDepth: number;
         candidates: number;
         repliesAdded: number;

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

@@ -169,14 +169,7 @@ export declare const noteSourceOfQuery: (query: string) => {
     source?: Note["source"];
     rest: string;
 };
-/**
- * What a note found by meaning must still match: the query with each word it asks for taken as matched, since the
- * meaning half stands in for those. Words it excludes, and every other field, stay. `undefined` when nothing but
- * wanted words is left, so any note found by meaning fits.
- */
 export declare const fieldsOfQuery: (root: QueryNode) => QueryNode | undefined;
-/** The words and phrases the query asks for, for the meaning half to embed; none it excludes, no field. */
-export declare const meaningWords: (root: QueryNode) => string;
 /**
  * The most notes a filter may hold for meaning to rank all of them, each by its best chunk. Above it, meaning ranks
  * the nearest notes overall and keeps those inside the filter, so a narrow filter over a large store loses some. On

package/dist/services/notes-search.js

@@ -6,6 +6,7 @@ import { defaultThreads, isTextModelInstalled, openEmbedder, textModelsDirectory
 import { DEFAULT_TEXT_MODEL, meaningFloor, textModel, vectorModelKey } from "../embeddings/models.js";
 import { DEFAULT_IMAGE_MODEL, imageModel } from "../images/picture/models.js";
 import { entriesOfList, fitting } from "../search/account-list.js";
+import { fieldsOfQuery as fieldsOf, meaningWords } from "../search/lucene/meaning-parts.js";
 import { validateFields } from "../search/lucene/registry.js";
 import { hasStems } from "../search/lucene/resolved.js";
 import { SEARCH_QUERY } from "../search/lucene/types.js";
@@ -234,44 +235,9 @@ export const noteSourceOfQuery = (query) => {
     }
     return { source, rest };
 };
-const WORD_FIELDS = new Set(["text", "exact"]);
-/**
- * What a note found by meaning must still match: the query with each word it asks for taken as matched, since the
- * meaning half stands in for those. Words it excludes, and every other field, stay. `undefined` when nothing but
- * wanted words is left, so any note found by meaning fits.
- */
-export const fieldsOfQuery = (root) => {
-    let narrows = false;
-    const kept = (node) => {
-        if (node.kind === "boolean")
-            return {
-                ...node,
-                clauses: node.clauses.map(({ occur, node }) => {
-                    if (occur !== "must_not")
-                        return { occur, node: kept(node) };
-                    narrows = true;
-                    return { occur, node };
-                }),
-            };
-        if (!WORD_FIELDS.has(node.field)) {
-            narrows = true;
-            return node;
-        }
-        // `in:notes` holds for every note and document; an empty clause list would match nothing.
-        return { kind: "predicate", field: "in", operator: "term", value: "notes", span: node.span };
-    };
-    const fields = kept(root);
-    return narrows ? fields : undefined;
-};
-/** The words and phrases the query asks for, for the meaning half to embed; none it excludes, no field. */
-export const meaningWords = (root) => {
-    const wanted = (node) => node.kind === "boolean"
-        ? node.clauses.flatMap(({ occur, node }) => (occur === "must_not" ? [] : wanted(node)))
-        : WORD_FIELDS.has(node.field) && (node.operator === "term" || node.operator === "phrase")
-            ? [node.value]
-            : [];
-    return wanted(root).join(" ").trim();
-};
+/** `in:notes` holds for every note and document. */
+const EVERY_NOTE = { kind: "predicate", field: "in", operator: "term", value: "notes" };
+export const fieldsOfQuery = (root) => fieldsOf(root, EVERY_NOTE);
 const allOf = (nodes) => nodes.length <= 1
     ? nodes[0]
     : {
@@ -286,7 +252,7 @@ const allOf = (nodes) => nodes.length <= 1
 const matching = async (store, refs, root, scope) => {
     if (refs.length === 0)
         return new Map();
-    const resolved = await resolvedQuery(store, root ?? { kind: "predicate", field: "in", operator: "term", value: "notes", span: { start: 0, end: 0 } }, scope.timezone);
+    const resolved = await resolvedQuery(store, root ?? { ...EVERY_NOTE, span: { start: 0, end: 0 } }, scope.timezone);
     const found = await store.notes.search({
         root: resolved.root,
         refs,

package/dist/services/search-all.js

@@ -123,7 +123,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
             return byWords;
         }
         messagesBy = { by: "words and meaning", ...(lane.partly ? { meaningSkipped: lane.partly } : {}) };
-        const near = await nearEligible(store, account, query, messenger, lane.ranked, filters ?? "");
+        const near = await nearEligible(store, account, query, messenger, lane.ranked, filters ? { text: filters } : {});
         // One list per resource, as notes give theirs, so messages get no second vote against mail.
         const fused = new Map();
         byWords.forEach((item, rank) => {

package/dist/store/index.d.ts

@@ -51,6 +51,7 @@ export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people
 export type { ProposalInput, ProposedAction, ProposedActionsStore } from "./sqlite/proposed-actions.js";
 export { PROPOSAL_STATUSES } from "./sqlite/proposed-actions.js";
 export { fillSearchIndex, resetSearchIndex, type SearchIndexFill, type SearchIndexState, searchIndexState, } from "./sqlite/search-index.js";
+export type { SyncStateSave } from "./sqlite/sync.js";
 export type { TagCreationOptions, TagCreationReview } from "./sqlite/tag-creation.js";
 export type { TagKind, TagRow } from "./sqlite/tags.js";
 export type { SimilarSubject, SimilarTask, TaskDraft } from "./sqlite/task-candidates.js";

package/dist/store/queries.d.ts

@@ -15,6 +15,8 @@ export interface QueriesStore {
     countQuery(execution: QueryExecution, by: QueryGrouping): Promise<QueryGroup[]>;
     /** How many messages match, counted no further than `cap + 1`; `undefined` when only a full search could tell. */
     countMatches(execution: QueryExecution, cap: number): Promise<number | undefined>;
+    /** The keys of the messages that match, no more than `cap + 1`; `undefined` when only a full search could tell. */
+    matchingPks(execution: QueryExecution, cap: number): Promise<number[] | undefined>;
     conversationEligibility(execution: QueryExecution): Promise<ConversationEligibility>;
     rankQuery(execution: QueryExecution, request: RankingRequest): Promise<RankedStoreFound>;
     rankingEvidence(execution: QueryExecution, request: RankingEvidenceRequest): Promise<RankedEvidence>;

package/dist/store/queries.js

@@ -14,6 +14,7 @@ export const queriesStoreOver = (context, stemmerFor) => {
         matchQuery: async (execution) => lucene.matchQuery(context, mailIndexed(execution)),
         countQuery: async (execution, by) => lucene.countQuery(context, mailIndexed(execution), by),
         countMatches: async (execution, cap) => lucene.countMatches(context, mailIndexed(execution), cap),
+        matchingPks: async (execution, cap) => lucene.matchingPks(context, mailIndexed(execution), cap),
         conversationEligibility: async (execution) => conversationEligibility(context, execution),
         rankQuery: async (execution, request) => rankQuery(context, execution, request),
         rankingEvidence: async (execution, request) => rankingEvidence(context, execution, request),

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

@@ -7,6 +7,7 @@ import { type EmailLocationInput, type FolderEmail } from "./email-locations.js"
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
 import type { StoreContext } from "./open.js";
+import { type SyncStateSave } from "./sync.js";
 export type { EmailLocationInput, FolderEmail };
 export interface EmailAddress {
     address: string;
@@ -203,6 +204,8 @@ export interface SenderScore {
 /** Mail in tables of its own: threads, emails, recipients and mailboxes, keyed by account and Message-ID. */
 export interface MailStore {
     saveThread(input: ThreadSave): Promise<ThreadDetails>;
+    /** Several threads and sync state in one transaction: a slice of mail commits with its resume point, or not at all. */
+    saveThreads(inputs: ThreadSave[], states?: SyncStateSave[]): Promise<ThreadDetails[]>;
     /** Newest activity first. */
     threads(filter?: MailFilter): Promise<EmailThread[]>;
     thread(id: number): Promise<ThreadDetails | null>;
@@ -280,4 +283,4 @@ export declare const emailHitsByPk: (database: CacheDatabase, pks: number[]) =>
  * Indexes the queued emails as the notes are indexed, words and stems of the subject, then the body; then cuts
  * the threads they belong to into pieces for search by meaning.
  */
-export declare const mailStoreOver: ({ database, orm }: Pick<StoreContext, "database" | "orm">, stemmerFor?: (stemmers: Stemmers) => Stemmer) => MailStore;
+export declare const mailStoreOver: ({ database, orm, now }: Pick<StoreContext, "database" | "orm" | "now">, stemmerFor?: (stemmers: Stemmers) => Stemmer) => MailStore;

package/dist/store/sqlite/emails.js

@@ -10,6 +10,7 @@ import { ensurePerson } from "./identities.js";
 import { mailRulesOver } from "./mail-rules.js";
 import { attachmentOf, saveAttachment, wordsQuery } from "./meetings.js";
 import { stemmerCache } from "./stems.js";
+import { writeState } from "./sync.js";
 import { write } from "./transaction.js";
 import { dropUnusedVectors } from "./vector-index.js";
 import { dot } from "./vectors.js";
@@ -415,12 +416,21 @@ export const emailHitsByPk = (database, pks) => {
  * Indexes the queued emails as the notes are indexed, words and stems of the subject, then the body; then cuts
  * the threads they belong to into pieces for search by meaning.
  */
-export const mailStoreOver = ({ database, orm }, stemmerFor = stemmerCache()) => ({
+export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache()) => ({
     rules: mailRulesOver(database),
     async saveThread(input) {
         const id = write(database, () => saveThread(database, orm, input));
         return threadDetails(database, id);
     },
+    async saveThreads(inputs, states = []) {
+        const ids = write(database, () => {
+            const saved = inputs.map((input) => saveThread(database, orm, input));
+            for (const { accountId, name, value } of states)
+                writeState({ orm, now }, accountId, name, value);
+            return saved;
+        });
+        return ids.map((id) => threadDetails(database, id));
+    },
     async threads(filter = {}) {
         const [limit, offset] = page(filter);
         return database

package/dist/store/sqlite/facts.js

@@ -3,7 +3,7 @@ import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
-import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, linkEvidence, subjectOf, } from "./memories.js";
+import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, keepHighestId, linkEvidence, nextId, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.js";
 import { write } from "./transaction.js";
 const NAMED = "SELECT f.*, b.name AS author_name FROM facts f LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id";
@@ -80,10 +80,10 @@ export const factOperationsOver = (context) => {
                 const { actor, model } = authorActor(context, input.by);
                 const at = now();
                 const made = Number(database
-                    .prepare("INSERT INTO facts (type, statement, status, project_id, subject_type, subject_id, occurred_at, supersedes_id, " +
+                    .prepare("INSERT INTO facts (id, type, statement, status, project_id, subject_type, subject_id, occurred_at, supersedes_id, " +
                     "author_type, author_id, model, scope, source, created_at, updated_at) " +
-                    "VALUES (?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", at, at)?.id);
+                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", at, at)?.id);
                 linkEvidence(context, { type: "fact", id: made }, input.evidence ?? [], owner ? "owner" : "agent");
                 if (input.createdFrom !== undefined) {
                     const from = requiredThing(database, input.createdFrom, "the source");
@@ -135,6 +135,9 @@ export const factOperationsOver = (context) => {
             const id = Number(row.id);
             const twin = row.source === "memory" && row.metadata != null ? migratedFrom(String(row.metadata)) : undefined;
             const links = erase(database, () => {
+                keepHighestId(database, "facts", now());
+                if (twin !== undefined)
+                    keepHighestId(database, "memories", now());
                 database.prepare("UPDATE facts SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
                 const count = dropLinksOf(database, { type: "fact", id });
                 database.prepare("DELETE FROM links WHERE from_type = 'fact' AND from_id = ?").run(id);

package/dist/store/sqlite/follow-ups.js

@@ -17,14 +17,14 @@ export const laterSharingRare = (context, wanted, { rareAt, limit }) => {
     if (!wanted.length || !stemmers || !stemsState(database)?.ready)
         return wanted.map(() => []);
     const stemmer = stemmerFor(stemmers);
-    // A temporary table: reading the index's own counts needs no migration, and it leaves with the connection.
-    database.exec("CREATE VIRTUAL TABLE IF NOT EXISTS temp.message_stem_counts USING fts5vocab(main, message_stems, col)");
-    const count = database.prepare("SELECT doc FROM temp.message_stem_counts WHERE term = ? AND col = 'stems'");
+    // Counted only up to one past `rareAt`, so a common word costs no more than a rare one. Not an fts5vocab table:
+    // creating one is a write, which a read-only connection refuses.
+    const count = database.prepare("SELECT count(*) AS doc FROM (SELECT rowid FROM message_stems WHERE message_stems MATCH ? LIMIT ?)");
     const counts = new Map();
     const countOf = (stem) => {
         let found = counts.get(stem);
         if (found === undefined) {
-            found = Number(count.get(stem)?.doc ?? 0);
+            found = Number(count.get(`stems : "${stem.replaceAll('"', '""')}"`, rareAt + 1)?.doc ?? 0);
             counts.set(stem, found);
         }
         return found;

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

@@ -18,11 +18,13 @@ export declare const matchQuery: (context: StoreContext, execution: QueryExecuti
 export declare const countQuery: (context: StoreContext, execution: QueryExecution, by: QueryGrouping) => Promise<QueryGroup[]>;
 /** All matching message keys, without materializing message bodies or imposing a hit-page limit. */
 export declare const queryMessagePks: (context: StoreContext, execution: QueryExecution) => Promise<number[]>;
+/** How many messages match, counting no further than `cap + 1`; `undefined` as `matchingPks` says. */
+export declare const countMatches: (context: StoreContext, execution: QueryExecution, cap: number) => number | undefined;
 /**
- * How many messages match, counting no further than `cap + 1`: one SQL count, unranked. `undefined` when a leaf is
- * checked row by row (a preset, a pattern), where a count would cost as much as the search itself.
+ * The keys of the messages that match, no more than `cap + 1`: one SQL query, unranked. `undefined` when a leaf is
+ * checked row by row (a preset, a pattern), where it would cost as much as the search itself.
  */
-export declare const countMatches: (context: StoreContext, execution: QueryExecution, cap: number) => number | undefined;
+export declare const matchingPks: (context: StoreContext, execution: QueryExecution, cap: number) => number[] | undefined;
 interface QuerySelection {
     sql: string;
     params: SqlValue[];

package/dist/store/sqlite/lucene.js

@@ -48,22 +48,24 @@ export const matchQuery = (context, execution) => runQuery(context, execution);
 export const countQuery = (context, execution, by) => runQuery(context, execution, by);
 /** All matching message keys, without materializing message bodies or imposing a hit-page limit. */
 export const queryMessagePks = (context, execution) => runQuery(context, execution, "pks");
+/** How many messages match, counting no further than `cap + 1`; `undefined` as `matchingPks` says. */
+export const countMatches = (context, execution, cap) => matchingPks(context, execution, cap)?.length;
 /**
- * How many messages match, counting no further than `cap + 1`: one SQL count, unranked. `undefined` when a leaf is
- * checked row by row (a preset, a pattern), where a count would cost as much as the search itself.
+ * The keys of the messages that match, no more than `cap + 1`: one SQL query, unranked. `undefined` when a leaf is
+ * checked row by row (a preset, a pattern), where it would cost as much as the search itself.
  */
-export const countMatches = (context, execution, cap) => {
+export const matchingPks = (context, execution, cap) => {
     const { database, check, where, from, withRanking, ranked, leaves } = compileQuery(context, {
         ...execution,
         newest: true,
     });
     if (leaves.some(({ test }) => test))
         return undefined;
-    const row = database
-        .prepare(`SELECT count(*) AS n FROM (${withRanking}SELECT m.id ${from} WHERE ${where.sql} LIMIT ?)`)
-        .get(...ranked.params, ...where.params, cap + 1);
+    const rows = database
+        .prepare(`${withRanking}SELECT m.id ${from} WHERE ${where.sql} LIMIT ?`)
+        .all(...ranked.params, ...where.params, cap + 1);
     check();
-    return Number(row?.n ?? 0);
+    return rows.map(({ id }) => Number(id));
 };
 const compileQuery = (context, execution, boundedAttachments = false) => {
     const { database } = context;

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

@@ -100,6 +100,14 @@ export declare const evidenceOf: (context: StoreContext, from: {
 }) => string[];
 /** What a memory's or fact's subject is called, for a reader who should not have to look the reference up. */
 export declare const subjectOf: (database: StoreContext["database"], row: Row) => Pick<Memory, "subject" | "subjectName" | "subjectIsOwner">;
+type Numbered = "memories" | "facts";
+/**
+ * The id the next row takes: above every row there is and every one forgotten. SQLite hands out the highest id + 1,
+ * so without this a forgotten record's number would name the next one, and a stale `memory:N` act on it.
+ */
+export declare const nextId: (database: StoreContext["database"], table: Numbered) => number;
+/** Before a delete: remembers the highest id handed out, which the delete may be about to free. */
+export declare const keepHighestId: (database: StoreContext["database"], table: Numbered, at: number) => void;
 /** Counts every link from or to a row and drops the ones its delete trigger does not: those pointing at it. */
 export declare const dropLinksOf: (database: StoreContext["database"], thing: {
     type: string;

package/dist/store/sqlite/memories.js

@@ -64,6 +64,23 @@ export const subjectOf = (database, row) => {
         subjectIsOwner: Number(named?.owner) === 1,
     };
 };
+const highestKey = (table) => `ids.${table}.highest`;
+/**
+ * The id the next row takes: above every row there is and every one forgotten. SQLite hands out the highest id + 1,
+ * so without this a forgotten record's number would name the next one, and a stale `memory:N` act on it.
+ */
+export const nextId = (database, table) => {
+    const kept = database.prepare("SELECT value FROM store_settings WHERE key = ?").get(highestKey(table));
+    const highest = database.prepare(`SELECT max(id) AS id FROM ${table}`).get();
+    return Math.max(Number(kept?.value ?? 0), Number(highest?.id ?? 0)) + 1;
+};
+/** Before a delete: remembers the highest id handed out, which the delete may be about to free. */
+export const keepHighestId = (database, table, at) => {
+    const highest = nextId(database, table) - 1;
+    database
+        .prepare("INSERT OR REPLACE INTO store_settings (key, value, at) VALUES (?, ?, ?)")
+        .run(highestKey(table), String(highest), at);
+};
 /** Counts every link from or to a row and drops the ones its delete trigger does not: those pointing at it. */
 export const dropLinksOf = (database, thing) => {
     const count = Number(database
@@ -153,9 +170,9 @@ export const memoriesStoreOver = (context) => {
                 const replaced = input.supersedes === undefined ? undefined : Number(rowOf(input.supersedes).id);
                 const at = now();
                 const made = Number(database
-                    .prepare("INSERT INTO memories (kind, body, subject_type, subject_id, author_type, author_id, model, confidence, status, " +
-                    "last_verified_at, supersedes_id, scope, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(kind, body, subject?.type ?? null, subject?.id ?? null, actor.type, actor.id, model, input.confidence ?? null, status, status === "confirmed" ? at : null, replaced ?? null, scope, at, at)?.id);
+                    .prepare("INSERT INTO memories (id, kind, body, subject_type, subject_id, author_type, author_id, model, confidence, status, " +
+                    "last_verified_at, supersedes_id, scope, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(nextId(database, "memories"), kind, body, subject?.type ?? null, subject?.id ?? null, actor.type, actor.id, model, input.confidence ?? null, status, status === "confirmed" ? at : null, replaced ?? null, scope, at, at)?.id);
                 linkEvidence(context, { type: "memory", id: made }, input.evidence, input.author === "owner" ? "owner" : "agent");
                 if (replaced !== undefined)
                     database.prepare("UPDATE memories SET status = 'superseded', updated_at = ? WHERE id = ?").run(at, replaced);
@@ -178,6 +195,7 @@ export const memoriesStoreOver = (context) => {
         remove: async (reference) => {
             const id = Number(rowOf(reference).id);
             const links = erase(database, () => {
+                keepHighestId(database, "memories", now());
                 database.prepare("UPDATE memories SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
                 const count = dropLinksOf(database, { type: "memory", id });
                 database.prepare("DELETE FROM memories WHERE id = ?").run(id);

package/dist/store/sqlite/message-chunks.d.ts

@@ -39,6 +39,12 @@ type MessageFilter = {
     since?: number;
     before?: number;
 };
+/** Each of the account's messages among `pks` that has a vector of `model`, scored against `query`, best first. */
+export declare const scoreMessages: ({ orm }: StoreContext, accountPk: number, { model, query, pks }: {
+    model: string;
+    query: Float32Array;
+    pks: number[];
+}) => NearestMessage[];
 /** The account's live messages nearest to `query` by their vector of `model`, best first. */
 export declare const nearestMessages: (context: StoreContext, accountPk: number, { limit, query, ...filter }: MessageFilter & {
     limit: number;

package/dist/store/sqlite/message-chunks.js

@@ -59,6 +59,16 @@ const messageRows = ({ orm }, accountPk, { chatKey, model, since, before }, rows
         ${"ids" in rows
     ? sql `AND k.id IN (SELECT value FROM json_each(${JSON.stringify(rows.ids)})) ORDER BY k.id`
     : sql `AND k.id > ${rows.after} ORDER BY k.id LIMIT ${SCAN_PAGE}`}`);
+/** Each of the account's messages among `pks` that has a vector of `model`, scored against `query`, best first. */
+export const scoreMessages = ({ orm }, accountPk, { model, query, pks }) => orm
+    .all(sql `SELECT ch.external_id AS chatId, m.external_id AS messageId, v.vector
+        FROM chunks k CROSS JOIN messages m ON m.id = k.chunkable_id AND m.deleted_at IS NULL
+          JOIN chats ch ON ch.id = m.chat_id AND ch.searchable = 1
+          JOIN embeddings v ON v.model = ${model} AND v.content_hash = k.content_hash
+        WHERE k.chunkable_type = 'message' AND k.position = 0 AND k.account_id = ${accountPk}
+          AND k.chunkable_id IN (SELECT value FROM json_each(${JSON.stringify(pks)}))`)
+    .map(({ chatId, messageId, vector }) => ({ chatId, messageId, score: dot(query, vector) }))
+    .sort((a, b) => b.score - a.score);
 /** The account's live messages nearest to `query` by their vector of `model`, best first. */
 export const nearestMessages = (context, accountPk, { limit, query, ...filter }) => {
     const score = (row) => ({

package/dist/store/sqlite/project-transfer/records.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { fold } from "../../normalize.js";
+import { nextId } from "../memories.js";
 import { thingOf } from "../things.js";
 export const restoreAnnotationRecords = (database, projectId, snapshot, bindings) => {
     const mappings = { ...bindings };
@@ -24,8 +25,8 @@ export const restoreAnnotationRecords = (database, projectId, snapshot, bindings
         if (!author)
             throw new CliError("validation_error", "project annotation author is required");
         const row = database
-            .prepare("INSERT INTO facts(type,statement,status,project_id,subject_type,subject_id,occurred_at,supersedes_id,author_type,author_id,model,confirmed_by_type,confirmed_by_id,scope,source,created_at,updated_at) VALUES(?,?,?,?,NULL,NULL,?,NULL,?,?,?,?,?,?,?,?,?) RETURNING id")
-            .get(fact.type, fact.statement, fact.status, projectId, fact.occurred_at, author.type, author.id, fact.model, confirmed?.type ?? null, confirmed?.id ?? null, fact.scope, fact.source, fact.created_at, fact.updated_at);
+            .prepare("INSERT INTO facts(id,type,statement,status,project_id,subject_type,subject_id,occurred_at,supersedes_id,author_type,author_id,model,confirmed_by_type,confirmed_by_id,scope,source,created_at,updated_at) VALUES(?,?,?,?,?,NULL,NULL,?,NULL,?,?,?,?,?,?,?,?,?) RETURNING id")
+            .get(nextId(database, "facts"), fact.type, fact.statement, fact.status, projectId, fact.occurred_at, author.type, author.id, fact.model, confirmed?.type ?? null, confirmed?.id ?? null, fact.scope, fact.source, fact.created_at, fact.updated_at);
         if (!row)
             throw new CliError("configuration_error", "project annotation fact insertion failed");
         mappings[fact.ref] = `fact:${row.id}`;

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

@@ -3,7 +3,13 @@ export declare const syncStateOf: ({ orm }: StoreContext, accountKey: number, na
     value: string;
     at: string;
 } | undefined;
-export declare const writeState: ({ orm, now }: StoreContext, accountKey: number, name: string, value: string) => void;
+/** A sync state value saved with `MailStore.saveThreads`, by the account's row id. */
+export interface SyncStateSave {
+    accountId: number;
+    name: string;
+    value: string;
+}
+export declare const writeState: ({ orm, now }: Pick<StoreContext, "orm" | "now">, accountKey: number, name: string, value: string) => void;
 export declare const clearState: ({ orm }: StoreContext, accountKey: number, name: string) => void;
 /** Taken when free, expired, or already this holder's; another holder's running lease stays. */
 export declare const claim: ({ orm, now }: StoreContext, chatKey: number, anchor: string, holder: string, forMs: number) => boolean;

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

@@ -11,7 +11,8 @@ export declare const write: <T>(database: CacheDatabase, body: () => T, { before
 /**
  * A write to tables that queue no derived work, in a loop that budgets its lock time or reports what it did: a fill,
  * a backfill, a rebuild. It drains nothing, so it neither does nor hides another write's work; the queues wait for
- * the next `write`.
+ * the next `write`. The outermost pauses 2 ms after it commits: a loop that begins again at once leaves another
+ * process's `write` a gap of microseconds, and it misses that gap until its 5 s wait runs out.
  */
 export declare const writeBatch: <T>(database: CacheDatabase, body: () => T) => T;
 /** Several queries that must see one state of the file. Never drains: that is the outer write's work, or nobody's. */

package/dist/store/sqlite/transaction.js

@@ -11,7 +11,8 @@ const isBusy = (error) => {
 /**
  * Takes the write lock, waiting as long as the connection's `busy_timeout`. SQLite's own wait sleeps 1 ms, then up to
  * 100 ms between tries, so a process that commits and begins again at once is never seen free and the waiter fails
- * with "database is locked" after the full timeout. Trying every millisecond sees the gap between two writes.
+ * with "database is locked" after the full timeout. Trying every millisecond sees a gap of a fraction of a
+ * millisecond between two writes; a writer that leaves none still starves it, hence `writeBatch`'s pause.
  */
 const beginImmediate = (database) => {
     const timeout = Number(database.prepare("PRAGMA busy_timeout").get()?.timeout ?? 0);
@@ -53,9 +54,17 @@ export const write = (database, body, { beforeCommit } = {}) => transact(databas
 /**
  * A write to tables that queue no derived work, in a loop that budgets its lock time or reports what it did: a fill,
  * a backfill, a rebuild. It drains nothing, so it neither does nor hides another write's work; the queues wait for
- * the next `write`.
+ * the next `write`. The outermost pauses 2 ms after it commits: a loop that begins again at once leaves another
+ * process's `write` a gap of microseconds, and it misses that gap until its 5 s wait runs out.
  */
-export const writeBatch = (database, body) => transact(database, body, false);
+export const writeBatch = (database, body) => {
+    const outer = connectionOf(database).depth === 0;
+    const result = transact(database, body, false);
+    if (outer)
+        Atomics.wait(pause, 0, 0, BATCH_PAUSE_MS);
+    return result;
+};
+const BATCH_PAUSE_MS = 2;
 const transact = (database, body, drain, beforeCommit) => {
     const connection = connectionOf(database);
     if (connection.reading)

package/dist/store/vectors.d.ts

@@ -87,6 +87,19 @@ export interface AccountVectors {
         messageId: Id;
         score: number;
     }[]>;
+    /**
+     * The account's messages among `pks` (store keys, as a query's matches give them) scored against `query` by their
+     * own vector of `model`, best first: a filter's own messages ranked, not the nearest overall.
+     */
+    scoreMessages(key: AccountKey, options: {
+        model: string;
+        query: Float32Array;
+        pks: number[];
+    }): Promise<{
+        chatId: Id;
+        messageId: Id;
+        score: number;
+    }[]>;
     /** The current build's distinct chunks, and how many have a vector of `model`. */
     vectorStatus(key: AccountKey, chatId: Id, model: string): Promise<{
         chunks: number;

package/dist/store/vectors.js

@@ -147,6 +147,10 @@ export const accountVectorsOver = (context, mail) => {
                 query,
             });
         },
+        scoreMessages: async (key, options) => {
+            const accountPk = findAccountPk(key);
+            return accountPk === undefined ? [] : messageChunks.scoreMessages(context, accountPk, options);
+        },
         vectorStatus: async (key, chatId, model) => {
             const chatKey = chatKeyOf(key, chatId);
             return chatKey === undefined ? { chunks: 0, embedded: 0 } : vectors.vectorStatus(context, chatKey, model);

package/dist/terminal/sign-in-steps.js

@@ -2,6 +2,7 @@ import { StringDecoder } from "node:string_decoder";
 import { CliError } from "@wirecat/cli-base";
 import { Option } from "commander";
 import { MAX_SECRET_INPUT } from "../cli/input-policy.js";
+import { stepLines } from "./step-lines.js";
 /**
  * Opt-in, because a read nobody answers hangs: an agent running `session start` in a shell must get the refusal it
  * gets today, and only a caller that holds stdin open and answers each `needs` line (WireCat Desktop) passes it.
@@ -10,10 +11,7 @@ export const answerStdinOption = () => new Option("--answer-stdin", "with --json
 export const signInSteps = ({ diagnostic, json, answers, input = process.stdin }) => {
     if (answers && !json)
         throw new CliError("validation_error", "--answer-stdin needs --json");
-    const emit = (event) => {
-        if (json)
-            diagnostic(JSON.stringify(event));
-    };
+    const emit = stepLines(diagnostic, json);
     const next = answers ? lineReader(input) : undefined;
     return {
         json,

package/dist/terminal/step-lines.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Machine-readable step lines: one JSON object per line on the diagnostic stream, only in `--json` / `--jsonl`, so
+ * stdout keeps its single answer and a person at a terminal sees nothing new. Sign-in and `messages sync` share it.
+ */
+export declare const stepLines: (diagnostic: (line: string) => void, json: boolean) => (event: Record<string, unknown> & {
+    event: string;
+}) => void;

package/dist/terminal/step-lines.js

@@ -0,0 +1,8 @@
+/**
+ * Machine-readable step lines: one JSON object per line on the diagnostic stream, only in `--json` / `--jsonl`, so
+ * stdout keeps its single answer and a person at a terminal sees nothing new. Sign-in and `messages sync` share it.
+ */
+export const stepLines = (diagnostic, json) => (event) => {
+    if (json)
+        diagnostic(JSON.stringify(event));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.505.0",
+  "version": "0.507.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",
@@ -247,7 +247,7 @@
     "@types/node": "^22.20.5",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.5",
-    "@wirecat/cli-base": "0.67.0",
+    "@wirecat/cli-base": "0.68.0",
     "@wirecat/cli-core-legacy-tags": "npm:@wirecat/cli-core@0.414.0",
     "commander": "15.0.0",
     "cspell": "10.4.0",
@@ -267,7 +267,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.67.0 <0.68.0",
+    "@wirecat/cli-base": ">=0.68.0 <0.69.0",
     "commander": ">=15"
   },
   "bin": {