@wirecat/cli-core 0.359.0 → 0.360.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ shape of this file.
 
 ## Unreleased
 
+## 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 zeros. */
+    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()
@@ -137,7 +137,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 +171,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 +184,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 +211,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,
@@ -231,7 +236,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
                         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`);
                     });
-                    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" });
@@ -265,7 +270,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 +418,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/package.json

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