@wirecat/cli-core 0.359.0 → 0.361.0

package/CHANGELOG.md

@@ -7,6 +7,32 @@ shape of this file.
 
 ## Unreleased
 
+## 0.361.0 — 19.10.2026
+
+### Fixed
+
+- **A warning in `serve`'s log now says which warning it was.** Off a terminal, a re-key given up at exit, a write
+  the store did not take, a passive listen that failed and a stored-chats call that failed each wrote a bare
+  `serve.warning` record, so the log could not tell them apart. The record now carries the warning's `code`,
+  `operation` and `counts` (`rekeys_not_applied` with `counts.rekeys`), never its sentence, which can quote an
+  error or a chat. Warnings that have no code yet still log a bare record.
+- **The adapter test example in [ADAPTERS.md](docs/dev/ADAPTERS.md#running-the-contract-cases) no longer gives up
+  re-keys.** It handed `run()` `rekeyPacing: { lockMs: 0 }`, one re-key per transaction, so a few hundred re-keys
+  outlasted `closeWaitMs: 10` and were given up. It now hands `{ lockMs: 1000, pauseMs: 0 }` and says what each
+  field does.
+
+## 0.360.0 — 19.10.2026
+
+### Added
+
+- **Adapter test authors can shorten a connection's close wait and re-key pauses.** The run environment takes
+  `closeWaitMs` (how long a connection's close waits on its saves and passive listens, 5 s by default) and
+  `rekeyPacing` (`{ lockMs, pauseMs }` for chat re-keys, 50 ms and 25 ms by default). Commands, the shared services and
+  the MCP server's tool calls pass them on; a command `serve` runs for a client through its relay keeps the
+  defaults. A test through `run()` no longer pays the real waits. Only code
+  that builds the environment can set them; no flag, variable or MCP call does
+  ([ADAPTERS.md](docs/dev/ADAPTERS.md#running-the-contract-cases)).
+
 ## 0.359.0 — 19.10.2026
 
 ### Fixed

package/dist/cli/context.d.ts

@@ -35,6 +35,13 @@ export interface BaseEnvironment {
     recognizer?: OpenRecognizer;
     /** How long `store restore` and `store reset` wait on another connection's write, 1 s unless a test hands one in. */
     storeLockWaitMs?: number;
+    /** How long a connection's close waits on its saves and passive listens, 5 s unless a test hands one in. */
+    closeWaitMs?: number;
+    /** How long one pass of chat re-keys holds the store's write lock and the pause after it; tests hand in no pause. */
+    rekeyPacing?: {
+        lockMs: number;
+        pauseMs: number;
+    };
     /** Where raw bytes go when stdout is not this process's own — an MCP session relayed by serve. */
     stdout?: NodeJS.WritableStream;
     /** Where a prompt and what is typed at it go, in place of the process's stderr; tests hand one in. */

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

@@ -8,7 +8,7 @@ import { type PermissionKey } from "../../sends/permissions.js";
 import { type ServiceMessenger, type Services } from "../../services/index.js";
 import type { OpenRecognizer } from "../../speech/transcribe.js";
 import { type AccountKey, type DeletionScope, type MessageStore } from "../../store/store.js";
-import { type BaseContext } from "../context.js";
+import { type BaseContext, type BaseEnvironment } from "../context.js";
 import { type PermissionKeyOf } from "../permission-keys.js";
 import type { GlobalFlags, ResolveOptions, Settings } from "../settings.js";
 /**
@@ -225,6 +225,8 @@ export interface MessengerContext extends BaseContext {
         name?: string;
     }) => Promise<T>;
 }
+/** The waits a test shortens through its environment; a run without them keeps the defaults. */
+type ConnectionWaits = Pick<BaseEnvironment, "closeWaitMs" | "rekeyPacing">;
 /**
  * A connection as every shared reader sees it: its account remembered, each call a run event, what
  * the reads answer saved to the store. `close` closes the connection and the store it opened. One
@@ -234,7 +236,7 @@ export interface MessengerContext extends BaseContext {
  * does not `watch` is open: what it queued while nothing was connected is delivered once and cannot be fetched again.
  * A connection opened with `listen: true` is left to its `watch` and `feed`, which save the same.
  */
-export declare const connected: (connection: MessengerAdapter, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }: Pick<Messenger, "app" | "provider" | "name" | "deletedWithoutChat" | "pace" | "history" | "savedChatId">, { settings, env, renderer }: Pick<BaseContext, "settings" | "env" | "renderer">, events: EventSink, store?: LazyStore, { listen: watching }?: Pick<ConnectOptions, "listen">) => {
+export declare const connected: (connection: MessengerAdapter, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }: Pick<Messenger, "app" | "provider" | "name" | "deletedWithoutChat" | "pace" | "history" | "savedChatId">, { settings, env, renderer }: Pick<BaseContext, "settings" | "env" | "renderer">, events: EventSink, store?: LazyStore, { listen: watching, closeWaitMs, rekeyPacing, }?: Pick<ConnectOptions, "listen"> & ConnectionWaits) => {
     adapter: MessengerAdapter;
     close: () => Promise<void>;
 };
@@ -253,3 +255,4 @@ export declare const connectedFor: (command: Command, messenger: Pick<Messenger,
  */
 export declare const refuseLocalWrite: (context: MessengerContext, command: string, permission: PermissionKey) => void;
 export declare const messengerContext: (command: Command, messenger: Messenger, resolving?: Pick<ResolveOptions, "needsProfile">) => MessengerContext;
+export {};

package/dist/cli/messenger/context.js

@@ -118,7 +118,7 @@ const settled = async (pending, ms) => {
  * never fails the command; one that fails once the connection is `closing` is the close, not news. It still listens
  * while the connection closes, so what arrives then is saved too.
  */
-const listened = ({ run, operation, what }, events, warn) => {
+const listened = ({ run, operation, what }, events, warn, waitMs) => {
     const abort = new AbortController();
     let closing = false;
     const ended = Promise.resolve()
@@ -126,8 +126,9 @@ const listened = ({ run, operation, what }, events, warn) => {
         .catch((error) => {
         if (closing)
             return;
-        events({ event: "warning", code: "listen_failed", operation });
-        warn(`${what} arriving during this command are not saved: ${error instanceof Error ? error.message : String(error)}`);
+        const warning = { event: "warning", code: "listen_failed", operation };
+        events(warning);
+        warn(`${what} arriving during this command are not saved: ${error instanceof Error ? error.message : String(error)}`, warning);
     });
     return {
         operation,
@@ -137,7 +138,7 @@ const listened = ({ run, operation, what }, events, warn) => {
         },
         stop: () => {
             abort.abort();
-            return settled(new Set([ended]), SAVES_WAIT_MS);
+            return settled(new Set([ended]), waitMs);
         },
     };
 };
@@ -171,6 +172,10 @@ const rekeyRecipients = async (app, profile, env, warn, from, to) => {
         warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`);
     }
 };
+const waitsOf = (command) => {
+    const { closeWaitMs, rekeyPacing } = environmentOf(command);
+    return { ...(closeWaitMs === undefined ? {} : { closeWaitMs }), ...(rekeyPacing ? { rekeyPacing } : {}) };
+};
 /**
  * A connection as every shared reader sees it: its account remembered, each call a run event, what
  * the reads answer saved to the store. `close` closes the connection and the store it opened. One
@@ -180,7 +185,7 @@ const rekeyRecipients = async (app, profile, env, warn, from, to) => {
  * does not `watch` is open: what it queued while nothing was connected is delivered once and cannot be fetched again.
  * A connection opened with `listen: true` is left to its `watch` and `feed`, which save the same.
  */
-export const connected = (connection, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }, { settings, env, renderer }, events, store = lazyStore(env, app.command), { listen: watching = false } = {}) => {
+export const connected = (connection, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }, { settings, env, renderer }, events, store = lazyStore(env, app.command), { listen: watching = false, closeWaitMs = SAVES_WAIT_MS, rekeyPacing, } = {}) => {
     const self = connection.self();
     if (self !== null)
         rememberAccount(app, settings.profile, self, env);
@@ -207,12 +212,13 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             announcing,
             closing: closing.signal,
             ...(deletedWithoutChat ? { deletedWithoutChat } : {}),
+            ...(rekeyPacing ? { rekeyPacing } : {}),
             rekeyed: (from, to) => rekeyRecipients(app, settings.profile, env, renderer.warn, from, to),
             recipientIds: () => (new RecipientList(recipientsPathFor(app, settings.profile, env), app.command).read() ?? []).flatMap((recipient) => [recipient.id, ...(recipient.partnerId ? [recipient.partnerId] : [])]),
             ...(history === "store" ? { namesFromStore: savedChatId ? { savedChatId } : {} } : {}),
         });
     const passives = history === "store" && self !== null && !watching
-        ? passivesOf(saving).map((passive) => listened(passive, events, renderer.warn))
+        ? passivesOf(saving).map((passive) => listened(passive, events, renderer.warn, closeWaitMs))
         : [];
     return {
         adapter: saving,
@@ -225,22 +231,22 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             finally {
                 try {
                     const ended = await Promise.all(passives.map((passive) => passive.stop()));
+                    const warn = renderer.warn;
+                    const warned = (warning, text) => {
+                        events(warning);
+                        warn(text, warning);
+                    };
                     passives.forEach(({ operation, what }, at) => {
                         if (ended[at])
                             return;
-                        events({ event: "warning", code: "store_not_written", operation });
-                        renderer.warn(`not saved to the local store: the messenger was still handing on ${what} at exit`);
+                        warned({ event: "warning", code: "store_not_written", operation }, `not saved to the local store: the messenger was still handing on ${what} at exit`);
                     });
-                    await settled(new Set([...pending, ...announcing]), SAVES_WAIT_MS);
+                    await settled(new Set([...pending, ...announcing]), closeWaitMs);
                     closing.abort();
-                    if (pending.size > 0) {
-                        events({ event: "warning", code: "store_not_written", operation: "close" });
-                        renderer.warn("not saved to the local store: the last messages were still being written at exit");
-                    }
-                    if (announcing.size > 0) {
-                        events({ event: "warning", code: "stored_chats_failed", operation: "close" });
-                        renderer.warn("the messenger's stored-chats hook did not finish and was abandoned at exit; nothing is lost");
-                    }
+                    if (pending.size > 0)
+                        warned({ event: "warning", code: "store_not_written", operation: "close" }, "not saved to the local store: the last messages were still being written at exit");
+                    if (announcing.size > 0)
+                        warned({ event: "warning", code: "stored_chats_failed", operation: "close" }, "the messenger's stored-chats hook did not finish and was abandoned at exit; nothing is lost");
                 }
                 finally {
                     await store.close();
@@ -265,7 +271,10 @@ export const connectedFor = async (command, messenger, base, options) => {
     }
     return {
         connection,
-        ...connected(connection, messenger, base, options.events, store, options.listen ? { listen: true } : {}),
+        ...connected(connection, messenger, base, options.events, store, {
+            ...waitsOf(command),
+            ...(options.listen ? { listen: true } : {}),
+        }),
     };
 };
 const unrecorded = (command, messenger, profile, offline) => {
@@ -410,7 +419,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
                             throw new CliError("validation_error", "the read connection has already been released");
                         }
                         base.track(connection);
-                        held = connected(connection, messenger, base, events);
+                        held = connected(connection, messenger, base, events, undefined, waitsOf(command));
                     }
                     return held.adapter;
                 },

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

@@ -13,8 +13,9 @@ export declare const noticeFor: (context: MessengerContext, app: AppIdentity, se
 /**
  * A serve left running writes its diagnostics to a log file, so off a terminal each one is a log record with
  * its time and run. A sentence handed to the renderer may quote an error or a chat, so the record keeps only
- * which kind of line it was; serve's own reports go through `noticeFor` with a code. The renderer is changed
- * in place, so the send guard, bound to it before serve started, writes records too.
+ * which kind of line it was, and a warning's code, operation and counts when the warning event comes with it
+ * (`Warn`); serve's own reports go through `noticeFor` with a code. The renderer is changed in place, so the
+ * send guard, bound to it before serve started, writes records too.
  */
 export declare const recordDiagnostics: (context: MessengerContext, app: AppIdentity) => MessengerContext;
 export {};

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

@@ -19,16 +19,18 @@ export const noticeFor = (context, app, severity = "warn") => ({ text, ...attrib
 /**
  * A serve left running writes its diagnostics to a log file, so off a terminal each one is a log record with
  * its time and run. A sentence handed to the renderer may quote an error or a chat, so the record keeps only
- * which kind of line it was; serve's own reports go through `noticeFor` with a code. The renderer is changed
- * in place, so the send guard, bound to it before serve started, writes records too.
+ * which kind of line it was, and a warning's code, operation and counts when the warning event comes with it
+ * (`Warn`); serve's own reports go through `noticeFor` with a code. The renderer is changed in place, so the
+ * send guard, bound to it before serve started, writes records too.
  */
 export const recordDiagnostics = (context, app) => {
     if (context.format === "pretty")
         return context;
-    const say = (severity, event, always = false) => (_text) => {
+    const say = (severity, event, always = false) => (_text, warning) => {
         if (context.settings.quiet && !always)
             return;
-        record(context, app, severity, { event });
+        const { event: _warning, ...fields } = warning ?? {};
+        record(context, app, severity, { event, ...fields });
     };
     const renderer = context.renderer;
     renderer.note = say("info", "serve.note");

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

@@ -1,13 +1,13 @@
 import type { Id } from "../../domain/models.js";
 import { type MessengerAdapter } from "../../ports/messenger.js";
 import type { MessengerTraits } from "../../ports/traits.js";
-import type { EventSink } from "../../runs/events.js";
+import type { EventSink, Warn } from "../../runs/events.js";
 import type { AccountKey, DeletionScope, MessageStore } from "../../store/store.js";
 export interface Saving {
     account: AccountKey;
     /** Opened on the first save, not before: a command that reads nothing has no reason to touch the file. */
     store: () => Promise<MessageStore | undefined>;
-    warn: (message: string) => void;
+    warn: Warn;
     events: EventSink;
     /** Saves still writing, for the closer to wait on: `watch` does not hold the next event for one. */
     pending?: Set<Promise<void>>;

package/dist/cli/messenger/stored.js

@@ -16,9 +16,10 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
     let warned = false;
     let recorded = profile === undefined;
     const notWritten = (operation, error) => {
-        events({ event: "warning", code: "store_not_written", operation });
+        const warning = { event: "warning", code: "store_not_written", operation };
+        events(warning);
         if (!warned)
-            warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`);
+            warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`, warning);
         warned = true;
     };
     const attempt = async (operation, write) => {
@@ -92,8 +93,14 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             pending?.delete(saving);
         if (count === 0)
             return;
-        events({ event: "warning", code: "rekeys_not_applied", operation: "history.rekey", counts: { rekeys: count } });
-        warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`);
+        const warning = {
+            event: "warning",
+            code: "rekeys_not_applied",
+            operation: "history.rekey",
+            counts: { rekeys: count },
+        };
+        events(warning);
+        warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`, warning);
     };
     closing?.addEventListener("abort", giveUpRekeys, { once: true });
     const saveRekeys = async (pairs, round) => {
@@ -466,8 +473,9 @@ const announceStoredChats = async (messenger, store, account, events, warn, reci
             await messenger.storedChats?.(held);
     }
     catch (error) {
-        events({ event: "warning", code: "stored_chats_failed", operation: "history.stored_chats" });
-        warn(`the messenger was not told the stored chats: ${error instanceof Error ? error.message : String(error)}`);
+        const warning = { event: "warning", code: "stored_chats_failed", operation: "history.stored_chats" };
+        events(warning);
+        warn(`the messenger was not told the stored chats: ${error instanceof Error ? error.message : String(error)}`, warning);
     }
 };
 /** Read once when `watch` starts: a store read per event would let a later event overtake an earlier one. */

package/dist/runs/events.d.ts

@@ -49,6 +49,8 @@ export interface CacheEvent {
 }
 export type DiagnosticEvent = RequestEvent | CacheEvent | WarningEvent;
 export type EventSink = (event: DiagnosticEvent) => void;
+/** A sentence for a person, and the warning event it stands for when there is one: a log record keeps only the event. */
+export type Warn = (message: string, warning?: WarningEvent) => void;
 /** `FLOOD_WAIT`, `PEER_ID_INVALID`, `login.token` — or nothing. A sentence is dropped, not trimmed. */
 export declare const providerErrorKey: (value: unknown) => string | undefined;
 /**

package/package.json

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