@animalabs/agent-framework 0.33.0 → 0.34.0

package/src/mcpl/protocol-family.ts

@@ -6,10 +6,14 @@
  * - **Legacy**: MCP 2024-11-05, with MCPL riding on it as an experimental
  *   capability. `McplServerConnection` speaks it, over stdio or MCPL's
  *   WebSocket binding.
- * - **Modern**: MCP 2026-07-28, which is stateless. It has no `initialize`;
- *   every request carries its version and client capabilities in `_meta`, and
- *   server-to-client requests are replaced by in-band continuation.
- *   `ModernMcpConnection` speaks it, over stdio or Streamable HTTP.
+ * - **Modern**: the official SDK's client, which `ModernMcpConnection` drives.
+ *   Over stdio it speaks MCP 2026-07-28, which is stateless. That revision
+ *   has no `initialize`: every request carries its version and client
+ *   capabilities in `_meta`, and server-to-client requests are replaced by
+ *   in-band continuation. Over Streamable HTTP the revision is negotiated at
+ *   each connect, from {@link MODERN_HTTP_PROTOCOL_VERSIONS}: 2026-07-28
+ *   when the server offers it, and otherwise a 2025 revision, with its
+ *   `initialize` handshake and its session.
  *
  * A URL's scheme decides a network server's family: `ws://`/`wss://` is
  * legacy, `http://`/`https://` is modern, because neither family has the
@@ -17,10 +21,10 @@
  * unless its config says `protocol: 'modern'`, so every existing stdio
  * configuration opens exactly as before.
  *
- * Why no auto-detection: the modern spec's discover-first probe makes some
- * real MCPL servers exit (heartbeat-mcpl closes on any first message that
- * isn't `initialize`), the SDK's stdio probe launches the server twice, and a
- * server's era is a stable fact its configuration can state.
+ * Why a stdio server's era isn't detected: the modern spec's discover-first
+ * probe makes some real MCPL servers exit (heartbeat-mcpl closes on any first
+ * message that isn't `initialize`), the SDK's stdio probe launches the server
+ * twice, and a server's era is a stable fact its configuration can state.
  */
 import { NOTICE_TAG } from '../notice-tags.js';
 import { DENY_BY_DEFAULT, capabilityPatternMatches } from './capability-grant.js';
@@ -31,8 +35,10 @@ import { kindOf } from '../config-checks.js';
 
 /** The one revision the legacy engine offers and accepts. */
 export const LEGACY_MCP_PROTOCOL_VERSION = '2024-11-05';
-/** The revision the modern engine pins. */
+/** The revision the modern engine pins over stdio, and prefers over HTTP. */
 export const MODERN_MCP_PROTOCOL_VERSION = '2026-07-28';
+/** 2024-11-05 isn't offered: its HTTP binding was HTTP+SSE, another transport. */
+export const MODERN_HTTP_PROTOCOL_VERSIONS: readonly string[] = [MODERN_MCP_PROTOCOL_VERSION, '2025-11-25', '2025-06-18', '2025-03-26'];
 
 export type McpProtocolFamily = 'legacy' | 'modern';
 export type McpTransportKind = 'stdio' | 'websocket' | 'http';

package/src/mcpl/server-connection.ts

@@ -157,20 +157,27 @@ const UNSUPPORTED_PROTOCOL_VERSION_CODE = -32022;
 const MAX_TOOL_LIST_PAGES = 100;
 
 /**
- * The server and this engine have no protocol revision in common, so the
- * connection was never established. This is a protocol-negotiation fact, not
- * a request outcome. Retrying cannot change it: each engine offers one
- * revision, and only configuration can fix the mismatch. A connection that
- * gets this error does not schedule reconnects. The legacy engine and the
- * modern one (ModernMcpConnection, whose pinned revision the server refused)
- * both throw it, so its readers treat them alike.
+ * This engine and the server could not negotiate a protocol revision, so the
+ * connect that throws it established no connection. Usually they share none. Over HTTP it
+ * can also be the SDK's own refusal: after a -32022 whose list names a
+ * revision from 2026-07-28 on that this client doesn't speak, the SDK
+ * negotiates no further, even when the list also names a 2025 revision both
+ * speak. This is a protocol-negotiation fact, not a request outcome.
+ * Retrying cannot change it: each engine offers the same revisions every
+ * time (`offeredRevisions`), and only configuration, or the server's
+ * operator, can fix the mismatch. A connection that gets this error does not
+ * schedule reconnects. The legacy engine and the modern one
+ * (ModernMcpConnection) both throw it, so its readers treat them alike.
  *
- * - `rejected`: the server refused the offered revision: the legacy engine's
- *   `initialize` answered with error -32022, or a modern server's discovery
- *   or error naming no common revision. `supported` is the server's own list,
- *   when it gave one.
- * - `mismatch`: the server answered the legacy engine's `initialize` with a
- *   revision other than 2024-11-05, or with none.
+ * - `rejected`: the server refused the revision offered. The legacy
+ *   engine's `initialize` was answered with error -32022. A modern server's
+ *   discovery or -32022 error named no revision in common (over HTTP, a
+ *   discovery's list counts once the server has refused the `initialize`
+ *   tried after it too), or, over HTTP, named one this client doesn't speak,
+ *   as above. `supported` is the server's own list, when it gave one.
+ * - `mismatch`: the server answered `initialize` with a revision that
+ *   handshake doesn't accept, or with none: the legacy engine's, or a modern
+ *   connection's 2025 handshake over HTTP.
  */
 export class McplProtocolVersionError extends Error {
   constructor(
@@ -185,9 +192,15 @@ export class McplProtocolVersionError extends Error {
      *  redacted (`rejected`). */
     readonly code?: number,
     readonly data?: unknown,
-    /** The revision this client offered: the legacy engine's, unless a
-     *  modern connection's. */
+    /** The revision this client offered first, in its order of preference:
+     *  the legacy engine's (2024-11-05), a modern connection's over stdio
+     *  (2026-07-28), or over HTTP 2026-07-28, the first of
+     *  `offeredRevisions`. */
     readonly offered: string = MCP_PROTOCOL_VERSION,
+    /** Every revision this client offered, in its order of preference: the
+     *  legacy engine's one, a modern connection's one over stdio, or its
+     *  list over HTTP. */
+    readonly offeredRevisions: readonly string[] = [offered],
   ) {
     super(message);
     this.name = 'McplProtocolVersionError';

package/src/mcpl/tool-presence.ts

@@ -27,6 +27,7 @@
  */
 import { objectSignature, renderToolLines, toolDigest, type HintedTool, type Shown } from './tool-signature.js';
 import { nameToTypeBack, quotedValue, suppliedValue } from '../supplied-text.js';
+import { appendAll } from '../append-all.js';
 
 export interface ToolsetDecl {
   title?: string;
@@ -632,7 +633,7 @@ export class ToolPresence {
         continue;
       }
       const title = (c.opened || c.retitled) && !bare ? c.title : undefined;
-      if (showsBlock(c)) lines.push(...this.toolBlock(c.key, c.now, { headed: !bare, title, seen, describeAll: opts.describeAll }));
+      if (showsBlock(c)) appendAll(lines, this.toolBlock(c.key, c.now, { headed: !bare, title, seen, describeAll: opts.describeAll }));
       else if (title) lines.push(`${this.label(c.key)} ${suppliedValue(title)}`);
       if (c.gone.length) lines.push(`now unavailable: ${c.gone.map(suppliedValue).join(', ')}`);
       if (c.opened && !bare) {
@@ -641,7 +642,8 @@ export class ToolPresence {
       }
     }
     for (const s of cs.suggest) lines.push(this.renderSuggestion(s));
-    lines.push(...this.untoldNotes(cs), ...cs.notes);
+    appendAll(lines, this.untoldNotes(cs));
+    appendAll(lines, cs.notes);
     return lines.join('\n');
   }
 
@@ -663,7 +665,7 @@ export class ToolPresence {
     if (!v.size) return null;
     const lines: string[] = [];
     for (const [key, e] of v) {
-      lines.push(...this.toolBlock(key, [...e.tools.values()], { describeAll: true, title: e.title }));
+      appendAll(lines, this.toolBlock(key, [...e.tools.values()], { describeAll: true, title: e.title }));
       const close = this.closeHint(key);
       if (close) lines.push(`  ${close} closes it.`);
     }
@@ -679,7 +681,7 @@ export class ToolPresence {
     const v = this.view();
     if (v.size) {
       for (const [key, e] of v) {
-        lines.push(...this.toolBlock(key, [...e.tools.values()], { describeAll: true, title: e.title, seen: opts.mark === false ? new Set<string>() : undefined }).map((l) => `  ${l}`));
+        appendAll(lines, this.toolBlock(key, [...e.tools.values()], { describeAll: true, title: e.title, seen: opts.mark === false ? new Set<string>() : undefined }).map((l) => `  ${l}`));
         const close = this.closeHint(key);
         if (close) lines.push(`    ${close} closes it.`);
       }
@@ -700,7 +702,10 @@ export class ToolPresence {
       const names = this.allTools.filter((t) => this.toolsetOf(t.name) === g).map((t) => t.name);
       openable.push(`  ${nameToTypeBack(g)}: ${names.map(nameToTypeBack).join(', ')}`);
     }
-    if (openable.length) lines.push(`can open — ${this.names.open} {server:"${this.server}", toolset, instance?, options?}:`, ...openable);
+    if (openable.length) {
+      lines.push(`can open — ${this.names.open} {server:"${this.server}", toolset, instance?, options?}:`);
+      appendAll(lines, openable);
+    }
     return lines.join('\n');
   }
 

package/src/mcpl/toolset-host.ts

@@ -35,6 +35,7 @@ import {
   type ChangeSet, type MetaToolNames, type Presence,
 } from './tool-presence.js';
 import type { HintedTool } from './tool-signature.js';
+import { appendAll } from '../append-all.js';
 
 /** The meta-tools' module, whose tools are `toolsets--open` and so on. */
 export const TOOLSETS_MODULE = 'toolsets';
@@ -246,7 +247,7 @@ export class ToolsetController {
         const toolset = typeof res.toolset === 'string' ? res.toolset : String(params.toolset ?? '');
         const instance = typeof res.instance === 'string' && res.instance ? res.instance : typeof params.instance === 'string' ? params.instance : undefined;
         this.presence.noteOpened(toolset, instance, typeof res.title === 'string' && res.title ? res.title : undefined);
-        cs.changes.push(...this.presence.diff(before, this.presence.view()).changes);
+        appendAll(cs.changes, this.presence.diff(before, this.presence.view()).changes);
         break;
       }
       case 'toolsets/close': {
@@ -255,7 +256,7 @@ export class ToolsetController {
         cs = this.applyHints(metaHints(res), 'toolsets/close');
         const before = this.presence.view();
         this.presence.noteClosed(String(params.toolset ?? ''), typeof params.instance === 'string' ? params.instance : undefined);
-        cs.changes.push(...this.presence.diff(before, this.presence.view()).changes);
+        appendAll(cs.changes, this.presence.diff(before, this.presence.view()).changes);
         break;
       }
       default:
@@ -298,7 +299,7 @@ export class ToolsetController {
       this.scheduleRecovery();
     }
     const cs = this.presence.diff(before, this.presence.view());
-    cs.suggest.push(...r.suggest);
+    appendAll(cs.suggest, r.suggest);
     return cs;
   }
 
@@ -332,11 +333,11 @@ export class ToolsetController {
       this.scheduleRecovery();
     }
     const cs = this.presence.diff(before, this.presence.view());
-    cs.suggest.push(...suggest);
+    appendAll(cs.suggest, suggest);
     // A lost toolset gets its note, not also a "closed" line.
     cs.changes = cs.changes.filter((c) => !lost.some((o) => keyOf(o.toolset, o.instance) === c.key));
     const told = this.presence.adoptionNotes(lost, ended);
-    cs.notes.push(...told.notes);
+    appendAll(cs.notes, told.notes);
     if (told.ended.length) cs.ended = [...(cs.ended ?? []), ...told.ended];
     return cs;
   }
@@ -625,7 +626,7 @@ export class ToolsetController {
     const moved = this.presence.applyMoves(moves);
     if (!moved.length) return;
     const cs = emptyChange();
-    cs.notes.push(...moved.map(({ name, to }) => to === 'dynamic'
+    appendAll(cs.notes, moved.map(({ name, to }) => to === 'dynamic'
       ? `${nameToTypeBack(name)} left your tool list: it's announced when available, and called with ${META_TOOL_NAMES.act} {server:"${this.serverId}", tool:${quotedValue(name)}, args}.`
       : `${nameToTypeBack(name)} is in your tool list now, as ${nameToTypeBack(this.deps.listedName(this.serverId, name))}.`));
     this.deliver(cs);

package/src/mcpl/toolsets-module.ts

@@ -32,6 +32,7 @@ import { keyOf, type ChangeSet, type ToolPresence } from './tool-presence.js';
 import { checkArgs, jsonText, renderToolDefinition, type HintedTool } from './tool-signature.js';
 import { McplRequestError } from './server-connection.js';
 import { BUILTIN_TOOLSET, type HostPresentation } from '../host-presentation.js';
+import { appendAll } from '../append-all.js';
 
 /** The namespace a reminder's stored injection carries. */
 export const TOOLSETS_REMINDER_NAMESPACE = 'mcpl-toolsets';
@@ -516,7 +517,7 @@ export class ToolsetsModule implements Module {
         return said;
       })
       : [];
-    lines.push(...unread);
+    appendAll(lines, unread);
     return lines.length ? textResult(`${result.data}\n${lines.join('\n')}`) : result;
   }
 

package/src/mcpl/types.ts

@@ -267,8 +267,9 @@ export interface McplServerConfig {
    * - `ws://` or `wss://` is a legacy MCPL server over MCPL's WebSocket
    *   binding. The host dials it and runs the same newline-delimited JSON-RPC
    *   as over stdio.
-   * - `http://` or `https://` is a modern MCP (2026-07-28) server over
-   *   Streamable HTTP.
+   * - `http://` or `https://` is a modern MCP server over Streamable HTTP.
+   *   Its revision is negotiated at each connect: 2026-07-28 when the server
+   *   offers it, and otherwise 2025-11-25, 2025-06-18 or 2025-03-26.
    */
   url?: string;
 
@@ -428,14 +429,34 @@ export interface McplServerConfig {
    * Only `true` turns it on, and null counts as not set. `create()`,
    * `connectMcplServer` and `restartMcplServer` refuse any other value, such
    * as a quoted "false".
+   *
+   * A modern server reached over HTTP at a 2025 revision can hold a session
+   * for this client. When the server ends it (HTTP 404), or stops serving its
+   * revision or its streams as a server upgraded to 2026-07-28 does, after it
+   * has answered a request, a new session starts at once whether or not this
+   * is set: the connection emits 'close' while its `willReconnect` reads
+   * true, then 'reconnect'. If that new session can't start, this setting
+   * decides, as for any lost connection, and a revision verdict stops it for
+   * good, as on any reconnect; without this setting, a second 'close', while
+   * `willReconnect` reads false, says the server is gone. An answered session
+   * that ends less than `reconnectIntervalMs` after it started gets a new
+   * one at once only if the last session restarted that way had lived that
+   * long, or there was none. A second such young end in a row, and a session
+   * that ends before it has answered, count as a failed connect, and follow
+   * this setting.
    */
   reconnect?: boolean;
 
   /**
    * Base interval between reconnection attempts in milliseconds.
    * The actual delay doubles with each consecutive failure (with ±25% jitter)
-   * up to `reconnectMaxIntervalMs`, and resets after a successful handshake.
-   * Default: 5000 (5 seconds).
+   * up to `reconnectMaxIntervalMs`, and resets after a successful handshake
+   * (for a modern server's 2025 session over HTTP, once that session's end
+   * starts a new one at once). Over HTTP the same backoff paces a modern
+   * server's streams: a dropped stream's first try waits the server's
+   * `retry` hint when it sent one above 0, and the backoff's first step
+   * otherwise, and a try after a failed one waits the longer of the hint
+   * and the doubling backoff. Default: 5000 (5 seconds).
    */
   reconnectIntervalMs?: number;
 

package/src/modules/discord/index.ts

@@ -1172,7 +1172,7 @@ export class DiscordModule implements Module {
       // boundary whose tied millisecond must be preserved.
       const fetchedCompleteHistory = discordMessages.length < scrollback;
       const oldestFetchedTimestamp = discordMessages.length > 0
-        ? Math.min(...discordMessages.map((msg) => msg.timestamp.getTime()))
+        ? discordMessages.reduce((min, msg) => Math.min(min, msg.timestamp.getTime()), Infinity)
         : undefined;
       for (const [externalId, rows] of storedMessageMap) {
         const stored = rows[0]!;

package/src/modules/health/index.ts

@@ -188,7 +188,7 @@ export class HealthModule implements Module {
         timestamp: safeZoned(s.timestamp),
         agentName: s.agentName,
         success: s.success,
-        error: s.error,
+        error: s.errorWords,
         requestId: s.requestId,
         tokenUsage: s.tokenUsage,
       };
@@ -201,7 +201,7 @@ export class HealthModule implements Module {
       .map((s) => ({
         timestamp: s.timestamp,
         agentName: s.agentName,
-        error: typeof s.error === 'string' ? safeSlice(s.error, 0, 400) : s.error,
+        error: typeof s.error === 'string' ? safeSlice(s.error, 0, 400) : null,
         requestId: s.requestId,
       }));
 

package/src/modules/history/semantic.ts

@@ -880,14 +880,14 @@ export class SemanticIndexer {
       // The current branch may then have items this pass didn't send, and
       // old items a failed delete left are still to go.
       if (left || oldItemsOwed) report.more = true;
-      this.consecutiveFailures = 0; this.lastError = named(notStats?.message ?? null, ...phaseErrors); this.lastSyncAt = Date.now();
+      this.consecutiveFailures = 0; this.lastError = named([notStats?.message ?? null, ...phaseErrors]); this.lastSyncAt = Date.now();
       return report;
     } catch (e) {
       this.consecutiveFailures++;
       const delay = Math.min(15 * 60_000, 5_000 * 2 ** Math.min(8, this.consecutiveFailures - 1));
       this.backoffUntil = Date.now() + delay;
       const failure = e instanceof Error ? e.message : String(e);
-      this.lastError = named(failure, notStats?.message ?? null, ...phaseErrors);
+      this.lastError = named([failure, notStats?.message ?? null, ...phaseErrors]);
       this.warn(`sync failed (${this.consecutiveFailures}×, retry in ${Math.round(delay / 1000)}s): ${failure}`);
       report.more = true;
       return report;
@@ -896,6 +896,6 @@ export class SemanticIndexer {
 }
 
 /** Each failure a sync pass met, once, in the order given, for its lastError: null if none. */
-function named(...failures: (string | null)[]): string | null {
+function named(failures: (string | null)[]): string | null {
   return [...new Set(failures.filter((f): f is string => f !== null))].join('; ') || null;
 }

package/src/modules/workspace/index.ts

@@ -89,6 +89,7 @@ import {
   sameIdentity,
   stageContained,
 } from './direct-write.js';
+import { appendAll } from '../../append-all.js';
 
 /** Default for how long the after-batch scan may hold the agent's next inference. */
 const AGENT_ACTION_SCAN_DEADLINE_MS = 20_000;
@@ -4549,7 +4550,7 @@ export class WorkspaceModule implements Module {
             });
             continue;
           }
-          notes.push(...lookedIn);
+          appendAll(notes, lookedIn);
           const plan = planTargetEdits(tool, target, stored.bytes, hints, maxSize, counts, problems);
           if (plan === null) continue;
           plans.push({
@@ -5670,8 +5671,8 @@ export class WorkspaceModule implements Module {
       const found = mount.direct
         ? await this.textsFromDisk(mount, relativePath, root, start, kept, (text) => searched(text)())
         : await this.textsFromStore(mount, relativePath, start, kept, searched);
-      skipped.push(...found.skipped);
-      incomplete.push(...found.incomplete);
+      appendAll(skipped, found.skipped);
+      appendAll(incomplete, found.incomplete);
     }
 
     const answer: GrepAnswer = {

package/src/modules/workspace/observe.ts

@@ -48,6 +48,7 @@ import type { FileHandle } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
 import { onlyDeviceDiffers, sameRootIdentity, type Fingerprint, type RootIdentity } from './disk-agreement.js';
 import { OUTSIDE_STEP, UNFOLLOWED_STEP, errnoClause, errnoCode, systemWords } from './answers.js';
+import { appendAll } from '../../append-all.js';
 
 export interface MountView {
   /**
@@ -2391,7 +2392,7 @@ export async function walkScope(
     for (const d of subdirs) walk.dirs.add(d);
     for (const [p, why] of others) walk.others.set(p, why);
     for (const p of otherFiles) walk.otherFiles.add(p);
-    walk.incomplete.push(...regions);
+    appendAll(walk.incomplete, regions);
     walk.complete.add(rel);
     const listing = { leaves, subdirs, ...dir.identity() };
     listings.set(rel, listing);

package/src/modules/workspace/reconcile.ts

@@ -94,6 +94,7 @@ import {
 } from './observe.js';
 import { EffectFailed, type Expect, callFailed, chainOf, chmodContained, narrowedTo, syncDirectories, unlinkContained, writeContained } from './effects.js';
 import { OUTSIDE_STEP, RESOLVED_OUTSIDE_STEP, UNFOLLOWED_STEP, errnoClause, errnoWords } from './answers.js';
+import { appendAll } from '../../append-all.js';
 
 export type EntryState =
   | 'synced'
@@ -1150,8 +1151,8 @@ export async function reconcilePass(
     return result;
   }
   const { walk, facts } = gathered;
-  result.dirs.push(...gathered.dirs);
-  result.incomplete.push(...gathered.incomplete);
+  appendAll(result.dirs, gathered.dirs);
+  appendAll(result.incomplete, gathered.incomplete);
 
   // Decide and apply — synchronously, so nothing interleaves.
   const branchId = store.currentBranch().id;

package/src/notice-tags.ts

@@ -17,7 +17,7 @@ export const NOTICE_TAG = {
   turnInterrupted: 'turn-interrupted',
   closedChannel: 'closed channel',
   tunedOut: 'tuned out',
-  refusalRewind: 'refusal-rewind',
+  refusalRewind: 'turns-set-aside',
   drafts: 'drafts',
   delivered: 'delivered',
   routing: 'routing',
@@ -75,20 +75,23 @@ export const NOTICE_TAG = {
   noText: 'no text',
 } as const;
 
+export const FORMER_NOTICE_TAGS = ['refusal-rewind'] as const;
+
 /**
- * The bracket openings context-manager 0.23.0 and 0.23.1 write into an
- * agent's context outside a tool result or read back from it, marked as the
- * framework's own are. Check them against each context-manager release the
- * framework takes.
+ * The bracket openings context-manager 0.25.1 writes into an agent's context
+ * outside a tool result or read back from it, the same as 0.23.1 and 0.25.0
+ * write, marked as the framework's own are. Its `[truncated — original was`
+ * isn't here: NOTICE_TAG.truncated marks it. Check them against each
+ * context-manager release the framework takes.
  */
 export const CONTEXT_MANAGER_TAGS = [
   'content omitted', 'image not shown', 'Operator note', 'Recall', 'tool call omitted', 'tool result moved', 'Topic Transition',
 ] as const;
 
 /**
- * The bracket openings membrane 0.8.0 writes into an agent's request outside
- * a tool result, marked as the framework's own are. Check them against each
- * membrane release the framework takes.
+ * The bracket openings membrane 0.8.0 and 0.9.0 write into an agent's request
+ * outside a tool result, marked as the framework's own are. Check them against
+ * each membrane release the framework takes.
  */
 export const MEMBRANE_TAGS = [
   'Audio', 'continuing', 'Document', 'duplicate tool_result for', 'Image', 'orphan tool_result for', 'Start', 'Tool Result', 'Video',

package/src/presentation.ts

@@ -63,6 +63,7 @@
  */
 import type { ContentBlock } from '@animalabs/membrane';
 import { continuesBody, MessageStore, type ContextManager, type MessageId, type MessageMetadata, type StoredMessage } from '@animalabs/context-manager';
+import { isReasoningLoss } from './reasoning-loss.js';
 import { audienceOf, heldFromResidents, observedRowFor, suppressedRow } from './dendrite/audience.js';
 import { sameSlot, type AgentRegistry } from './dendrite/registry.js';
 import type { AgentName, AgentRecord, MessageSlotRef, ObserveEdge } from './dendrite/types.js';
@@ -228,7 +229,8 @@ export type RowSlot = 'own' | MessageSlotRef;
  * a ref sameSlot as its `ownSlot`), else a slot it may observe. undefined,
  * a slot its caller couldn't name, is elsewhere.
  *
- * A row a suppress rule hid (suppressedRow) is elsewhere to every reader,
+ * A legacy reasoning-loss notice or a row a suppress rule hid
+ * (suppressedRow) is elsewhere to every reader,
  * in any slot: no view the framework sets renders it.
  *
  * In its own slot, with `stamp = audienceOf(metadata)`:
@@ -263,7 +265,7 @@ export function bearingOf(
 ): Bearing {
   const metadata = row.metadata as Record<string, unknown> | undefined;
   if (slot === undefined) return 'elsewhere';
-  if (suppressedRow(metadata)) return 'elsewhere';
+  if (isReasoningLoss(metadata) || suppressedRow(metadata)) return 'elsewhere';
   if (slot !== 'own' && !sameSlot(slot, reader.ownSlot)) {
     const shown = reader.observed.some((seen) => sameSlot(seen.slot, slot)
       && observedRowFor(seen.edge, row, { observer: reader.name, owners: seen.owners }));

package/src/reasoning-loss.ts

@@ -0,0 +1,7 @@
+/** #973: #938 stopped writing these notices, but old stores retain them.
+ *  Exclude deterministically before selection, compression and thinking binding;
+ *  never match text or change stored history. */
+export function isReasoningLoss(metadata: unknown): boolean {
+  const mark = metadata as { kind?: unknown; system?: unknown } | null | undefined;
+  return mark?.kind === 'reasoning-loss' && mark.system === true;
+}

package/src/recovery/offline-branch.ts

@@ -16,6 +16,7 @@ import {
   type DiscordAwarenessRef,
   type DiscordMessageMetadataCarrier,
 } from './discord-awareness-outbox.js';
+import { appendAll } from '../append-all.js';
 
 export interface OfflineRecoveryBranchOptions {
   storePath: string;
@@ -877,7 +878,7 @@ function buildSuppressionPlan(
   const intervals: SuppressionInterval[] = [...stamped];
   for (const id of messageIds) {
     const location = locations.get(id)!;
-    intervals.push(...location.runs.map((run) => ({ ...run })));
+    appendAll(intervals, location.runs.map((run) => ({ ...run })));
   }
   for (const range of ranges) {
     const from = locations.get(range.fromMessageId)!;
@@ -896,7 +897,7 @@ function buildSuppressionPlan(
       fromId: earlier.firstId,
       toId: later.firstId,
     });
-    for (const end of [from, to]) intervals.push(...end.runs.map((run) => ({ ...run })));
+    for (const end of [from, to]) appendAll(intervals, end.runs.map((run) => ({ ...run })));
   }
 
   intervals.sort((a, b) => a.start - b.start || a.end - b.end);
@@ -916,7 +917,7 @@ function buildSuppressionPlan(
   const carriers: DiscordMessageMetadataCarrier[] = [];
   const ids = new Set<string>();
   for (const interval of merged) {
-    carriers.push(...collectDiscordCarriers(contextManager, interval.start, interval.end + 1, ids));
+    appendAll(carriers, collectDiscordCarriers(contextManager, interval.start, interval.end + 1, ids));
   }
   return {
     intervals: merged,
@@ -946,7 +947,7 @@ function collectDiscordCarriers(
       Math.min(RECOVERY_SCAN_WINDOW, end - offset),
       { resolveBlobs: false },
     ).messages;
-    carriers.push(...messages.map(addressingOnly));
+    appendAll(carriers, messages.map(addressingOnly));
     if (ids) for (const message of messages) ids.add(String(message.id));
   }
   return carriers;

package/src/recovery/recover-cli.ts

@@ -2,6 +2,7 @@
 
 import { createOfflineRecoveryBranch } from './offline-branch.js';
 import type { DiscordAwarenessMarks } from './discord-awareness-outbox.js';
+import { appendAll } from '../append-all.js';
 
 interface CliOptions {
   storePath?: string;
@@ -86,7 +87,7 @@ function parseArgs(args: string[]): CliOptions {
       case '--messages': options.messages = Number(value()); break;
       case '--suppress':
       case '--suppress-message':
-        options.suppressMessageIds.push(...value().split(',').map((item) => item.trim()).filter(Boolean));
+        appendAll(options.suppressMessageIds, value().split(',').map((item) => item.trim()).filter(Boolean));
         break;
       case '--suppress-range': {
         const raw = value();

package/src/sent-rows.ts

@@ -152,7 +152,7 @@ export function roundRows(
  * the two alike (read from the provider on 2026-10-23: Haiku 5.5 with the drop control, on an enforcing API-key
  * organization and on a subscription account, reported no drop for either, and dropped both replies' blocks when an
  * earlier user message changed). The store's own fields beside them, such as
- * `toolName`, don't reach the provider on membrane's native path, the only one noted (membrane 0.8.0's XML
+ * `toolName`, don't reach the provider on membrane's native path, the only one noted (membrane 0.8.0's and 0.9.0's XML
  * formatter reads `toolName`, and an XML stream is never noted).
  */
 function normalizedResult(block: ContentBlock): unknown {

package/src/supplied-text.ts

@@ -5,7 +5,7 @@
  * a line that reads as the framework's own.
  */
 
-import { CONTEXT_MANAGER_TAGS, MEMBRANE_TAGS, NOTICE_TAG } from './notice-tags.js';
+import { CONTEXT_MANAGER_TAGS, FORMER_NOTICE_TAGS, MEMBRANE_TAGS, NOTICE_TAG } from './notice-tags.js';
 
 /** Every form of line break a reader might take for one: CR LF, CR, LF,
  *  vertical tab, form feed, NEL, and the Unicode line and paragraph separators. */
@@ -27,14 +27,14 @@ const SKIPPED = `[\\s\\p{Cc}${INVISIBLE}]`;
 const tagWord = (word: string): string =>
   [...word].map((c) => (/[\\^$.*+?()[\]{}|/]/.test(c) ? `\\${c}` : c)).join(`${SKIPPED}*`);
 const NOTICE_OPENING = new RegExp(
-  `\\[(?=${SKIPPED}*(?:${[...Object.values(NOTICE_TAG), ...CONTEXT_MANAGER_TAGS, ...MEMBRANE_TAGS].map((tag) => tag.split(' ').map(tagWord).join(`${SKIPPED}+`)).join('|')})(?![\\p{L}\\p{N}]))`,
+  `\\[(?=${SKIPPED}*(?:${[...Object.values(NOTICE_TAG), ...FORMER_NOTICE_TAGS, ...CONTEXT_MANAGER_TAGS, ...MEMBRANE_TAGS].map((tag) => tag.split(' ').map(tagWord).join(`${SKIPPED}+`)).join('|')})(?![\\p{L}\\p{N}]))`,
   'giu',
 );
 
 /**
  * Texts read as one string, joined by line breaks, with a backslash put
  * before the bracket of each opening of a listed tag (NOTICE_TAG,
- * CONTEXT_MANAGER_TAGS, MEMBRANE_TAGS) that hasn't one before it in its own
+ * FORMER_NOTICE_TAGS, CONTEXT_MANAGER_TAGS, MEMBRANE_TAGS) that hasn't one before it in its own
  * text. A text `marks` says false of is read and never changed.
  *
  * Every opening, not only one that starts a line: membrane's XML formatter

package/src/thinking-drops.ts

@@ -34,6 +34,8 @@ export interface StreamThinkingDrops {
   place: (entries: readonly ThinkingBindingEntry[]) => PlacedDrop[];
   recordedAfter?: number;
   branch?: string;
+  /** `StartStreamResult`'s `noteThinkingDropped`. */
+  noteDropped?: (messageIds: readonly MessageId[]) => boolean;
 }
 
 /** A signed block's identity on the wire: a thinking block's signature, a redacted block's data. */