@wirecat/cli-core 0.478.0 → 0.480.0

package/CHANGELOG.md

@@ -5,7 +5,32 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 0.480.0 — 29.10.2026
+
+### Changed — may break callers
+
+- **`StoredMessages.reactors` is required again.** 0.479.0 made it optional so a messenger that builds its own
+  `StoredMessages` kept compiling; whatsapp-cli now implements it, so every messenger must give it (`async () => []` for
+  one that stores no reactions). tg-cli and max-cli do not build a `StoredMessages` and are not affected.
+
+### Added
+
+- **`reactions list` is in whatsapp-cli too** (`parity.json`: `tg` and `wa`; max-cli does not list who reacted).
+
+## 0.479.0 — 29.10.2026
+
+### Added
+
+- **`StoredMessages.reactors(chatId, messageId)`** gives an adapter the reactions the store holds for a message, so a
+  messenger that sends reactions one person at a time (WhatsApp) can implement `MessageReactions.reactors` from the
+  store. One `Reactor` per person (`person`, `reaction`, `reactedAt`), newest first; a person's newest reaction wins
+  and one they took back is not listed. It is optional on the type, so an adapter that builds its own `StoredMessages` still compiles. It covers only what the store received. No schema change, store version stays 37.
+- **A person's phone is saved in the store** (store version 37, additive, minCompatible stays 34). `contacts sync`
+  saves the phone an address book entry carries (`AddressBookEntry`, a `Member` with an optional `phone`), and an
+  online `contacts show` saves the phone the profile shows, so `contacts show --offline` answers it. A read that
+  shows no phone never erases a saved one.
+- **A shared contact card's phone is a mention** of field `contact`, beside `file_text` and `transcript`:
+  `mentions list kind:phone` and `phone:` search find it, and `mentions rebuild` reads cards stored before.
 
 ## 0.478.0 — 29.10.2026
 

package/dist/cli/messenger/context.d.ts

@@ -1,5 +1,5 @@
 import type { Command } from "commander";
-import type { AdminRight, GroupSettingKey, Id, Message, Page, PollVote, PrivacyKey, Provider } from "../../domain/models.js";
+import type { AdminRight, GroupSettingKey, Id, Message, Page, PollVote, PrivacyKey, Provider, Reactor } from "../../domain/models.js";
 import type { MessengerAdapter } from "../../ports/messenger.js";
 import type { EventSink, Warn } from "../../runs/events.js";
 import { type Asker, type SendGuard } from "../../sends/guard.js";
@@ -31,6 +31,8 @@ export interface StoredMessages {
     wroteTo(personId: Id): Promise<boolean>;
     /** Each voter's newest vote in the poll the message carries, newest first; a retracted vote has no answers. */
     pollVotes(chatId: Id, messageId: Id): Promise<PollVote[]>;
+    /** Each person's newest reaction the store received for the message, newest first; a taken-back one is not listed. */
+    reactors(chatId: Id, messageId: Id): Promise<Reactor[]>;
 }
 /** `listen` opens a connection that receives updates — only `watch` asks; the rest stay quiet. */
 export interface ConnectOptions {

package/dist/cli/messenger/context.js

@@ -85,6 +85,10 @@ export const storedMessages = (provider, store, account) => {
             const owner = key();
             return owner ? (await store()).messages.pollVotes(owner, chatId, messageId) : [];
         },
+        reactors: async (chatId, messageId) => {
+            const owner = key();
+            return owner ? (await store()).messages.reactors(owner, chatId, messageId) : [];
+        },
     };
 };
 /**

package/dist/domain/models.d.ts

@@ -574,6 +574,10 @@ export interface Contact {
 }
 /** Somebody in a chat, as much of them as a chat card shows. */
 export type Member = Pick<Contact, "id" | "name" | "username">;
+/** A contact of the messenger's address book: the phone is there when the messenger shows it to the owner. */
+export type AddressBookEntry = Member & {
+    phone?: string | null;
+};
 /** A topic of a forum group; its messages carry this id as `threadId`. */
 export interface Topic {
     id: Id;

package/dist/ports/messenger.d.ts

@@ -3,7 +3,7 @@ import type { CounterField, CounterObservations } from "../domain/counters.js";
 import type { HtmlFormatting, MarkdownFormatting, TextSpan } from "../domain/formatting.js";
 import type { Markup } from "../domain/markdown.js";
 import type { MessagePermalink } from "../domain/message-link.js";
-import type { Account, AccountSession, AdminRight, Button, CallRecord, Chat, ChatCard, ChatEvent, ChatEvents, ChatUpdate, Discussion, Folder, FolderChange, FolderRules, GroupCard, GroupChange, GroupMember, Id, InviteLink, InviteLinkChange, JoinRequest, LinkTarget, MediaKind, Member, Message, MessageEvent, MessageHit, OfficialChatStats, Page, PersonCard, PersonReaction, PhoneBookEntry, Poll, PollVote, PrivacySettings, ProfileFacts, ProviderMetadata, Reactor, SenderIdentity, Sticker, StickerSet, Topic, TopicChange, WindowedMessage } from "../domain/models.js";
+import type { Account, AccountSession, AddressBookEntry, AdminRight, Button, CallRecord, Chat, ChatCard, ChatEvent, ChatEvents, ChatUpdate, Discussion, Folder, FolderChange, FolderRules, GroupCard, GroupChange, GroupMember, Id, InviteLink, InviteLinkChange, JoinRequest, LinkTarget, MediaKind, Member, Message, MessageEvent, MessageHit, OfficialChatStats, Page, PersonCard, PersonReaction, PhoneBookEntry, Poll, PollVote, PrivacySettings, ProfileFacts, ProviderMetadata, Reactor, SenderIdentity, Sticker, StickerSet, Topic, TopicChange, WindowedMessage } from "../domain/models.js";
 /** One attachment's bytes, fetched over the adapter's connection when `bytes` is read — so read it before the command closes. */
 export interface RemoteFile {
     kind: string;
@@ -502,7 +502,7 @@ export interface AccountTools {
     /** The person with this phone number, where their privacy lets the owner find them; `not_found` otherwise. */
     lookup(phone: string): Promise<Member>;
     /** The owner's contact list as the messenger keeps it — the address book, not the chats. */
-    addressBook(): Promise<Member[]>;
+    addressBook(): Promise<AddressBookEntry[]>;
 }
 /** Everything the messenger says about one person — what `contacts show` shows. */
 export interface PersonProfiles {

package/dist/services/person-profile.js

@@ -1,5 +1,5 @@
 import { pickPerson } from "../resolve.js";
-import { storeIfOpen } from "./deps.js";
+import { storeIfOpen, unlessBusy } from "./deps.js";
 /**
  * The person as the messenger describes them, and their stored activity in every chat shared with
  * them. Online, one profile read; `--offline`, or a messenger that cannot describe a person, what
@@ -10,13 +10,18 @@ import { storeIfOpen } from "./deps.js";
 export const personProfile = async (deps, person, known) => {
     const online = deps.offline ? undefined : await deps.connection();
     const held = await storeIfOpen(deps);
-    const facts = online?.profile
+    const read = online?.profile
         ? await online.profile(person)
         : known
             ? factsOfCard(known)
             : await storedFacts(held ?? { store: await deps.store(), account: await deps.account() }, person);
     if (!held)
-        return { ...facts, chats: quiet(facts), aliases: [] };
+        return { ...read, chats: quiet(read), aliases: [] };
+    if (online?.profile && read.phone) {
+        await unlessBusy(() => held.store.people.savePeople(held.account, [{ id: read.id, name: read.name, phone: read.phone }]));
+    }
+    const phone = read.phone ?? (await held.store.people.phoneOf(held.account, read.id));
+    const facts = phone ? { ...read, phone } : read;
     return {
         ...facts,
         chats: await activityIn(held.store, held.account, facts),

package/dist/store/messages.d.ts

@@ -1,5 +1,5 @@
 import type { CounterObservations } from "../domain/counters.js";
-import type { Delivery, Id, Message, Page, PersonReaction, PollVote, Reactions, WindowedMessage } from "../domain/models.js";
+import type { Delivery, Id, Message, Page, PersonReaction, PollVote, Reactions, Reactor, WindowedMessage } from "../domain/models.js";
 import { type DocumentLinkMessage } from "./sqlite/document-links.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { AccountKey, DeletionScope, IngestedVia, MessageFilter, SenderChatStats, StoredHit } from "./types.js";
@@ -118,6 +118,8 @@ export interface AccountMessages {
     saveVote(key: AccountKey, chatId: Id, messageId: Id, vote: PollVote): Promise<void>;
     /** Each voter's newest vote in the poll a message carries, newest first. */
     pollVotes(key: AccountKey, chatId: Id, messageId: Id): Promise<PollVote[]>;
+    /** Each person's newest reaction to a message, newest first; a person who took theirs back is not listed. */
+    reactors(key: AccountKey, chatId: Id, messageId: Id): Promise<Reactor[]>;
     /** One person's stored messages per chat of this account, newest first. */
     senderStats(key: AccountKey, senderId: Id): Promise<SenderChatStats[]>;
     /** What a voice message said, when it was heard before, and by what. */

package/dist/store/messages.js

@@ -110,6 +110,10 @@ export const accountMessagesOver = (context) => {
             const chatKey = chatKeyOf(key, chatId);
             return chatKey === undefined ? [] : messageWrites.pollVotes(context, chatKey, messageId);
         },
+        reactors: async (key, chatId, messageId) => {
+            const chatKey = chatKeyOf(key, chatId);
+            return chatKey === undefined ? [] : messageWrites.reactors(context, chatKey, messageId);
+        },
         senderStats: async (key, senderId) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? [] : reads.senderStats(context, accountKey, key.provider, senderId);

package/dist/store/people.d.ts

@@ -21,6 +21,8 @@ export interface AccountPeople {
     refreshRecency(key: AccountKey): Promise<void>;
     /** Every name and username this account's store recorded for one person, the current ones included. */
     personNames(key: AccountKey, personId: Id): Promise<PersonAlias[]>;
+    /** The phone saved for them, `null` when none was ever shown to the owner. */
+    phoneOf(key: AccountKey, personId: Id): Promise<string | null>;
     privateContact(key: AccountKey, personId: Id): Promise<PrivateContact>;
     setContactAlias(key: AccountKey, personId: Id, alias: string | null): Promise<{
         personId: Id;

package/dist/store/people.js

@@ -39,6 +39,7 @@ export const accountPeopleOver = (context) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? [] : identities.namesOf(context, accountKey, key.provider, personId);
         },
+        phoneOf: async (key, personId) => identities.phoneOf(context, key.provider, personId),
         privateContact: async (key, person) => privatePeople.privateContact(context, key, person),
         setContactAlias: async (key, person, alias) => {
             return write(database, () => privatePeople.setAlias(context, key, person, alias));

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

@@ -45,4 +45,5 @@ export declare const refreshRecency: ({ orm }: StoreContext, accountKey: number)
 export declare const namesOf: ({ orm }: StoreContext, accountKey: number, provider: Provider, nativeId: Id) => PersonAlias[];
 /** Stable provider identity only; participant labels never resolve or merge other people. */
 export declare const meetingIdentityPk: (context: StoreContext, accountId: number, identity: IdentityInput) => number;
+export declare const phoneOf: ({ orm }: StoreContext, provider: Provider, nativeId: Id) => string | null;
 export {};

package/dist/store/sqlite/identities.js

@@ -13,6 +13,7 @@ const prepare = (orm) => ({
         username: identities.username,
         isBot: identities.bot,
         description: identities.description,
+        phone: identities.phone,
         updatedAt: identities.updatedAt,
         personId: identityLinks.personId,
     })
@@ -118,12 +119,14 @@ const saveIdentity = ({ orm, now, database }, provider, nativeId, name, facts, r
             username: facts.username ?? found.username,
             bot: flag(facts.isBot) ?? found.isBot,
             description: facts.description ?? found.description,
+            phone: facts.phone ?? found.phone,
         };
         // Only on a real change: the search trigger rewrites the index row on every update of `name`.
         if (changed.name !== found.name ||
             changed.username !== found.username ||
             changed.bot !== found.isBot ||
-            changed.description !== found.description) {
+            changed.description !== found.description ||
+            changed.phone !== found.phone) {
             orm
                 .update(identities)
                 .set({ ...changed, updatedAt: now() })
@@ -150,6 +153,7 @@ const saveIdentity = ({ orm, now, database }, provider, nativeId, name, facts, r
         username: facts.username ?? null,
         bot: flag(facts.isBot),
         description: facts.description ?? null,
+        phone: facts.phone ?? null,
         createdAt: at,
         updatedAt: at,
     })
@@ -325,3 +329,8 @@ export const meetingIdentityPk = (context, accountId, identity) => {
         statementsOf(context.orm).seen.run({ accountId, identityId: saved.pk, createdAt: context.now() });
     return saved.pk;
 };
+export const phoneOf = ({ orm }, provider, nativeId) => orm
+    .select({ phone: identities.phone })
+    .from(identities)
+    .where(and(eq(identities.provider, provider), eq(identities.externalId, nativeId)))
+    .get()?.phone ?? null;

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

@@ -37,6 +37,13 @@ export interface Corpus {
  */
 export declare const speech: (alias: string) => string;
 export declare const SPEECH: string;
+/**
+ * What mentions are read from in an attachment: its text, or for a shared contact card its phone behind a phone
+ * word, which makes the number count as a phone whatever its country code. One expression for finding and reading
+ * back, so the offsets agree.
+ */
+export declare const mentionText: (alias: string) => string;
+export declare const mentionField: (alias: string) => string;
 export declare const quoted: (value: string) => string;
 /** A leaf's words as an FTS5 match: a phrase, or with `~N` its words at most N apart, in any order. */
 export declare const ftsMatch: (node: ResolvedPredicate) => string;

package/dist/store/sqlite/lucene-fields.js

@@ -20,6 +20,13 @@ import { canonicalTagNamed } from "./tags.js";
  */
 export const speech = (alias) => `(coalesce(${alias}.extractor,'') LIKE 'speech:%' OR ${alias}.kind IN ('voice','video_note') OR coalesce(${alias}.mime,'')='audio/ogg')`;
 export const SPEECH = speech("att");
+/**
+ * What mentions are read from in an attachment: its text, or for a shared contact card its phone behind a phone
+ * word, which makes the number count as a phone whatever its country code. One expression for finding and reading
+ * back, so the offsets agree.
+ */
+export const mentionText = (alias) => `CASE WHEN coalesce(json_extract(${alias}.contact, '$.phone'), '') <> '' THEN 'phone: ' || json_extract(${alias}.contact, '$.phone') ELSE ${alias}.text END`;
+export const mentionField = (alias) => `CASE WHEN coalesce(json_extract(${alias}.contact, '$.phone'), '') <> '' THEN 'contact' WHEN ${speech(alias)} THEN 'transcript' ELSE 'file_text' END`;
 export const quoted = (value) => `"${value.replaceAll('"', '""')}"`;
 /** A leaf's words as an FTS5 match: a phrase, or with `~N` its words at most N apart, in any order. */
 export const ftsMatch = (node) => {

package/dist/store/sqlite/manifest.js

@@ -48,6 +48,8 @@ export const MANIFEST = [
     { name: "20261027102259_version-35-calendar-neutral", version: 35, minCompatible: 34 },
     { name: "20261027102302_version-35-calendar-neutral-data", version: 35, minCompatible: 34 },
     { name: "20261029162435_version-36-attachment-contact", version: 36, minCompatible: 34 },
+    { name: "20261029180959_version-37-identity-phone", version: 37, minCompatible: 34 },
+    { name: "20261029181000_version-37-contact-mention-triggers", version: 37, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/mention-drain.js

@@ -1,7 +1,7 @@
 import { findMentions, MENTION_KINDS, MENTION_VERSIONS, oneTrackedLinkPerSite, telegramTarget, } from "../../domain/mentions.js";
 import { findNames, findUnknownNames, nameIndex } from "../../domain/person-names.js";
 import { createStemmer } from "../../search/stem.js";
-import { speech } from "./lucene-fields.js";
+import { mentionField, mentionText } from "./lucene-fields.js";
 import { storePhoneCountries } from "./phone-countries.js";
 import { placeOf } from "./place-key.js";
 /** Mentions a store write finds before it commits: an older binary may have queued thousands. */
@@ -98,13 +98,13 @@ export const SOURCES = {
     },
     attachment: {
         count: "SELECT count(*) AS n FROM attachments a JOIN messages m ON m.id = a.attachable_id " +
-            "WHERE a.attachable_type = 'message' AND a.text IS NOT NULL AND a.text <> '' AND m.deleted_at IS NULL",
-        page: `SELECT a.id, a.text, CASE WHEN ${speech("a")} THEN 'transcript' ELSE 'file_text' END AS field, ` +
+            `WHERE a.attachable_type = 'message' AND coalesce(${mentionText("a")}, '') <> '' AND m.deleted_at IS NULL`,
+        page: `SELECT a.id, ${mentionText("a")} AS text, ${mentionField("a")} AS field, ` +
             "m.chat_id FROM attachments a JOIN messages m ON m.id = a.attachable_id WHERE a.id > ? AND a.attachable_type = 'message' " +
-            "AND a.text IS NOT NULL AND a.text <> '' AND m.deleted_at IS NULL ORDER BY a.id LIMIT ?",
-        one: `SELECT a.text, CASE WHEN ${speech("a")} THEN 'transcript' ELSE 'file_text' END AS field, ` +
+            `AND coalesce(${mentionText("a")}, '') <> '' AND m.deleted_at IS NULL ORDER BY a.id LIMIT ?`,
+        one: `SELECT ${mentionText("a")} AS text, ${mentionField("a")} AS field, ` +
             "m.chat_id FROM attachments a JOIN messages m ON m.id = a.attachable_id WHERE a.id = ? AND a.attachable_type = 'message' " +
-            "AND a.text IS NOT NULL AND m.deleted_at IS NULL",
+            `AND ${mentionText("a")} IS NOT NULL AND m.deleted_at IS NULL`,
     },
     // Texts outside a chat: no one wrote them in a chat, so a name in them is never linked by rule.
     document: {

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

@@ -11,7 +11,7 @@ export interface StoredMention {
     domain: string | null;
     confidence: number;
     status: MentionStatus;
-    /** Which text of the message: `text`, a file's `file_text`, or a voice note's `transcript`. */
+    /** Which text of the message: `text`, a file's `file_text`, a voice note's `transcript`, or a shared card's `contact`. */
     field: string;
     /** Who linked or dismissed it: `owner`, an agent by name, `rules` for a value that already had an owner. */
     author: string | null;

package/dist/store/sqlite/mentions.js

@@ -3,6 +3,7 @@ import { defineQuery } from "@wirecat/cli-base/query";
 import { MENTION_KINDS, siteOf } from "../../domain/mentions.js";
 import { findNames, nameIndex } from "../../domain/person-names.js";
 import { createStemmer } from "../../search/stem.js";
+import { mentionText } from "./lucene-fields.js";
 import { knownPeople, participants, SOURCE_TYPES, SOURCES, sourceOf, telegramLink, writer, } from "./mention-drain.js";
 import { linkIdentityToPerson, personByUid } from "./person-links.js";
 import { valueMatch } from "./phone-countries.js";
@@ -94,7 +95,9 @@ export const mentionsState = (database) => {
 // A mention in a file or a voice note belongs to that attachment's message, and is listed with it.
 const SELECT = "SELECT mn.id, mn.kind, mn.value, mn.domain, mn.confidence, mn.status, mn.author, mn.source_field, " +
     "mn.target_type, mn.target_id, mn.created_at, " +
-    "mn.start_offset, mn.end_offset, CASE WHEN mn.source_type = 'attachment' THEN att.text ELSE m.text END AS text, " +
+    "mn.start_offset, mn.end_offset, CASE WHEN mn.source_type = 'attachment' THEN " +
+    mentionText("att") +
+    " ELSE m.text END AS text, " +
     "m.external_id AS message_id, m.sent_at, m.chat_id AS chat_pk, c.external_id AS chat_id FROM mentions mn " +
     "LEFT JOIN attachments att ON mn.source_type = 'attachment' AND att.id = mn.source_id AND att.attachable_type = 'message' " +
     "JOIN messages m ON mn.source_type IN ('message', 'attachment') " +

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

@@ -1,4 +1,4 @@
-import type { Delivery, Id, Message, PersonReaction, PollVote, Provider, Reactions } from "../../domain/models.js";
+import type { Delivery, Id, Message, PersonReaction, PollVote, Provider, Reactions, Reactor } 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) => boolean;
@@ -27,6 +27,7 @@ export declare const pollVotes: ({ database }: StoreContext, chatKey: number, me
  * 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;
+export declare const reactors: ({ database }: StoreContext, chatKey: number, messageId: Id) => Reactor[];
 /** 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

@@ -412,6 +412,16 @@ export const derivedReactions = ({ database }, chatKey, messageId) => {
         total: sorted.reduce((sum, [, { count }]) => sum + count, 0),
     };
 };
+export const reactors = ({ database }, chatKey, messageId) => database
+    .prepare(`SELECT i.external_id AS id, i.name, i.username, r.reaction, r.reacted_at AS reactedAt
+         FROM message_reactions r JOIN identities i ON i.id = r.identity_id
+         WHERE r.chat_id = ? AND r.message_external_id = ? AND r.reaction IS NOT NULL
+         ORDER BY r.reacted_at DESC, r.id DESC`)
+    .all(chatKey, messageId).map(({ id, name, username, reaction, reactedAt }) => ({
+    person: { id, name, username },
+    reaction,
+    reactedAt: new Date(reactedAt).toISOString(),
+}));
 /** 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;

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

@@ -784,5 +784,18 @@ export const GENERATED = [
         "statements": [
             "ALTER TABLE `attachments` ADD `contact` text;"
         ]
+    },
+    {
+        "name": "20261029180959_version-37-identity-phone",
+        "statements": [
+            "ALTER TABLE `identities` ADD `phone` text;"
+        ]
+    },
+    {
+        "name": "20261029181000_version-37-contact-mention-triggers",
+        "statements": [
+            "-- A shared contact card has no text, only a phone: queue it for mentions like an attachment's text.\n-- Cards stored before version 37 wait for `mentions rebuild`.\nCREATE TRIGGER mention_pending_attachment_contact_ai AFTER INSERT ON attachments\n  WHEN new.attachable_type = 'message' AND new.contact IS NOT NULL BEGIN\n  INSERT OR IGNORE INTO mention_pending (source_type, source_id) VALUES ('attachment', new.id);\nEND;",
+            "CREATE TRIGGER mention_pending_attachment_contact_au AFTER UPDATE OF contact ON attachments\n  WHEN new.attachable_type = 'message' AND old.contact IS NOT new.contact BEGIN\n  INSERT OR IGNORE INTO mention_pending (source_type, source_id) VALUES ('attachment', new.id);\nEND;"
+        ]
     }
 ];

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

@@ -1042,6 +1042,22 @@ export declare const identities: import("drizzle-orm/sqlite-core").SQLiteTableWi
             identity: undefined;
             generated: undefined;
         }, {}>;
+        phone: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "identities";
+            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;
+        }, {}>;
     };
     dialect: 'sqlite';
     isAlias: false;

package/dist/store/sqlite/schema.js

@@ -100,6 +100,7 @@ export const identities = sqliteTable("identities", {
     updatedAt: integer("updated_at").notNull(),
     description: text("description"),
     email: text("email"),
+    phone: text("phone"),
 }, (table) => [
     unique().on(table.provider, table.externalId),
     index("identities_by_email").on(table.email).where(sql `email IS NOT NULL`),

package/dist/store/types.d.ts

@@ -34,6 +34,8 @@ export interface PersonFacts {
     description?: string | null;
     /** An address the provider shows for them: they become one person with the mail contact of that exact address. */
     email?: string | null;
+    /** As the provider showed it, whole; only where it shows it to the owner. */
+    phone?: string | null;
 }
 /** One identity in one messenger, by the messenger's own id. `provider` is any string: `email` is one. */
 export interface IdentityRef {

package/package.json

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

package/parity.json

@@ -3671,16 +3671,16 @@
       "in": "all"
     },
     "reactions list": {
-      "in": ["tg"],
-      "reason": "max-cli and whatsapp-cli do not list who reacted to a message",
+      "in": ["tg", "wa"],
+      "reason": "max-cli does not list who reacted to a message",
       "options": {
         "--cursor": {
-          "in": ["tg"],
-          "reason": "max-cli and whatsapp-cli do not list who reacted to a message"
+          "in": ["tg", "wa"],
+          "reason": "max-cli does not list who reacted to a message"
         },
         "--limit": {
-          "in": ["tg"],
-          "reason": "max-cli and whatsapp-cli do not list who reacted to a message"
+          "in": ["tg", "wa"],
+          "reason": "max-cli does not list who reacted to a message"
         }
       }
     },