@wirecat/cli-core 0.379.0 → 0.381.0

package/dist/store/sqlite/meeting-hit-search.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
-import { formatMeetingReference } from "../../meetings/index.js";
-import { normalize } from "../normalize.js";
+import { formatMeetingReference, parseMeetingQuery } from "../../meetings/index.js";
+import { matchMeetingText, meetingQuerySql, resolveMeetingQuery } from "./meeting-hit-query.js";
 import { indexedText } from "./meeting-index-values.js";
 import { checkMeetingCancelled } from "./meeting-operation.js";
 import { positiveReadInteger } from "./meeting-reads.js";
-import { meetingStemmableText, meetingStemState } from "./meeting-stem-state.js";
+import { meetingStemState } from "./meeting-stem-state.js";
 import { read } from "./transaction.js";
 const fail = (message) => {
     throw new CliError("validation_error", message);
@@ -42,8 +42,9 @@ const cursorOf = (value, key) => {
     catch {
         return fail("Invalid meeting search cursor");
     }
-    if (parsed?.version !== 1 ||
+    if (parsed?.version !== 2 ||
         parsed.key !== key ||
+        ![0, 1, 2].includes(parsed.tier) ||
         !Number.isSafeInteger(parsed.started) ||
         Math.abs(parsed.started) > 8640000000000000 ||
         !Number.isSafeInteger(parsed.meeting) ||
@@ -86,21 +87,14 @@ export function meetingHitSearchOver({ database }) {
                 fail("Meeting search limit must be from 1 through 1000");
             if (!Number.isSafeInteger(maxReadBytes) || maxReadBytes < 1 || maxReadBytes > 64 * 1024 ** 2)
                 fail("Meeting search byte limit must be from 1 through 67108864");
-            if (typeof rawQuery !== "string" || Buffer.byteLength(rawQuery) > 65536)
+            if (typeof rawQuery === "string" && Buffer.byteLength(rawQuery) > 65536)
                 fail("Meeting search query must be a bounded string");
-            const rawWords = rawQuery.match(/[\p{L}\p{N}\p{M}]+/gu)?.filter((word) => normalize(word)) ?? [];
-            if (rawWords.length > 128)
-                fail("Meeting search supports at most 128 query words");
+            const ast = typeof rawQuery === "string" ? parseMeetingQuery(rawQuery) : rawQuery;
             return read(database, () => {
                 checkMeetingCancelled(input.signal);
                 const state = meetingStemState(database, input.accountId);
-                const terms = rawWords.map((raw) => ({
-                    literal: normalize(raw),
-                    stems: state.stemmer && raw.length <= 1024
-                        ? [...new Set(state.stemmer.explain(raw).map((word) => word.stem))]
-                        : [],
-                }));
-                const key = fingerprint(JSON.stringify(terms), input, state.identity);
+                const tree = resolveMeetingQuery(database, input.accountId, ast, state);
+                const key = fingerprint(JSON.stringify(tree), input, state.identity);
                 const after = cursorOf(input.after, key);
                 const pending = database
                     .prepare(`SELECT 1 FROM meeting_index_pending p
@@ -118,20 +112,8 @@ export function meetingHitSearchOver({ database }) {
                     indexing: pending || !state.stemmer || state.through < state.watermark ? "pending" : "ready",
                     indexCompleteness: "unknown",
                 };
-                if (terms.length === 0)
-                    return { items: [], hasMore: false, nextCursor: null, coverage };
                 const clauses = ["m.account_id=?", "m.deleted_at IS NULL"];
-                const queryParams = [];
-                const termTables = terms.map((term, i) => {
-                    queryParams.push(`normalized_text : ("${term.literal}"*)`);
-                    let select = "SELECT rowid AS rid FROM meeting_words WHERE meeting_words MATCH ?";
-                    if (state.stemmer && state.through > 0 && term.stems.length) {
-                        queryParams.push(`stems : (${term.stems.map((stem) => `"${stem.replaceAll('"', '""')}"`).join(" OR ")})`, state.through);
-                        select += " UNION SELECT rowid AS rid FROM meeting_stems WHERE meeting_stems MATCH ? AND rowid<=?";
-                    }
-                    return `term_${i} AS (${select})`;
-                });
-                const matching = terms.map((_, i) => `SELECT rid FROM term_${i}`).join(" INTERSECT ");
+                const { sql: matching, params: queryParams } = meetingQuerySql(tree, state);
                 const params = [input.accountId];
                 if (input.meetingId !== undefined) {
                     clauses.push("m.id=?");
@@ -170,17 +152,17 @@ export function meetingHitSearchOver({ database }) {
                     params.push(input.tagId);
                 }
                 const seek = after
-                    ? "WHERE h.started<? OR (h.started=? AND (h.meeting_id>? OR (h.meeting_id=? AND (h.kind>? OR (h.kind=? AND h.id>?)))))"
+                    ? "WHERE h.tier>? OR (h.tier=? AND (h.started<? OR (h.started=? AND (h.meeting_id>? OR (h.meeting_id=? AND (h.kind>? OR (h.kind=? AND h.id>?)))))))"
                     : "";
                 if (after)
-                    params.push(after.started, after.started, after.meeting, after.meeting, after.kind, after.kind, after.id);
-                const sql = `WITH ${termTables.join(",")}, matches AS (${matching}), matching AS (SELECT rid FROM matches h WHERE NOT EXISTS(SELECT 1 FROM meeting_index_pending p WHERE p.id=h.rid/4 AND p.indexable_type=CASE h.rid%4 WHEN 1 THEN 'meeting_transcript_row' WHEN 2 THEN 'meeting_chat_message' ELSE 'meeting_summary' END)), selected AS (SELECT m.id,coalesce(m.started_at,0) AS started FROM meetings m WHERE ${clauses.join(" AND ")}), hits AS (
-        SELECT m.started,m.id AS meeting_id,0 AS kind,r.id,r.start_ms,${bytes("r", ["text"])} AS bytes,t.id AS transcript_id,r.position FROM matching h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4 JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id AND t.superseded_at IS NULL AND t.deleted_at IS NULL JOIN selected m ON m.id=t.meeting_id
-        UNION ALL SELECT m.started,m.id,1,c.id,NULL,${bytes("c", ["text"])},NULL,NULL FROM matching h JOIN meeting_chat_messages c ON h.rid%4=2 AND c.id=h.rid/4 JOIN selected m ON m.id=c.meeting_id
-        UNION ALL SELECT m.started,m.id,2,s.id,NULL,${bytes("s", fields)},NULL,NULL FROM matching h JOIN meeting_summaries s ON h.rid%4=3 AND s.id=h.rid/4 JOIN selected m ON m.id=s.meeting_id)
+                    params.push(after.tier, after.tier, after.started, after.started, after.meeting, after.meeting, after.kind, after.kind, after.id);
+                const sql = `WITH matches AS (${matching}), matching AS (SELECT rid,tier FROM matches h WHERE NOT EXISTS(SELECT 1 FROM meeting_index_pending p WHERE p.id=h.rid/4 AND p.indexable_type=CASE h.rid%4 WHEN 1 THEN 'meeting_transcript_row' WHEN 2 THEN 'meeting_chat_message' ELSE 'meeting_summary' END)), selected AS (SELECT m.id,coalesce(m.started_at,0) AS started FROM meetings m WHERE ${clauses.join(" AND ")}), hits AS (
+        SELECT h.tier,m.started,m.id AS meeting_id,0 AS kind,r.id,r.start_ms,${bytes("r", ["text"])} AS bytes,t.id AS transcript_id,r.position FROM matching h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4 JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id AND t.superseded_at IS NULL AND t.deleted_at IS NULL JOIN selected m ON m.id=t.meeting_id
+        UNION ALL SELECT h.tier,m.started,m.id,1,c.id,NULL,${bytes("c", ["text"])},NULL,NULL FROM matching h JOIN meeting_chat_messages c ON h.rid%4=2 AND c.id=h.rid/4 JOIN selected m ON m.id=c.meeting_id
+        UNION ALL SELECT h.tier,m.started,m.id,2,s.id,NULL,${bytes("s", fields)},NULL,NULL FROM matching h JOIN meeting_summaries s ON h.rid%4=3 AND s.id=h.rid/4 JOIN selected m ON m.id=s.meeting_id)
         SELECT h.*,${bytes("m", ["title"])}+${bytes("s", ["doc_url"])} AS context_bytes FROM hits h
         JOIN meetings m ON m.id=h.meeting_id LEFT JOIN meeting_summaries s ON h.kind=2 AND s.id=h.id
-        ${seek} ORDER BY h.started DESC,h.meeting_id,h.kind,h.id LIMIT ?`;
+        ${seek} ORDER BY h.tier,h.started DESC,h.meeting_id,h.kind,h.id LIMIT ?`;
                 const rows = database.prepare(sql).all(...queryParams, ...params, limit + 1);
                 let total = 0;
                 const meetingMetadata = database.prepare("SELECT title,started_at FROM meetings WHERE id=? AND account_id=? AND deleted_at IS NULL");
@@ -232,15 +214,15 @@ export function meetingHitSearchOver({ database }) {
                         startMs: row.start_ms === null ? null : Number(row.start_ms),
                     };
                 });
-                const fresh = items.filter((item) => {
-                    const literalTokens = normalize(item.text).match(/[\p{L}\p{N}]+/gu) ?? [];
-                    const missing = terms.filter((term) => !literalTokens.some((token) => token.startsWith(term.literal)));
-                    if (missing.length === 0)
-                        return true;
-                    const stemTokens = state.stemmer
-                        ? new Set(state.stemmer.explain(meetingStemmableText(item.text)).map((word) => word.stem))
-                        : new Set();
-                    return missing.every((term) => term.stems.some((stem) => stemTokens.has(stem)));
+                const fresh = items.flatMap((item) => {
+                    const corrections = matchMeetingText(tree, item.text, state.stemmer);
+                    if (!corrections)
+                        return [];
+                    return [
+                        corrections.length
+                            ? { ...item, match: "corrected", corrections }
+                            : { ...item, match: "words" },
+                    ];
                 });
                 if (fresh.length !== items.length)
                     coverage.indexing = "pending";
@@ -248,8 +230,9 @@ export function meetingHitSearchOver({ database }) {
                 const hasMore = rows.length > limit;
                 const nextCursor = hasMore && last
                     ? Buffer.from(JSON.stringify({
-                        version: 1,
+                        version: 2,
                         key,
+                        tier: Number(last.tier),
                         started: Number(last.started),
                         meeting: Number(last.meeting_id),
                         kind: Number(last.kind),

package/dist/store/sqlite/meetings.js

@@ -166,14 +166,65 @@ export const saveAttachment = (database, type, parentId, a, now) => upsert(datab
     content_sha256: a.contentSha256,
     extracted_at: a.extractedAt,
 }, now);
+const FILE_SOURCE = "file";
+const SAME_OCCURRENCE_MS = 15 * 60_000;
+/** The account's record of this occurrence under another key: same series, the nearest start within 15 minutes. */
+const sameOccurrence = (database, meeting, seriesKey) => {
+    if (!seriesKey || meeting.startedAt === null)
+        return undefined;
+    const row = database
+        .prepare(`SELECT m.id,m.external_id,m.meeting_series_id,
+       EXISTS (SELECT 1 FROM meeting_transcripts t WHERE t.meeting_id=m.id AND t.source=?) AND
+       NOT EXISTS (SELECT 1 FROM meeting_transcripts t WHERE t.meeting_id=m.id AND t.source!=?) AS from_file
+       FROM meetings m JOIN meeting_series s ON s.id=m.meeting_series_id
+       WHERE m.account_id=? AND s.account_id=? AND s.external_id=? AND m.deleted_at IS NULL
+       AND m.started_at BETWEEN ? AND ? ORDER BY abs(m.started_at-?),m.id LIMIT 1`)
+        .get(FILE_SOURCE, FILE_SOURCE, meeting.accountId, meeting.accountId, seriesKey, meeting.startedAt - SAME_OCCURRENCE_MS, meeting.startedAt + SAME_OCCURRENCE_MS, meeting.startedAt);
+    return row
+        ? {
+            id: row.id,
+            externalId: row.external_id,
+            seriesId: row.meeting_series_id,
+            fromFile: Number(row.from_file) === 1,
+        }
+        : undefined;
+};
+/** A file's copy of an occurrence the provider already gave: its transcript only, and only where there is none. */
+const fillGap = (context, input, meetingId) => {
+    const { database } = context;
+    const held = database
+        .prepare("SELECT 1 FROM meeting_transcripts WHERE meeting_id = ? AND superseded_at IS NULL AND deleted_at IS NULL")
+        .get(meetingId);
+    if (held || !input.transcripts?.length)
+        return meetingId;
+    const participantIds = (input.participants ?? []).map(({ identity, ...p }) => upsert(database, "meeting_participants", {
+        meeting_id: meetingId,
+        identity_id: meetingIdentityPk({ ...context, now: () => input.now }, input.meeting.accountId, identity),
+    }, { display_name: p.displayName, email: p.email, role: p.role, external_id: p.externalId }, input.now));
+    saveTranscripts(database, meetingId, input.transcripts, (position) => (position === null ? null : (participantIds[position] ?? null)), input.now);
+    return meetingId;
+};
 const save = (context, input) => {
     const { database } = context;
     const { meeting: { series: seriesInput, ...meeting }, now, } = input;
     if (!Number.isSafeInteger(meeting.accountId) || meeting.accountId <= 0 || !meeting.externalId)
         throw new Error("Invalid meeting key");
-    const existing = database
+    let existing = database
         .prepare("SELECT id, meeting_series_id FROM meetings WHERE account_id = ? AND external_id = ?")
         .get(meeting.accountId, meeting.externalId);
+    const same = existing ? undefined : sameOccurrence(database, meeting, seriesInput?.externalId);
+    if (same?.fromFile === false && input.fromFile)
+        return fillGap(context, input, Number(same.id));
+    if (same && (same.fromFile || input.fromFile)) {
+        // A provider record takes over a record made from files; two files of one occurrence share the first one's key.
+        if (input.fromFile)
+            meeting.externalId = String(same.externalId);
+        else
+            database
+                .prepare("UPDATE meetings SET external_id = ?, updated_at = ? WHERE id = ?")
+                .run(meeting.externalId, now, Number(same.id));
+        existing = { id: same.id, meeting_series_id: same.seriesId };
+    }
     let seriesId = existing ? int(existing.meeting_series_id) : null;
     if (seriesInput) {
         if (!seriesInput.externalId)
@@ -228,6 +279,10 @@ const save = (context, input) => {
         return id;
     };
     saveTranscripts(database, meetingId, input.transcripts ?? [], participantId, now);
+    if ((input.transcripts ?? []).some((transcript) => transcript.source !== FILE_SOURCE))
+        database
+            .prepare("UPDATE meeting_transcripts SET superseded_at = ?, updated_at = ? WHERE meeting_id = ? AND source = ? AND superseded_at IS NULL")
+            .run(now, now, meetingId, FILE_SOURCE);
     for (const { senderParticipantPosition, ...line } of input.chat ?? []) {
         const values = {
             sent_at: line.sentAt,

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

@@ -1,4 +1,4 @@
-import type { Id, Message, PollVote, Provider, Reactions } from "../../domain/models.js";
+import type { Id, Message, PersonReaction, PollVote, Provider, Reactions } from "../../domain/models.js";
 import type { AccountKey, DeletionScope } from "../types.js";
 import type { StoreContext } from "./open.js";
 export declare const upsertMessage: (context: StoreContext, key: AccountKey, accountKey: number, chatKey: number, message: Message, via: string, seenAt?: number) => void;
@@ -7,11 +7,19 @@ export declare const upsertMessage: (context: StoreContext, key: AccountKey, acc
  * back, and leaves no text — not in the row, the search copy, the edit history, a transcript or a vector.
  */
 export declare const tombstone: (context: StoreContext, pk: number) => number;
-/** Whether the message is held at all. */
-export declare const saveReactions: ({ orm }: StoreContext, chatKey: number, messageId: Id, reactions: Reactions) => boolean;
+/** Whether the message is held at all. Where people's own reactions are held, the totals come from them instead. */
+export declare const saveReactions: (context: StoreContext, chatKey: number, messageId: Id, reactions: Reactions) => boolean;
 /** Answers whether the message is held; a deleted one keeps no star. */
 export declare const saveStar: ({ orm }: StoreContext, chatKey: number, messageId: Id, starred: boolean) => boolean;
 export declare const markDeleted: (context: StoreContext, accountKey: number, messageIds: Id[], chatId: Id | undefined, among?: DeletionScope) => number;
 /** A vote older than the one held for that voter is dropped, and so is any vote in a deleted poll. */
 export declare const saveVote: (context: StoreContext, accountKey: number, provider: Provider, chatKey: number, messageId: Id, { person, answers, votedAt }: PollVote) => void;
 export declare const pollVotes: ({ database }: StoreContext, chatKey: number, messageId: Id) => PollVote[];
+/**
+ * The totals of the people's reactions the store holds for a message, or `undefined` when it holds none: then the
+ * messenger's own totals stand. A taken-back reaction still counts as held, so all of them taken back is zero.
+ */
+export declare const derivedReactions: ({ database }: StoreContext, chatKey: number, messageId: Id) => Reactions | undefined;
+/** A reaction older than the one held for that person is dropped, and so is any reaction to a deleted message. */
+export declare const saveReaction: (context: StoreContext, accountKey: number, provider: Provider, chatKey: number, messageId: Id, { person, own, reaction, reactedAt }: PersonReaction) => void;
+export declare const writeDerivedReactions: (context: StoreContext, chatKey: number, messageId: Id) => void;

package/dist/store/sqlite/messages.js

@@ -174,6 +174,13 @@ export const upsertMessage = (context, key, accountKey, chatKey, message, via, s
         if (revived)
             orm.update(messages).set({ deletedAt: null, text: message.text }).where(eq(messages.id, pk)).run();
     }
+    const derived = derivedReactions(context, chatKey, message.id);
+    if (derived)
+        orm
+            .update(messages)
+            .set({ reactions: JSON.stringify(derived) })
+            .where(eq(messages.id, pk))
+            .run();
     if (message.counterObservations)
         applyCounterObservations(context, pk, message.counterObservations);
     if (message.starred !== undefined)
@@ -237,6 +244,9 @@ export const tombstone = (context, pk) => {
     context.database
         .prepare("DELETE FROM poll_votes WHERE chat_id=? AND message_external_id=?")
         .run(row.chatId, row.externalId);
+    context.database
+        .prepare("DELETE FROM message_reactions WHERE chat_id=? AND message_external_id=?")
+        .run(row.chatId, row.externalId);
     purgeVectorsOf(context, pk);
     orm
         .delete(messageTranscripts)
@@ -244,10 +254,10 @@ export const tombstone = (context, pk) => {
         .run();
     return 1;
 };
-/** Whether the message is held at all. */
-export const saveReactions = ({ orm }, chatKey, messageId, reactions) => orm
+/** Whether the message is held at all. Where people's own reactions are held, the totals come from them instead. */
+export const saveReactions = (context, chatKey, messageId, reactions) => context.orm
     .update(messages)
-    .set({ reactions: JSON.stringify(reactions) })
+    .set({ reactions: JSON.stringify(derivedReactions(context, chatKey, messageId) ?? reactions) })
     .where(and(eq(messages.chatId, chatKey), eq(messages.externalId, messageId), isNull(messages.deletedAt)))
     .returning({ pk: messages.id })
     .all().length > 0;
@@ -326,3 +336,64 @@ export const pollVotes = ({ database }, chatKey, messageId) => database
     answers: JSON.parse(answers),
     votedAt: new Date(votedAt).toISOString(),
 }));
+const reactionStatements = new WeakMap();
+const reactionStatementsOf = (database) => {
+    const held = reactionStatements.get(database);
+    if (held)
+        return held;
+    const statements = {
+        gone: database.prepare("SELECT 1 FROM messages WHERE chat_id=? AND external_id=? AND deleted_at IS NOT NULL"),
+        upsert: database.prepare(`INSERT INTO message_reactions
+         (chat_id, message_external_id, identity_id, own, reaction, reacted_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (chat_id, message_external_id, identity_id) DO UPDATE SET
+         own = excluded.own, reaction = excluded.reaction, reacted_at = excluded.reacted_at,
+         updated_at = excluded.updated_at
+       WHERE excluded.reacted_at >= message_reactions.reacted_at`),
+        held: database.prepare("SELECT reaction, own, reacted_at AS reactedAt FROM message_reactions WHERE chat_id=? AND message_external_id=?"),
+        total: database.prepare("UPDATE messages SET reactions=? WHERE chat_id=? AND external_id=? AND deleted_at IS NULL"),
+    };
+    reactionStatements.set(database, statements);
+    return statements;
+};
+/**
+ * The totals of the people's reactions the store holds for a message, or `undefined` when it holds none: then the
+ * messenger's own totals stand. A taken-back reaction still counts as held, so all of them taken back is zero.
+ */
+export const derivedReactions = ({ database }, chatKey, messageId) => {
+    const rows = reactionStatementsOf(database).held.all(chatKey, messageId);
+    if (rows.length === 0)
+        return undefined;
+    const counts = new Map();
+    let mine = null;
+    for (const { reaction, own, reactedAt } of rows) {
+        if (reaction === null)
+            continue;
+        const held = counts.get(reaction);
+        counts.set(reaction, { count: (held?.count ?? 0) + 1, first: Math.min(held?.first ?? reactedAt, reactedAt) });
+        if (own === 1 && (mine === null || reactedAt > mine.at))
+            mine = { reaction, at: reactedAt };
+    }
+    const sorted = [...counts].sort(([, a], [, b]) => b.count - a.count || a.first - b.first);
+    return {
+        counts: sorted.map(([reaction, { count }]) => ({ reaction, count })),
+        mine: mine?.reaction ?? null,
+        total: sorted.reduce((sum, [, { count }]) => sum + count, 0),
+    };
+};
+/** A reaction older than the one held for that person is dropped, and so is any reaction to a deleted message. */
+export const saveReaction = (context, accountKey, provider, chatKey, messageId, { person, own, reaction, reactedAt }) => {
+    const { database, now } = context;
+    const statements = reactionStatementsOf(database);
+    if (statements.gone.get(chatKey, messageId))
+        return;
+    const reactor = identityPk(context, accountKey, provider, person.id, person.name, person.username ? { username: person.username } : {});
+    const at = toMs(reactedAt) ?? now();
+    statements.upsert.run(chatKey, messageId, reactor, own ? 1 : 0, reaction, at, now(), now());
+    writeDerivedReactions(context, chatKey, messageId);
+};
+export const writeDerivedReactions = (context, chatKey, messageId) => {
+    const derived = derivedReactions(context, chatKey, messageId);
+    if (derived)
+        reactionStatementsOf(context.database).total.run(JSON.stringify(derived), chatKey, messageId);
+};

package/dist/store/sqlite/migrations.generated.js

@@ -554,5 +554,12 @@ export const GENERATED = [
             "CREATE TRIGGER chat_revisions_au AFTER UPDATE OF external_id, title, membership_state, scope, searchable, parent_chat_id ON chats BEGIN\n  INSERT INTO chat_revisions (chat_id, account_id, field, old_value, new_value, source, created_at)\n  SELECT new.id, new.account_id, f.field, f.old_value, f.new_value, s.source,\n    coalesce(s.at, CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER))\n  FROM (\n    SELECT 'external_id' AS field, old.external_id AS old_value, new.external_id AS new_value\n    UNION ALL SELECT 'title', old.title, new.title\n    UNION ALL SELECT 'membership_state', old.membership_state, new.membership_state\n    UNION ALL SELECT 'scope', old.scope, new.scope\n    UNION ALL SELECT 'searchable', old.searchable, new.searchable\n    UNION ALL SELECT 'parent_chat_id', old.parent_chat_id, new.parent_chat_id\n  ) f\n  LEFT JOIN chat_revision_source s ON s.id = 1\n  WHERE f.old_value IS NOT f.new_value;\nEND;",
             "CREATE TRIGGER chat_revisions_ad AFTER DELETE ON chats BEGIN\n  DELETE FROM chat_revisions WHERE chat_id = old.id;\nEND;"
         ]
+    },
+    {
+        "name": "20261021214318_version-26-message-reactions",
+        "statements": [
+            "CREATE TABLE `message_reactions` (\n\t`id` integer PRIMARY KEY,\n\t`chat_id` integer NOT NULL,\n\t`message_external_id` text NOT NULL,\n\t`identity_id` integer NOT NULL,\n\t`own` integer NOT NULL,\n\t`reaction` text,\n\t`reacted_at` integer NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\tCONSTRAINT `fk_message_reactions_chat_id_chats_id_fk` FOREIGN KEY (`chat_id`) REFERENCES `chats`(`id`),\n\tCONSTRAINT `fk_message_reactions_identity_id_identities_id_fk` FOREIGN KEY (`identity_id`) REFERENCES `identities`(`id`),\n\tCONSTRAINT `message_reactions_chat_id_message_external_id_identity_id_unique` UNIQUE(`chat_id`,`message_external_id`,`identity_id`)\n);",
+            "CREATE INDEX `message_reactions_by_identity_id` ON `message_reactions` (`identity_id`);"
+        ]
     }
 ];

package/dist/store/sqlite/open-store.js

@@ -13,6 +13,20 @@ import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
 import { fillStems, followDefaultStemmers } from "./stems-fill.js";
 export const BACKFILL_ON_OPEN = 5_000;
+const NOT_WRITABLE = new Set(["EACCES", "EPERM", "EROFS"]);
+const createWritable = (file) => {
+    try {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        // SQLite gives its sidecar files the database's permissions.
+        writeFileSync(file, "", { flag: "a", mode: 0o600 });
+    }
+    catch (error) {
+        if (!NOT_WRITABLE.has(error.code ?? ""))
+            throw error;
+        // The errno's own sentence names the path, which holds the owner's home folder.
+        throw new CliError("permission_error", "the message store cannot be written from here; run where it is writable, or set MESSAGING_STORE", { reason: "store.not-writable" });
+    }
+};
 export const openStoreContext = async ({ path, env, now = Date.now, command, readOnly = false, } = {}) => {
     if (typeof readOnly !== "boolean")
         throw new CliError("validation_error", "readOnly must be a boolean");
@@ -22,11 +36,8 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, rea
         if (!statSync(file, { throwIfNoEntry: false })?.isFile())
             throw new CliError("not_found", "The store does not exist as a file; read-only opening does not create it");
     }
-    else {
-        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
-        // SQLite gives its sidecar files the database's permissions.
-        writeFileSync(file, "", { flag: "a", mode: 0o600 });
-    }
+    else
+        createWritable(file);
     const opened = await openSqlite(file, { readOnly });
     const database = opened.database;
     try {

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

@@ -4478,6 +4478,161 @@ export declare const chatEventPeople: import("drizzle-orm/sqlite-core").SQLiteTa
     };
     dialect: 'sqlite';
 }>;
+/**
+ * Each person's newest reaction to a message, for a messenger that sends one person's change at a time; the store
+ * derives `messages.reactions` from them. Keyed by chat and external id: a reaction can arrive before its message.
+ */
+export declare const messageReactions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "message_reactions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        chatId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        messageExternalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        identityId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        own: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        reaction: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        reactedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+}>;
 /** One read of a chat's member list. Retention reads presence at a checkpoint from these, not from stays. */
 export declare const memberObservations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "member_observations";

package/dist/store/sqlite/schema.js

@@ -511,6 +511,28 @@ export const chatEventPeople = sqliteTable("chat_event_people", {
     primaryKey({ columns: [table.chatEventId, table.identityId] }),
     index("chat_event_people_by_identity_id").on(table.identityId),
 ]);
+/**
+ * Each person's newest reaction to a message, for a messenger that sends one person's change at a time; the store
+ * derives `messages.reactions` from them. Keyed by chat and external id: a reaction can arrive before its message.
+ */
+export const messageReactions = sqliteTable("message_reactions", {
+    id: integer("id").primaryKey(),
+    chatId: integer("chat_id")
+        .notNull()
+        .references(() => chats.id),
+    messageExternalId: text("message_external_id").notNull(),
+    identityId: integer("identity_id")
+        .notNull()
+        .references(() => identities.id),
+    own: integer("own").notNull(),
+    reaction: text("reaction"),
+    reactedAt: integer("reacted_at").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    unique().on(table.chatId, table.messageExternalId, table.identityId),
+    index("message_reactions_by_identity_id").on(table.identityId),
+]);
 /** One read of a chat's member list. Retention reads presence at a checkpoint from these, not from stays. */
 export const memberObservations = sqliteTable("member_observations", {
     id: integer("id").primaryKey(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.379.0",
+  "version": "0.381.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",
@@ -173,6 +173,7 @@
     "@xmldom/xmldom": "0.9.12",
     "chardet": "2.2.0",
     "defuddle": "0.19.5",
+    "dictionary-ru": "3.0.0",
     "echarts": "6.1.0",
     "fflate": "0.8.3",
     "iconv-lite": "0.7.3",
@@ -202,7 +203,7 @@
     "@types/node": "^22.20.4",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.2",
-    "@wirecat/cli-base": "0.48.0",
+    "@wirecat/cli-base": "0.49.0",
     "commander": "15.0.0",
     "cspell": "10.3.6",
     "drizzle-kit": "1.0.0-rc.4",
@@ -222,7 +223,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.48.0 <0.49.0",
+    "@wirecat/cli-base": ">=0.49.0 <0.50.0",
     "commander": ">=15"
   },
   "bin": {