@wirecat/cli-core 0.363.0 → 0.364.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@ shape of this file.
 
 ## Unreleased
 
+## 0.364.0 — 19.10.2026
+
+### Fixed
+
+- **More warnings in `serve`'s log now carry a code.** A flood wait (`flood_wait`, with `counts.seconds`),
+  a long wait for the profile's pace (`pace_wait`, with `counts.seconds`), a held account (`account_frozen`,
+  `account_limited`, `account_banned`), a wait that could not be remembered (`wait_not_remembered`), a send missing
+  from the send journal (`send_not_journaled`), a recipient list that could not be re-keyed or read
+  (`recipients_not_rekeyed`, `recipients_not_read`), the reply audience warnings (`audience_person_on_both_lists`,
+  `audience_chat_on_both_lists`, `audience_allow_unused`, `audience_allow_empty`) and the reply template warnings
+  (`reply_legacy_placeholders`, `reply_legacy_may_reword`, `reply_template_warning`) each log their code and
+  operation instead of a bare `serve.warning`. The record never holds the sentence, a chat id, a name or an error
+  message; the sentence at a terminal is unchanged.
+
 ## 0.363.0 — 19.10.2026
 
 ### Added

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

@@ -1,7 +1,7 @@
 import type { Command } from "commander";
 import type { AdminRight, GroupSettingKey, Id, Message, PollVote, PrivacyKey, Provider } from "../../domain/models.js";
 import type { MessengerAdapter } from "../../ports/messenger.js";
-import type { EventSink } from "../../runs/events.js";
+import type { EventSink, Warn } from "../../runs/events.js";
 import { type Asker, type SendGuard } from "../../sends/guard.js";
 import { type PaceRate } from "../../sends/pace.js";
 import { type PermissionKey } from "../../sends/permissions.js";
@@ -186,7 +186,7 @@ export interface Messenger extends ServiceMessenger {
      * `ask`, when given, answers a write at level `ask` instead of the messenger's own prompt: the MCP
      * server has no terminal to ask at.
      */
-    guard?: (command: Command, settings: Settings, warn: (message: string) => void, ask?: Asker) => SendGuard;
+    guard?: (command: Command, settings: Settings, warn: Warn, ask?: Asker) => SendGuard;
     /** The permission key of one of this CLI's own commands, when `keyForCommand` does not know it. */
     permissionKey?: PermissionKeyOf;
     /** The CLI's SKILL.md, which the MCP server also serves as `<command>://skill`. */

package/dist/cli/messenger/context.js

@@ -169,7 +169,11 @@ const rekeyRecipients = async (app, profile, env, warn, from, to) => {
         await new RecipientList(recipientsPathFor(app, profile, env), app.command, REKEY_LOCK_WAIT_MS).rekey(from, to);
     }
     catch (error) {
-        warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`);
+        warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`, {
+            event: "warning",
+            code: "recipients_not_rekeyed",
+            operation: "recipients.rekey",
+        });
     }
 };
 const waitsOf = (command) => {
@@ -344,7 +348,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
         base.renderer.warn(`permissions.${key} names no command and does nothing — \`config unset permissions.${key}\``);
     }
     // Read when warning, not now: serve swaps the renderer's methods for log records after this.
-    const warn = (text) => base.renderer.warn(text);
+    const warn = (text, warning) => base.renderer.warn(text, warning);
     const accountFor = () => {
         const account = messenger.accountOf?.(command) ?? recalledAccount(app, provider, profile, base.env);
         if (!account)

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

@@ -1,4 +1,5 @@
 import { type MessengerAdapter } from "../../ports/messenger.js";
+import { type Warn } from "../../runs/events.js";
 import { type FloodMemory } from "../../sends/flood.js";
 import type { Pacer } from "../../sends/pace.js";
 /**
@@ -9,6 +10,6 @@ import type { Pacer } from "../../sends/pace.js";
  */
 export declare const flooded: (messenger: MessengerAdapter, memory: FloodMemory, { name, warn, pacer }: {
     name: string;
-    warn: (message: string) => void;
+    warn: Warn;
     pacer?: Pacer;
 }) => MessengerAdapter;

package/dist/cli/messenger/flooded.js

@@ -19,12 +19,16 @@ const chatOf = (args) => typeof args[0] === "string" && /^-?\d+$/.test(args[0])
  * waits for its turn in the profile's pace, and a wait the messenger asks for holds the whole profile.
  */
 export const flooded = (messenger, memory, { name, warn, pacer }) => {
-    const kept = async (what) => {
+    const kept = async (operation, what) => {
         try {
             await what();
         }
         catch (error) {
-            warn(`could not remember ${name}'s wait (${error instanceof Error ? error.message : String(error)})`);
+            warn(`could not remember ${name}'s wait (${error instanceof Error ? error.message : String(error)})`, {
+                event: "warning",
+                code: "wait_not_remembered",
+                operation,
+            });
         }
     };
     const noted = async (operation, chatId, error) => {
@@ -33,13 +37,17 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
         const details = error.details ?? {};
         const standing = details.standing;
         if (standing && BLOCKING.has(standing.state)) {
-            await kept(() => {
+            await kept(operation, () => {
                 const block = memory.block({
                     state: standing.state,
                     hint: standing.hint ?? error.message,
                     ...(standing.until ? { until: standing.until } : {}),
                 });
-                warn(`writes from this profile are held ${holdEnd(block)}: ${block.hint}`);
+                warn(`writes from this profile are held ${holdEnd(block)}: ${block.hint}`, {
+                    event: "warning",
+                    code: `account_${block.state}`,
+                    operation,
+                });
             });
             return;
         }
@@ -47,23 +55,28 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
         if (error.code !== "rate_limited" || details.remembered === true || !Number.isFinite(waitMs) || waitMs <= 0)
             return;
         const providerError = providerErrorKey(details.provider_error);
-        await kept(() => {
+        await kept(operation, () => {
             const deadline = memory.remember({
                 operation,
                 ...(chatId ? { chatId } : {}),
                 ...(providerError ? { providerError } : {}),
                 waitMs,
             });
-            warn(`${name} asked to wait before ${operation} again — until ${deadline.until}`);
+            warn(`${name} asked to wait before ${operation} again — until ${deadline.until}`, {
+                event: "warning",
+                code: "flood_wait",
+                operation,
+                counts: { seconds: Math.ceil(waitMs / 1000) },
+            });
         });
         if (pacer)
-            await kept(() => pacer.holdFor(waitMs));
+            await kept(operation, () => pacer.holdFor(waitMs));
     };
-    const turn = async () => {
+    const turn = async (operation) => {
         if (!pacer)
             return;
         let at = Date.now();
-        await kept(async () => {
+        await kept(operation, async () => {
             at = await pacer.reserve();
         });
         const waitMs = at - Date.now();
@@ -72,8 +85,15 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
         if (waitMs > LONGEST_PACE_WAIT_MS) {
             throw new CliError("rate_limited", `${name} asked this profile to wait, ${Math.ceil(waitMs / 1000)} s are left — nothing was sent to ${name}`, { retry_after_ms: waitMs, retry_at: new Date(at).toISOString(), remembered: true });
         }
-        if (waitMs >= ANNOUNCE_WAIT_MS)
-            warn(`waiting ${Math.ceil(waitMs / 1000)} s to keep this profile's pace with ${name}`);
+        if (waitMs >= ANNOUNCE_WAIT_MS) {
+            const seconds = Math.ceil(waitMs / 1000);
+            warn(`waiting ${seconds} s to keep this profile's pace with ${name}`, {
+                event: "warning",
+                code: "pace_wait",
+                operation,
+                counts: { seconds },
+            });
+        }
         await new Promise((resolve) => setTimeout(resolve, waitMs));
     };
     return throughWrapper(messenger, {}, (operation, call) => {
@@ -101,7 +121,7 @@ export const flooded = (messenger, memory, { name, warn, pacer }) => {
                     ...(owed.providerError ? { provider_error: owed.providerError } : {}),
                 });
             }
-            await turn();
+            await turn(operation);
             try {
                 return await call(...args);
             }

package/dist/cli/messenger/replies-command.js

@@ -43,8 +43,9 @@ export const repliesCommand = (messenger) => {
         if (rules.length === 0) {
             renderer.note(`no reply rules yet — they live in ${path}`);
         }
-        for (const warning of audienceWarnings(audience))
-            renderer.warn(warning);
+        const warn = renderer.warn;
+        for (const { text, warning } of audienceWarnings(audience))
+            warn(text, warning);
         const found = await context.withStore((store, account) => dryRun(store, account, rules, {
             since,
             audience,
@@ -103,8 +104,9 @@ export const repliesCommand = (messenger) => {
         const { settings, renderer, env } = context;
         const { rules, audience } = readReplies(repliesPathFor(messenger.app, settings.profile, env), messenger.provider);
         const warnings = audienceWarnings(audience);
-        for (const warning of warnings)
-            renderer.warn(warning);
+        const warn = renderer.warn;
+        for (const { text, warning } of warnings)
+            warn(text, warning);
         const state = readRepliesState(repliesStatePathFor(messenger.app, settings.profile, env));
         const level = levelFor(settings.permissions ?? {}, "replies.send").level;
         if (level !== "allow")
@@ -117,7 +119,7 @@ export const repliesCommand = (messenger) => {
                 allow: audience.allow.people.length + audience.allow.chats.length,
                 deny: audience.deny.people.length + audience.deny.chats.length,
             },
-            warnings,
+            warnings: warnings.map(({ text }) => text),
             rules: rules.map(({ id, on }) => ({ id, on })),
         }));
     });

package/dist/cli/messenger/replies-edit-command.js

@@ -78,8 +78,9 @@ export const addReplyEditors = (replies, messenger) => {
         const context = messengerContext(this, messenger);
         const { settings, renderer, env } = context;
         const answer = editAudience(repliesPathFor(messenger.app, settings.profile, env), messenger.provider, this.opts());
-        for (const warning of audienceWarnings(answer))
-            renderer.warn(warning);
+        const warn = renderer.warn;
+        for (const { text, warning } of audienceWarnings(answer))
+            warn(text, warning);
         renderItem(this, context, answer);
     });
     replies.addCommand(audience);

package/dist/cli/messenger/serve-command.js

@@ -162,9 +162,10 @@ const replying = (context, messenger, since) => {
     // A file that does not read is said on each message instead; it must not stop serve.
     try {
         const { rules, audience } = readReplies(repliesPathFor(app, profile, env), provider);
+        const warn = renderer.warn;
         if (rules.length > 0)
-            for (const warning of audienceWarnings(audience))
-                renderer.warn(warning);
+            for (const { text, warning } of audienceWarnings(audience))
+                warn(text, warning);
     }
     catch { }
     const handle = async (message) => {

package/dist/cli/messenger/serve-relay.d.ts

@@ -85,7 +85,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         officialStats?: boolean;
         tracksMembers?: boolean;
         speechModels?: readonly string[];
-        guard?: (command: Command, settings: import("../settings.js").Settings, warn: (message: string) => void, ask?: import("../../sends/guard.js").Asker) => import("../../sends/guard.js").SendGuard;
+        guard?: (command: Command, settings: import("../settings.js").Settings, warn: import("../../runs/events.js").Warn, ask?: import("../../sends/guard.js").Asker) => import("../../sends/guard.js").SendGuard;
         permissionKey?: import("../permission-keys.js").PermissionKeyOf;
         skill?: URL;
         diagnose?: (command: Command, context: import("../context.js").BaseContext) => Promise<Record<string, unknown>>;

package/dist/cli/messenger/stored.js

@@ -461,7 +461,11 @@ const announceStoredChats = async (messenger, store, account, events, warn, reci
         listed = recipientIds?.() ?? [];
     }
     catch (error) {
-        warn(`the messenger was not told the recipient list: ${error instanceof Error ? error.message : String(error)}`);
+        warn(`the messenger was not told the recipient list: ${error instanceof Error ? error.message : String(error)}`, {
+            event: "warning",
+            code: "recipients_not_read",
+            operation: "history.stored_chats",
+        });
     }
     try {
         const opened = await store();

package/dist/replies/rendering.d.ts

@@ -2,6 +2,7 @@ import { type KeyringStore } from "@wirecat/cli-base";
 import type { Chat, Message } from "../domain/models.js";
 import { type ModelSettings } from "../models/index.js";
 import type { AppIdentity } from "../ports/app.js";
+import type { Warn } from "../runs/events.js";
 import type { ReplyRule } from "./rules.js";
 import { type TemplateResult } from "./template.js";
 export type ReplyChat = Pick<Chat, "id" | "kind"> & {
@@ -10,7 +11,7 @@ export type ReplyChat = Pick<Chat, "id" | "kind"> & {
 export type ReplyRender = (rule: ReplyRule, message: Message, chat: ReplyChat, now: number) => Promise<TemplateResult>;
 export declare const replyRenderer: (app: AppIdentity, profile: string, settings: () => {
     models?: ModelSettings;
-}, env: NodeJS.ProcessEnv, warn: (message: string) => void, options?: {
+}, env: NodeJS.ProcessEnv, warn: Warn, options?: {
     ai?: boolean;
     preview?: boolean;
     signal?: AbortSignal;

package/dist/replies/rendering.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { embeddingKeys, endpointKeyName } from "../embeddings/keys.js";
 import { modelGateway, modelTarget } from "../models/index.js";
 import { mayModelReply, replyConsentPathFor, replyModelIdentity } from "./consents.js";
-import { renderReplyTemplate } from "./template.js";
+import { renderReplyTemplate, templateWarning } from "./template.js";
 export const replyRenderer = (app, profile, settings, env, warn, options = {
     ai: true,
 }) => async (rule, message, chat, now) => {
@@ -48,6 +48,6 @@ export const replyRenderer = (app, profile, settings, env, warn, options = {
         },
     });
     for (const warning of result.warnings)
-        warn(warning);
+        warn(warning, templateWarning(warning));
     return result;
 };

package/dist/replies/rules.d.ts

@@ -1,5 +1,6 @@
 import * as v from "valibot";
 import type { AppIdentity } from "../ports/app.js";
+import type { WarningEvent } from "../runs/events.js";
 export declare const REPLY_ACTIONS: readonly ["reply", "task"];
 export declare const REPLY_MODELS: readonly ["fill-only", "may-reword"];
 export type ReplyAction = (typeof REPLY_ACTIONS)[number];
@@ -199,8 +200,12 @@ export interface Replies {
 export declare const EVERYONE: Audience;
 /** Why nobody may be answered here, or `null` when the audience lets the reply go. */
 export declare const outsideAudience: (audience: Audience, person: string | null, chat: string) => string | null;
+export interface AudienceWarning {
+    text: string;
+    warning: WarningEvent;
+}
 /** What in the audience does not do what it seems to say — said, never refused. */
-export declare const audienceWarnings: ({ reply, allow, deny }: Audience) => string[];
+export declare const audienceWarnings: ({ reply, allow, deny }: Audience) => AudienceWarning[];
 /** The owner's rules, in file order. No file is no rules; a file that does not check out refuses, naming the field. */
 export declare const readReplyRules: (path: string) => ReplyRule[];
 /** `provider`: the messenger reading the file, which an older file's `testers` may have named. */

package/dist/replies/rules.js

@@ -112,19 +112,27 @@ export const outsideAudience = (audience, person, chat) => {
     const listed = (person !== null && audience.allow.people.includes(person)) || audience.allow.chats.includes(chat);
     return listed ? null : "not on the allow list";
 };
+const audienceWarning = (code, text) => ({
+    text,
+    warning: { event: "warning", code, operation: "replies.audience" },
+});
 /** What in the audience does not do what it seems to say — said, never refused. */
 export const audienceWarnings = ({ reply, allow, deny }) => [
     ...allow.people
         .filter((id) => deny.people.includes(id))
-        .map((id) => `person ${id} is on both lists: deny wins, nobody answers them`),
+        .map((id) => audienceWarning("audience_person_on_both_lists", `person ${id} is on both lists: deny wins, nobody answers them`)),
     ...allow.chats
         .filter((id) => deny.chats.includes(id))
-        .map((id) => `chat ${id} is on both lists: deny wins, nothing is answered there`),
+        .map((id) => audienceWarning("audience_chat_on_both_lists", `chat ${id} is on both lists: deny wins, nothing is answered there`)),
     ...(reply === "all" && allow.people.length + allow.chats.length > 0
-        ? ['the allow list does nothing while audience.reply is "all" — set it to "listed" to answer only those']
+        ? [
+            audienceWarning("audience_allow_unused", 'the allow list does nothing while audience.reply is "all" — set it to "listed" to answer only those'),
+        ]
         : []),
     ...(reply === "listed" && allow.people.length + allow.chats.length === 0
-        ? ['audience.reply is "listed" and the allow list is empty: nobody is answered']
+        ? [
+            audienceWarning("audience_allow_empty", 'audience.reply is "listed" and the allow list is empty: nobody is answered'),
+        ]
         : []),
 ];
 /** The owner's rules, in file order. No file is no rules; a file that does not check out refuses, naming the field. */

package/dist/replies/serve.d.ts

@@ -1,4 +1,5 @@
 import type { Id, Message } from "../domain/models.js";
+import type { Warn } from "../runs/events.js";
 import type { ReplyChat, ReplyRender } from "./rendering.js";
 export declare const NOT_ALLOWED = "replies.send is not allow";
 export declare const NO_RULES = "no rules";
@@ -27,7 +28,7 @@ export interface Replier {
     allowed: () => boolean;
     chatOf: (chat: Id) => Promise<ReplyChat>;
     render?: ReplyRender;
-    warn?: (message: string) => void;
+    warn?: Warn;
     senderOf: (person: Id) => Promise<{
         isBot: boolean;
         isContact: boolean;

package/dist/replies/serve.js

@@ -2,7 +2,7 @@ import { codeOf } from "../sends/guarded.js";
 import { decide } from "./decide.js";
 import { outsideAudience, readReplies } from "./rules.js";
 import { readRepliesState, recordReply, writeRepliesState } from "./state.js";
-import { renderReplyTemplate } from "./template.js";
+import { renderReplyTemplate, templateWarning } from "./template.js";
 export const NOT_ALLOWED = "replies.send is not allow";
 export const NO_RULES = "no rules";
 export const ONLY_TASK = "opened a task, sent nothing";
@@ -69,7 +69,7 @@ export const replyTo = async (deps, message) => {
                 data: message.text,
             });
         for (const warning of rendered.warnings)
-            deps.warn?.(warning);
+            deps.warn?.(warning, templateWarning(warning));
         if (rendered.text === null)
             return { skip: rendered.reason ?? "reply template produced no reply", ...opened };
         // Pause and consent can be revoked while an async model request is in flight.

package/dist/replies/template.d.ts

@@ -1,3 +1,4 @@
+import type { WarningEvent } from "../runs/events.js";
 import type { ReplyRule } from "./rules.js";
 export declare const TEMPLATE_LIMITS: {
     parse: number;
@@ -34,4 +35,6 @@ export interface TemplateInput {
     }>;
     limits?: Partial<typeof TEMPLATE_LIMITS>;
 }
+/** A rendering warning as a log keeps it: a renderer a CLI hands in may warn in words this module does not know. */
+export declare const templateWarning: (text: string) => WarningEvent;
 export declare const renderReplyTemplate: (reply: ReplyRule["reply"], input: TemplateInput) => Promise<TemplateResult>;

package/dist/replies/template.js

@@ -9,6 +9,18 @@ export const TEMPLATE_LIMITS = {
     aiOutput: 1_024,
     calls: 4,
 };
+const LEGACY_PLACEHOLDERS = "legacy reply placeholders: use {{ sender.firstName }} and {{ sender.name }}";
+const LEGACY_REWORD = "legacy may-reword: use an ai block with an explicit fallback";
+const WARNING_CODES = {
+    [LEGACY_PLACEHOLDERS]: "reply_legacy_placeholders",
+    [LEGACY_REWORD]: "reply_legacy_may_reword",
+};
+/** A rendering warning as a log keeps it: a renderer a CLI hands in may warn in words this module does not know. */
+export const templateWarning = (text) => ({
+    event: "warning",
+    code: WARNING_CODES[text] ?? "reply_template_warning",
+    operation: "replies.render",
+});
 export const renderReplyTemplate = async (reply, input) => {
     const limits = { ...TEMPLATE_LIMITS, ...input.limits };
     const blocks = [];
@@ -16,11 +28,11 @@ export const renderReplyTemplate = async (reply, input) => {
     let source = reply.template;
     const legacy = /(?<!\{)\{(firstName|name)\}(?!\})/g;
     if (legacy.test(source)) {
-        warnings.push("legacy reply placeholders: use {{ sender.firstName }} and {{ sender.name }}");
+        warnings.push(LEGACY_PLACEHOLDERS);
         source = source.replace(legacy, (_, name) => `{{ sender.${name} }}`);
     }
     if (reply.model === "may-reword") {
-        warnings.push("legacy may-reword: use an ai block with an explicit fallback");
+        warnings.push(LEGACY_REWORD);
         if (!/\{%[-]?\s*ai\b/.test(source))
             source = `{% ai %}${source}{% else %}${source}{% endai %}`;
     }

package/dist/sends/guard.d.ts

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import type { Id } from "../domain/models.js";
 import { type AppIdentity } from "../ports/app.js";
+import type { Warn } from "../runs/events.js";
 import { FloodMemory } from "./flood.js";
 import { type AccountAction, type ChatAction, type SendEntry, SendJournal, type SendKind } from "./journal.js";
 import { type Level, type PermissionKey } from "./permissions.js";
@@ -66,7 +67,7 @@ export interface SendGuardOptions {
     recipients: RecipientList;
     /** Where a messenger's "this account may not write" is remembered; without it nothing is held. */
     flood?: FloodMemory;
-    warn: (message: string) => void;
+    warn: Warn;
     now?: () => Date;
 }
 /** A write the profile's level refuses, worded alike by the guard and by the check before connecting. */
@@ -96,7 +97,7 @@ export interface GuardSettings {
  * The guard a profile's configuration asks for — the command's, and a background server's for every
  * write it forwards. Built per request there, so `config set permissions.messages readonly` needs no restart.
  */
-export declare const guardFor: (app: AppIdentity, settings: GuardSettings, warn: (message: string) => void, env?: NodeJS.ProcessEnv, ask?: Asker) => SendGuard;
+export declare const guardFor: (app: AppIdentity, settings: GuardSettings, warn: Warn, env?: NodeJS.ProcessEnv, ask?: Asker) => SendGuard;
 /**
  * Over a background server, the server journals what it forwards, with the outcome it saw; the command
  * writes only the refusals of its own check, which never reached the server.

package/dist/sends/guard.js

@@ -227,7 +227,11 @@ export const sendGuard = ({ profile, recipients, command = recipients.command, r
                 journal.append({ at: now().toISOString(), profile, ...kept, ...(settles ? { reservation: settles } : {}) });
             }
             catch (error) {
-                warn(`this send is not in the send journal: ${journalFailure(error)}`);
+                warn(`this send is not in the send journal: ${journalFailure(error)}`, {
+                    event: "warning",
+                    code: "send_not_journaled",
+                    operation: "sends.journal",
+                });
             }
         },
     };

package/package.json

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