serverless-ircd 0.4.0 → 0.6.0

package/packages/irc-server/tests/actor.test.ts

@@ -1,5 +1,6 @@
 import {
   type AccountStore,
+  type AwayStore,
   CapturingLogger,
   type ChanName,
   type ChanSnapshot,
@@ -11,20 +12,27 @@ import {
   EmptyMotdProvider,
   FakeClock,
   type FloodControlConfig,
+  InMemoryAwayStore,
   InMemoryMessageStore,
+  InMemoryMonitorStore,
   InMemoryNickHistoryStore,
+  InMemoryReadMarkerStore,
   LogLevel,
   type Logger,
   type MessageStore,
+  type MonitorStore,
   type MtlsIdentityProvider,
   type Nick,
   type NickHistoryStore,
   Numerics,
   type RawLine,
+  type ReadMarkerStore,
   type SaslPayload,
   type SaslResult,
   SequentialIdFactory,
   type ServerConfig,
+  type ServerStats,
+  type ServerStatsSnapshot,
   type StoredMessage,
   applyChannelDelta as applyDelta,
   createChannel,
@@ -35,7 +43,9 @@ import {
   toSnapshot,
 } from '@serverless-ircd/irc-core';
 import { describe, expect, it } from 'vitest';
-import { ConnectionActor } from '../src/actor';
+import { ConnectionActor, channelTargetsForMessage } from '../src/actor';
+import type { ActorChannelAccess } from '../src/actor';
+import actorSource from '../src/actor.ts?raw';
 import type { IrcRuntime } from '../src/runtime';
 import { TcpByteStreamTransport, WsTextFrameTransport } from '../src/transport';
 import type { Transport } from '../src/transport';
@@ -54,6 +64,14 @@ class FakeRuntime implements IrcRuntime {
   private readonly channels = new Map<string, ChannelState>();
   private readonly testConnections = new Map<ConnId, ConnectionState>();
   private readonly nicks = new Map<string, ConnId>();
+  /**
+   * Configurable `reloadConfig` result. When set, the next `reloadConfig()`
+   * call returns this value; when `reloadConfigError` is set instead it
+   * throws. Leaving both unset throws so a test that drives `REHASH` without
+   * configuring the fake fails loudly.
+   */
+  reloadConfigResult: ServerConfig | undefined;
+  reloadConfigError: unknown;
 
   constructor(private readonly clock: { now(): number }) {}
 
@@ -64,6 +82,16 @@ class FakeRuntime implements IrcRuntime {
     }
   }
 
+  /**
+   * Drops a connection from the live-connection store while leaving its nick
+   * registered. Simulates the race a reducer sees when `lookupNick` resolves
+   * a nick but `getConnection` returns null (the connection tore down between
+   * the two awaits).
+   */
+  dropConnection(id: ConnId): void {
+    this.testConnections.delete(id);
+  }
+
   // Channel-state access (used by the actor's `channels` dep).
   getOrCreateChannel(name: ChanName): ChannelState {
     const key = name.toLowerCase();
@@ -84,6 +112,9 @@ class FakeRuntime implements IrcRuntime {
   async broadcast(chan: ChanName, lines: RawLine[], except?: ConnId): Promise<void> {
     this.calls.push({ method: 'broadcast', args: [chan, lines, except] });
   }
+  async broadcastWallops(lines: RawLine[], except?: ConnId): Promise<void> {
+    this.calls.push({ method: 'broadcastWallops', args: [lines, except] });
+  }
   async disconnect(conn: ConnId, reason?: string): Promise<void> {
     this.calls.push({ method: 'disconnect', args: [conn, reason] });
   }
@@ -97,14 +128,27 @@ class FakeRuntime implements IrcRuntime {
   }
   async reserveNick(nick: Nick, conn: ConnId): Promise<{ ok: true } | { ok: false }> {
     this.calls.push({ method: 'reserveNick', args: [nick, conn] });
+    const key = nick.toLowerCase();
+    const existing = this.nicks.get(key);
+    if (existing !== undefined && existing !== conn) {
+      return { ok: false };
+    }
+    this.nicks.set(key, conn);
     return { ok: true };
   }
   async changeNick(conn: ConnId, oldNick: Nick, newNick: Nick): Promise<boolean> {
     this.calls.push({ method: 'changeNick', args: [conn, oldNick, newNick] });
+    const newKey = newNick.toLowerCase();
+    const oldKey = oldNick.toLowerCase();
+    const owner = this.nicks.get(newKey);
+    if (owner !== undefined && owner !== conn) return false;
+    this.nicks.set(newKey, conn);
+    if (this.nicks.get(oldKey) === conn) this.nicks.delete(oldKey);
     return true;
   }
   async releaseNick(nick: Nick): Promise<void> {
     this.calls.push({ method: 'releaseNick', args: [nick] });
+    this.nicks.delete(nick.toLowerCase());
   }
   async applyChannelDelta(chan: ChanName, delta: ChannelDelta): Promise<void> {
     this.calls.push({ method: 'applyChannelDelta', args: [chan, delta] });
@@ -156,6 +200,15 @@ class FakeRuntime implements IrcRuntime {
     }
     return out;
   }
+
+  async reloadConfig(): Promise<ServerConfig> {
+    this.calls.push({ method: 'reloadConfig', args: [] });
+    if (this.reloadConfigError !== undefined) throw this.reloadConfigError;
+    if (this.reloadConfigResult === undefined) {
+      throw new Error('FakeRuntime.reloadConfigResult not configured');
+    }
+    return this.reloadConfigResult;
+  }
 }
 
 function makeActor(opts: {
@@ -168,8 +221,14 @@ function makeActor(opts: {
   accounts?: AccountStore;
   mtlsIdentity?: MtlsIdentityProvider;
   history?: NickHistoryStore;
+  stats?: ServerStats;
   operCreds?: ReadonlyArray<{ user: string; password: string }>;
   transport?: Transport;
+  configSource?: string;
+  secure?: boolean;
+  monitor?: MonitorStore;
+  away?: AwayStore;
+  readMarkers?: ReadMarkerStore;
 }): { actor: ConnectionActor; runtime: FakeRuntime; conn: ConnectionState } {
   const clock = opts.clock ?? new FakeClock(1_000);
   const conn = createConnection({ id: 'c1', connectedSince: 0 });
@@ -229,9 +288,27 @@ function makeActor(opts: {
   if (opts.history !== undefined) {
     finalOpts.history = opts.history;
   }
+  if (opts.stats !== undefined) {
+    finalOpts.stats = opts.stats;
+  }
   if (opts.transport !== undefined) {
     finalOpts.transport = opts.transport;
   }
+  if (opts.configSource !== undefined) {
+    finalOpts.configSource = opts.configSource;
+  }
+  if (opts.secure !== undefined) {
+    finalOpts.secure = opts.secure;
+  }
+  if (opts.monitor !== undefined) {
+    finalOpts.monitor = opts.monitor;
+  }
+  if (opts.away !== undefined) {
+    finalOpts.away = opts.away;
+  }
+  if (opts.readMarkers !== undefined) {
+    finalOpts.readMarkers = opts.readMarkers;
+  }
   const actor = new ConnectionActor(finalOpts);
   return { actor, runtime, conn };
 }
@@ -241,23 +318,75 @@ void isChannelTarget;
 
 describe('ConnectionActor — framing', () => {
   it('processes one PRIVMSG in a single text frame into one broadcast', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
     const { actor, runtime } = makeActor({});
+    runtime.addConnection(bobConn);
     // Pre-add the connection to the channel so the broadcast excludes the sender.
     await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
     });
     runtime.calls.length = 0;
 
     await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
 
-    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0]?.args[0]).toBe('#foo');
-    expect(broadcasts[0]?.args[2]).toBe('c1'); // except sender
-    const lines = broadcasts[0]?.args[1] as RawLine[];
+    // Channel PRIVMSG fans out cap-split (msgid): dispatch resolves each
+    // member's caps and sends per-recipient. bob (no msgid cap) gets the bare
+    // line; the sender (c1) is excluded.
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    expect(toBob).toHaveLength(1);
+    expect(toBob[0]?.args[0]).toBe('c2');
+    const lines = toBob[0]?.args[1] as RawLine[];
     expect(lines[0]?.text).toBe(':alice!alice@example.com PRIVMSG #foo :hello');
   });
 
+  it('delivers @msgid=<id> to a msgid-cap peer and the bare line to a non-cap peer', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['msgid']);
+    const carolConn = createConnection({ id: 'c3', connectedSince: 0 });
+    carolConn.nick = 'carol';
+    carolConn.user = 'carol';
+    carolConn.host = 'example.net';
+    carolConn.registration = 'registered';
+    const { actor, runtime } = makeActor({});
+    runtime.addConnection(bobConn);
+    runtime.addConnection(carolConn);
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+        { type: 'add', conn: 'c3', nick: 'carol' },
+      ],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PRIVMSG #foo :hi\r\n');
+
+    // bob (msgid cap) receives the decorated line; carol (no cap) receives
+    // the bare line. The sender (c1) is excluded from both.
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    const toCarol = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c3');
+    expect(toBob).toHaveLength(1);
+    expect(toCarol).toHaveLength(1);
+    const bobLine = (toBob[0]?.args[1] as RawLine[])[0]?.text ?? '';
+    // bob sees the msgid-tagged line; carol sees the bare line. The msgid
+    // value is opaque (an IdFactory nonce), so match the shape not the value.
+    expect(bobLine).toMatch(/^@msgid=nonce-\d+ :alice!alice@example\.com PRIVMSG #foo :hi$/);
+    expect((toCarol[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      ':alice!alice@example.com PRIVMSG #foo :hi',
+    );
+  });
+
   it('tolerates a frame without a trailing CRLF', async () => {
     const { actor, runtime } = makeActor({});
     await actor.receiveTextFrame('PING :tok');
@@ -297,9 +426,18 @@ describe('ConnectionActor — framing', () => {
 
 describe('ConnectionActor — TCP byte-stream transport seam', () => {
   it('two TCP chunks split mid-line produce exactly one PRIVMSG broadcast', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
     const { actor, runtime } = makeActor({ transport: new TcpByteStreamTransport() });
+    runtime.addConnection(bobConn);
     await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
     });
     runtime.calls.length = 0;
 
@@ -309,10 +447,10 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
     expect(runtime.calls).toHaveLength(0);
     await actor.receive('lo\r\n');
 
-    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0]?.args[0]).toBe('#foo');
-    const lines = broadcasts[0]?.args[1] as RawLine[];
+    // Exactly one fanout to bob (cap-split dispatch sends per-recipient).
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    expect(toBob).toHaveLength(1);
+    const lines = toBob[0]?.args[1] as RawLine[];
     expect(lines[0]?.text).toBe(':alice!alice@example.com PRIVMSG #foo :hello');
   });
 
@@ -323,8 +461,17 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
     const wsSetup = makeActor({});
     const tcpSetup = makeActor({ transport: new TcpByteStreamTransport() });
     for (const rt of [wsSetup.runtime, tcpSetup.runtime]) {
+      const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+      bobConn.nick = 'bob';
+      bobConn.user = 'bob';
+      bobConn.host = 'example.org';
+      bobConn.registration = 'registered';
+      rt.addConnection(bobConn);
       await rt.applyChannelDelta('#foo', {
-        memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+        memberships: [
+          { type: 'add', conn: 'c1', nick: 'alice' },
+          { type: 'add', conn: 'c2', nick: 'bob' },
+        ],
       });
     }
     wsSetup.runtime.calls.length = 0;
@@ -337,18 +484,30 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
       await tcpSetup.actor.receive(stream.slice(i, i + 4));
     }
 
-    const wsBroadcast = wsSetup.runtime.calls.filter((c) => c.method === 'broadcast');
-    const tcpBroadcast = tcpSetup.runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(tcpBroadcast).toHaveLength(wsBroadcast.length);
-    expect((tcpBroadcast[0]?.args[1] as RawLine[])[0]?.text).toBe(
-      (wsBroadcast[0]?.args[1] as RawLine[])[0]?.text,
+    // Both transports deliver exactly one fanout to bob with identical bytes.
+    const wsSends = wsSetup.runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    const tcpSends = tcpSetup.runtime.calls.filter(
+      (c) => c.method === 'send' && c.args[0] === 'c2',
+    );
+    expect(tcpSends).toHaveLength(wsSends.length);
+    expect((tcpSends[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      (wsSends[0]?.args[1] as RawLine[])[0]?.text,
     );
   });
 
   it('buffers a partial line across multiple chunks with no loss or duplication', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
     const { actor, runtime } = makeActor({ transport: new TcpByteStreamTransport() });
+    runtime.addConnection(bobConn);
     await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
     });
     runtime.calls.length = 0;
 
@@ -358,13 +517,14 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
     for (const ch of stream) {
       await actor.receive(ch);
     }
-    const sends = runtime.calls.filter((c) => c.method === 'send');
-    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(sends).toHaveLength(2); // PONG :a, PONG :c
-    expect((sends[0]?.args[1] as RawLine[])[0]?.text).toBe('PONG :a');
-    expect((sends[1]?.args[1] as RawLine[])[0]?.text).toBe('PONG :c');
-    expect(broadcasts).toHaveLength(1); // PRIVMSG #foo :b
-    expect((broadcasts[0]?.args[1] as RawLine[])[0]?.text).toBe(
+    const pongs = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(pongs).toHaveLength(2); // PONG :a, PONG :c
+    expect((pongs[0]?.args[1] as RawLine[])[0]?.text).toBe('PONG :a');
+    expect((pongs[1]?.args[1] as RawLine[])[0]?.text).toBe('PONG :c');
+    // PRIVMSG fans out to bob exactly once (cap-split per-recipient send).
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    expect(toBob).toHaveLength(1); // PRIVMSG #foo :b
+    expect((toBob[0]?.args[1] as RawLine[])[0]?.text).toBe(
       ':alice!alice@example.com PRIVMSG #foo :b',
     );
   });
@@ -489,6 +649,50 @@ describe('ConnectionActor — routing', () => {
   });
 });
 
+describe('ConnectionActor — secure transport (user mode `S`)', () => {
+  it('marks the connection state secure when constructed with secure: true', () => {
+    const { conn } = makeActor({ secure: true });
+    expect(conn.secure).toBe(true);
+  });
+
+  it('defaults to insecure when secure is omitted', () => {
+    const { conn } = makeActor({});
+    expect(conn.secure).toBe(false);
+  });
+
+  it('sets user mode `S` at registration when constructed with secure: true', async () => {
+    const { actor, conn } = makeActor({ secure: true });
+    // Reset to pre-registration so the NICK/USER handshake drives welcome.
+    conn.registration = 'pre-registration';
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.nick;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.user;
+
+    await actor.receiveTextFrame('USER alice 0 * :Alice\r\n');
+    await actor.receiveTextFrame('NICK alice\r\n');
+
+    expect(conn.registration).toBe('registered');
+    expect(conn.userModes.tls).toBe(true);
+    expect(conn.secure).toBe(true);
+  });
+
+  it('does not set user mode `S` when constructed without secure', async () => {
+    const { actor, conn } = makeActor({});
+    conn.registration = 'pre-registration';
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.nick;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.user;
+
+    await actor.receiveTextFrame('USER alice 0 * :Alice\r\n');
+    await actor.receiveTextFrame('NICK alice\r\n');
+
+    expect(conn.registration).toBe('registered');
+    expect(conn.userModes.tls).toBe(false);
+  });
+});
+
 describe('ConnectionActor — additional routing', () => {
   it('routes PART through routeMultiChannel (one channel per invocation)', async () => {
     const { actor, runtime } = makeActor({});
@@ -610,7 +814,9 @@ describe('ConnectionActor — additional routing', () => {
     });
     runtime.calls.length = 0;
     await actor.receiveTextFrame('NOTICE #foo :note\r\n');
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(1);
+    // NOTICE channel fanout is cap-split (msgid) so dispatch resolves via
+    // getChannelSnapshot rather than the fast-path broadcast.
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(1);
   });
 
   it('routes TAGMSG to a channel broadcast (never 421) when message-tags cap is present', async () => {
@@ -671,8 +877,8 @@ describe('ConnectionActor — additional routing', () => {
     });
     runtime.calls.length = 0;
     await actor.receiveTextFrame('PRIVMSG #foo,bob :hi\r\n');
-    // One broadcast (channel) + one sendToNick (user).
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(1);
+    // One channel fanout (cap-split → getChannelSnapshot) + one sendToNick.
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(1);
     expect(runtime.calls.filter((c) => c.method === 'sendToNick')).toHaveLength(1);
   });
 
@@ -785,6 +991,24 @@ describe('ConnectionActor — additional routing', () => {
     }
   });
 
+  it('routes WHOIS with no parameter through whoisReducer (just 318, never 421)', async () => {
+    // Covers the `targetNick.length > 0` false branch in routeWhois:
+    // a bare `WHOIS` resolves no target and defers to the reducer, which
+    // emits only the 318 end marker.
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WHOIS\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines.some((l) => l.text.includes(' 318 '))).toBe(true);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
   it('routes WHOWAS of a quit nick through whowasReducer (314 + 369, never 421)', async () => {
     const history = new InMemoryNickHistoryStore(new FakeClock(1_000));
     history.record({
@@ -968,6 +1192,34 @@ describe('ConnectionActor — additional routing', () => {
     }
   });
 
+  it('routes SETNAME :<realname> through setnameReducer, mutating state.realname (never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('SETNAME :New Name\r\n');
+
+    expect(conn.realname).toBe('New Name');
+    // Silent update: no Send reply and no broadcast, just the state mutation.
+    expect(runtime.calls).toHaveLength(0);
+  });
+
+  it('routes SETNAME with no param to 461 (never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('SETNAME\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toBe(':irc.example.com 461 alice SETNAME :Not enough parameters');
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
   it('routes OPER with matching creds through operReducer (381, never 421)', async () => {
     const { actor, runtime, conn } = makeActor({
       operCreds: [{ user: 'alice', password: 'secret' }],
@@ -1046,6 +1298,260 @@ describe('ConnectionActor — additional routing', () => {
     expect(lines[0]?.text).toBe(':irc.example.com 421 alice :Unknown command');
   });
 
+  it('routes WALLOPS from an oper through wallopsReducer (broadcastWallops, never 421)', async () => {
+    const { actor, runtime } = makeActor({
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WALLOPS :reboot in 5\r\n');
+
+    // Oper happy path: one broadcastWallops runtime call, carrying the
+    // oper-attributed line and excepting the sender.
+    const wallops = runtime.calls.filter((c) => c.method === 'broadcastWallops');
+    expect(wallops).toHaveLength(1);
+    const lines = wallops[0]?.args[0] as RawLine[];
+    const except = wallops[0]?.args[1];
+    expect(lines[0]?.text).toBe(':alice!alice@example.com WALLOPS :reboot in 5');
+    expect(except).toBe('c1');
+    // Critical: WALLOPS must reach the reducer, never the 421 fallthrough.
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('routes WALLOPS from a non-oper through wallopsReducer (481, never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WALLOPS :hi\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 481 ');
+    // A non-oper must never trigger global fanout.
+    expect(runtime.calls.some((c) => c.method === 'broadcastWallops')).toBe(false);
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('routes WALLOPS with no message through wallopsReducer (412, never 421)', async () => {
+    const { actor, runtime } = makeActor({
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WALLOPS\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 412 ');
+    expect(runtime.calls.some((c) => c.method === 'broadcastWallops')).toBe(false);
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('routes REHASH from an oper through rehashReducer (382, never 421) and re-invokes the loader', async () => {
+    const { actor, runtime, conn } = makeActor({
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
+      configSource: 'KV',
+    });
+    runtime.reloadConfigResult = {
+      serverName: 'irc.reloaded.test',
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    };
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('REHASH\r\n');
+
+    // 382 emitted, never 421.
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const firstLines = sends[0]?.args[1] as RawLine[];
+    expect(firstLines[0]?.text).toBe(':irc.example.com 382 alice :Rehashing from KV');
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+    // The bound loader was actually re-invoked.
+    expect(runtime.calls.some((c) => c.method === 'reloadConfig')).toBe(true);
+    void conn;
+    // The live config was swapped: a subsequent REHASH's 382 carries the
+    // reloaded server name (ctx is rebuilt from the swapped serverConfig).
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('REHASH\r\n');
+    const secondSends = runtime.calls.filter((c) => c.method === 'send');
+    const secondLines = secondSends[0]?.args[1] as RawLine[];
+    expect(secondLines[0]?.text).toBe(':irc.reloaded.test 382 alice :Rehashing from KV');
+  });
+
+  it('routes REHASH from a non-oper through rehashReducer (481) and does NOT reload', async () => {
+    const { actor, runtime } = makeActor({ configSource: 'KV' });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('REHASH\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 481 ');
+    // Critical: a non-oper must not trigger a config reload.
+    expect(runtime.calls.some((c) => c.method === 'reloadConfig')).toBe(false);
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('keeps the oper connected and retains the prior config when the loader rejects', async () => {
+    const { actor, runtime } = makeActor({
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
+      configSource: 'KV',
+    });
+    runtime.reloadConfigError = new Error('store unreachable');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('REHASH\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    // Optimistic 382 + graceful error-suffixed 382; oper NOT disconnected.
+    expect(sends).toHaveLength(2);
+    const lines = [
+      ...((sends[0]?.args[1] as RawLine[]) ?? []),
+      ...((sends[1]?.args[1] as RawLine[]) ?? []),
+    ];
+    expect(lines[0]?.text).toBe(':irc.example.com 382 alice :Rehashing from KV');
+    expect(lines[1]?.text).toBe(
+      ':irc.example.com 382 alice :Rehashing from KV failed: store unreachable',
+    );
+    // The oper is never disconnected on a reload failure.
+    expect(runtime.calls.some((c) => c.method === 'disconnect')).toBe(false);
+    // Prior config retained: a subsequent command still sees the old name.
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('REHASH\r\n');
+    const retrySends = runtime.calls.filter((c) => c.method === 'send');
+    const retryLines = retrySends[0]?.args[1] as RawLine[];
+    expect(retryLines[0]?.text).toBe(':irc.example.com 382 alice :Rehashing from KV');
+  });
+
+  it('stringifies a non-Error rejection in the graceful 382 suffix', async () => {
+    const { actor, runtime } = makeActor({
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
+      configSource: 'KV',
+    });
+    // A non-Error throw exercises the `String(err)` branch of the suffix
+    // formatting (vs. `err.message` for a real Error).
+    runtime.reloadConfigError = 'totally broken';
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('REHASH\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(2);
+    const errorLine = (sends[1]?.args[1] as RawLine[])[0];
+    expect(errorLine?.text).toBe(
+      ':irc.example.com 382 alice :Rehashing from KV failed: totally broken',
+    );
+    expect(runtime.calls.some((c) => c.method === 'disconnect')).toBe(false);
+  });
+
+  it('falls back to "*" in the graceful 382 suffix when the oper has no nick', async () => {
+    // Covers the `this.state.nick ?? '*'` fallback in routeRehash's catch
+    // block. Oper state without a nick is unusual (registration normally
+    // sets the nick before OPER can succeed) but the actor must still
+    // format a valid numeric addressed to "*" rather than crash.
+    const { actor, runtime, conn } = makeActor({
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
+      configSource: 'KV',
+    });
+    // Clear the nick post-construction (exactOptionalPropertyTypes forbids
+    // assigning undefined; delete is the idiomatic way to unset an optional).
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
+    delete conn.nick;
+    runtime.reloadConfigError = new Error('store unreachable');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('REHASH\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        // Addressed to "*" (no nick), never 421.
+        expect(line.text).toContain(' 382 * ');
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
   it('covers JOIN with no params (splitCsv("") → [])', async () => {
     const { actor, runtime } = makeActor({});
     await actor.receiveTextFrame('JOIN\r\n');
@@ -1312,10 +1818,11 @@ describe('ConnectionActor — flood control', () => {
       await actor.receiveTextFrame('PRIVMSG #foo :flood\r\n');
     }
 
-    // Disabled → every frame reaches the inner reducer and broadcasts; the
-    // close path is never invoked.
+    // Disabled → every frame reaches the inner reducer and fans out; the
+    // close path is never invoked. Channel PRIVMSG dispatches cap-split
+    // (msgid) via getChannelSnapshot, once per accepted message.
     expect(runtime.calls.filter((c) => c.method === 'disconnect')).toHaveLength(0);
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(20);
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(20);
   });
 
   it('does not let an interleaved PING advance the bucket (control-plane exemption plumbed through)', async () => {
@@ -1552,19 +2059,40 @@ describe('ConnectionActor — CHATHISTORY', () => {
     expect(sends).toHaveLength(0);
   });
 
-  it('records a channel PRIVMSG into the bound store (JOIN auto-playback data source)', async () => {
+  it('handles a missing target parameter gracefully (no 421)', async () => {
+    // Covers the `target !== undefined` false branch in routeChathistory:
+    // a CHATHISTORY message with only the subcommand and no target param.
+    // peekChannel is not called; the reducer surfaces the param error.
     const store = new InMemoryMessageStore();
-    const { actor, runtime } = makeActor({ messages: store });
-    await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    const { actor, runtime } = makeActor({
+      conn: { caps: CHATHISTORY_CAPS },
+      messages: store,
     });
     runtime.calls.length = 0;
 
-    await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
+    await actor.receiveTextFrame('CHATHISTORY LATEST\r\n');
 
-    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
-    expect(recorded).toHaveLength(1);
-    expect(recorded[0]?.text).toBe('hello');
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('records a channel PRIVMSG into the bound store (JOIN auto-playback data source)', async () => {
+    const store = new InMemoryMessageStore();
+    const { actor, runtime } = makeActor({ messages: store });
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0]?.text).toBe('hello');
     expect(recorded[0]?.command).toBe('PRIVMSG');
     expect(recorded[0]?.nick).toBe('alice');
   });
@@ -1578,8 +2106,9 @@ describe('ConnectionActor — CHATHISTORY', () => {
 
     await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
 
-    // Broadcast still happens (the message is delivered live)…
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(1);
+    // Broadcast still happens (the message is delivered live). Channel
+    // PRIVMSG fans out cap-split (msgid) via getChannelSnapshot…
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(1);
     // …but there is no store to record into.
   });
 });
@@ -1850,6 +2379,30 @@ describe('ConnectionActor — server-info commands (VERSION/TIME/ADMIN/INFO/USER
     expect(lines[0]?.text).toContain('bob*=-bobuser@bobhost');
   });
 
+  it('USERHOST treats a nick whose conn tore down mid-resolve as offline', async () => {
+    // Covers the `conn === null` branch in routeUserhost: lookupNick
+    // resolves but the live connection is gone (race between the two
+    // awaits). The reducer must treat the nick as offline rather than
+    // crash.
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.user = 'bobuser';
+    bobState.host = 'bobhost';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.dropConnection('c2'); // race: nick map lags the connection map
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('USERHOST bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 302 ');
+    expect(lines[0]?.text).not.toContain('bobuser@bobhost');
+  });
+
   it('routes ISON resolving online nicks (303, never 421)', async () => {
     const { actor, runtime, conn } = makeActor({});
     const bobState = createConnection({ id: 'c2', connectedSince: 0 });
@@ -1885,4 +2438,1932 @@ describe('ConnectionActor — server-info commands (VERSION/TIME/ADMIN/INFO/USER
     const lines = sends[0]?.args[1] as RawLine[];
     expect(lines[0]?.text).toContain(':Bob');
   });
+
+  it('skips a nick whose connection has torn down between lookupNick and getConnection (race)', async () => {
+    // Covers the `conn?.nick !== undefined` false branch in routeIson:
+    // lookupNick resolves because the nick map still holds the entry, but
+    // the connection is already gone from the live-connection store.
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    // Drop the live connection but leave the nick registered.
+    runtime.dropConnection('c2');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('ISON bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends[0]?.args[1] as RawLine[];
+    // 303 reply lists no nicks (bob was dropped mid-resolve).
+    expect(lines[0]?.text).toContain(' 303 ');
+    expect(lines[0]?.text).not.toContain('bob');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+});
+
+describe('ConnectionActor — KILL (oper force-disconnect)', () => {
+  it('routes an oper KILL through killReducer, invoking runtime.disconnect for the target (never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.user = 'bob';
+    bobState.host = 'example.com';
+    bobState.realname = 'Bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('KILL bob :flooding\r\n');
+
+    const disconnects = runtime.calls.filter((c) => c.method === 'disconnect');
+    expect(disconnects).toHaveLength(1);
+    expect(disconnects[0]?.args[0]).toBe('c2');
+    expect(disconnects[0]?.args[1]).toBe('Killed (alice (flooding))');
+    // Critical: never 421 for a routed KILL.
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('emits 481 ERR_NOPRIVILEGES (never 421, no disconnect) when the sender is not an oper', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('KILL bob :flooding\r\n');
+
+    const disconnects = runtime.calls.filter((c) => c.method === 'disconnect');
+    expect(disconnects).toHaveLength(0);
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 481 ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('emits 401 ERR_NOSUCHNICK for an unknown target (never 421, no disconnect)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('KILL ghost :nope\r\n');
+
+    const disconnects = runtime.calls.filter((c) => c.method === 'disconnect');
+    expect(disconnects).toHaveLength(0);
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 401 ');
+    expect(lines[0]?.text).toContain(' ghost ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when the comment is missing (never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('KILL bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 461 ');
+    expect(lines[0]?.text).toContain(' KILL ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('emits 461 when an oper sends KILL with no params at all (never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('KILL\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 461 ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('treats a nick whose connection vanished mid-route as unknown (401, never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    // lookupNick will still resolve bob, but getConnection returns null.
+    runtime.dropConnection('c2');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('KILL bob :flooding\r\n');
+
+    const disconnects = runtime.calls.filter((c) => c.method === 'disconnect');
+    expect(disconnects).toHaveLength(0);
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 401 ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+});
+
+describe('ConnectionActor — TRACE (routing diagnostics)', () => {
+  it('emits the 262 terminator and never 421 for TRACE with no target', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('TRACE\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines[allLines.length - 1]?.text).toContain(' 262 ');
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('routes oper TRACE <nick> through traceReducer (205 + 262, never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.user = 'bob';
+    bobState.host = 'example.com';
+    bobState.realname = 'Bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('TRACE bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const firstBatch = sends[0]?.args[1] as RawLine[];
+    expect(firstBatch[0]?.text).toContain(' 205 ');
+    expect(firstBatch[0]?.text).toContain(' bob ');
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines[allLines.length - 1]?.text).toContain(' 262 ');
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('emits 402 ERR_NOSUCHSERVER for a non-local server target (never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('TRACE remote.example.org\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 402 ');
+    expect(lines[0]?.text).toContain(' remote.example.org ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('treats the local server name as the local server (no 402, never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('TRACE irc.example.com\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines[allLines.length - 1]?.text).toContain(' 262 ');
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 402 ');
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('treats a nick whose connection vanished mid-route as the no-target path (262, never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.userModes.oper = true;
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    // lookupNick resolves bob, but getConnection returns null.
+    runtime.dropConnection('c2');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('TRACE bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines[allLines.length - 1]?.text).toContain(' 262 ');
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+});
+
+describe('ConnectionActor — dropped S2S and obsolete verbs', () => {
+  // These verbs are formally dropped (not deferred):
+  //   - S2S (PLAN non-goal): CONNECT, SQUIT, LINKS
+  //   - RFC 2812 obsolete (never widely implemented): SERVICE, SUMMON, USERS
+  // They keep returning `421 ERR_UNKNOWNCOMMAND` (the correct response for an
+  // unimplemented command); the regression guard below pins that behaviour so
+  // a future accidental `case` label is caught.
+  const droppedVerbs = ['CONNECT', 'SQUIT', 'LINKS', 'SERVICE', 'SUMMON', 'USERS'];
+
+  it.each(droppedVerbs)('emits 421 for the dropped verb %s', async (verb) => {
+    const { actor, runtime } = makeActor({});
+    await actor.receiveTextFrame(`${verb} ignored-arg\r\n`);
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 421 ');
+    expect(lines[0]?.text).toContain(` ${verb} `);
+  });
+
+  it('documents the deliberate drop at the default branch (no "deferred" framing)', () => {
+    // The default branch must explain these verbs are deliberately dropped,
+    // not still "deferred" (the framing removed by the S2S / obsolete-verb
+    // drop).
+    expect(actorSource).toMatch(/S2S/);
+    expect(actorSource).toMatch(/non-goal/);
+    expect(actorSource).toMatch(/obsolete/i);
+    // The CONNECT/SQUIT/LINKS and SERVICE/SUMMON/USERS lines must not be
+    // framed as deferred.
+    expect(actorSource).not.toMatch(/deferred LINKS/);
+    expect(actorSource).not.toMatch(/deferred SQUIT/);
+    expect(actorSource).not.toMatch(/deferred SERVICE/);
+    expect(actorSource).not.toMatch(/deferred SUMMON/);
+    expect(actorSource).not.toMatch(/deferred USERS/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// FakeServerStats + helpers
+// ---------------------------------------------------------------------------
+
+/** Stats backend double that returns a fixed snapshot. */
+class FakeServerStats implements ServerStats {
+  constructor(readonly snapshot: ServerStatsSnapshot) {}
+  async getStats(): Promise<ServerStatsSnapshot> {
+    return this.snapshot;
+  }
+}
+
+const populatedSnapshot: ServerStatsSnapshot = {
+  users: 4,
+  invisible: 1,
+  opers: 2,
+  unknownConnections: 1,
+  channels: 3,
+  servers: 1,
+  localConns: 6,
+  globalConns: 6,
+  maxLocalConns: 9,
+  maxGlobalConns: 9,
+  uptimeStartedAt: 0,
+};
+
+// ---------------------------------------------------------------------------
+// LUSERS actor routing
+// ---------------------------------------------------------------------------
+
+describe('ConnectionActor — LUSERS (network statistics)', () => {
+  it('emits 251–255 from the bound ServerStats snapshot and never 421', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('LUSERS\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    const codes = allLines.map((l) => Number(l.text.split(' ')[1]));
+    expect(codes).toContain(251);
+    expect(codes).toContain(252);
+    expect(codes).toContain(253);
+    expect(codes).toContain(254);
+    expect(codes).toContain(255);
+    expect(codes).toContain(265);
+    expect(codes).toContain(266);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('awaits the stats backend before invoking the reducer (async getStats)', async () => {
+    let calls = 0;
+    const stats: ServerStats = {
+      async getStats() {
+        calls++;
+        return populatedSnapshot;
+      },
+    };
+    const { actor, runtime } = makeActor({ stats });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('LUSERS\r\n');
+
+    expect(calls).toBe(1);
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    // The 251 line carries the snapshot's user/invisible/server counts.
+    expect(allLines.some((l) => l.text.includes(' 251 ') && l.text.includes('4 users'))).toBe(true);
+  });
+
+  it('emits 402 ERR_NOSUCHSERVER for a non-local server target (never 421)', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('LUSERS * remote.example.org\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 402 ');
+    expect(lines[0]?.text).toContain(' remote.example.org ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('treats the local server name as the local server (no 402, never 421)', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('LUSERS * irc.example.com\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 402 ');
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('falls back to a zero-count snapshot when no stats backend is bound (never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('LUSERS\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    // 251 still emitted with zero counts; 252/253/254 suppressed (zero).
+    expect(allLines.some((l) => l.text.includes(' 251 '))).toBe(true);
+    expect(allLines.some((l) => l.text.includes(' 255 '))).toBe(true);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 252 ');
+      expect(line.text).not.toContain(' 253 ');
+      expect(line.text).not.toContain(' 254 ');
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// STATS actor routing
+// ---------------------------------------------------------------------------
+
+describe('ConnectionActor — STATS (server statistics)', () => {
+  it('routes STATS u to a 242 + 219 reply (never 421)', async () => {
+    const clock = new FakeClock(5_000);
+    const { actor, runtime } = makeActor({
+      stats: new FakeServerStats({ ...populatedSnapshot, uptimeStartedAt: 0 }),
+      clock,
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('STATS u\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines.some((l) => l.text.includes(' 242 '))).toBe(true);
+    expect(allLines[allLines.length - 1]?.text).toContain(' 219 ');
+    expect(allLines[allLines.length - 1]?.text).toContain(' u ');
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('routes STATS l to a 211 + 219 reply (never 421)', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('STATS l\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines.some((l) => l.text.includes(' 211 '))).toBe(true);
+    expect(allLines[allLines.length - 1]?.text).toContain(' 219 ');
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('routes an unknown STATS letter to a charybdis-style empty body + 219 (never 421)', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('STATS z\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 219 ');
+    expect(lines[0]?.text).toContain(' z ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('emits 402 ERR_NOSUCHSERVER for a non-local server target (never 421)', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('STATS u remote.example.org\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 402 ');
+    expect(lines[0]?.text).toContain(' remote.example.org ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('treats the local server name as the local server (no 402, never 421)', async () => {
+    const { actor, runtime } = makeActor({ stats: new FakeServerStats(populatedSnapshot) });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('STATS u irc.example.com\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 402 ');
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+});
+
+// ============================================================================
+// channelTargetsForMessage — pure dispatch table for prefetch
+// ============================================================================
+
+describe('channelTargetsForMessage', () => {
+  it('returns the channel list for each channel-touching verb', () => {
+    // Covers every case clause in the switch.
+    expect(channelTargetsForMessage({ command: 'PART', params: ['#a,#b'], tags: {} })).toEqual([
+      '#a',
+      '#b',
+    ]);
+    expect(channelTargetsForMessage({ command: 'TOPIC', params: ['#foo'], tags: {} })).toEqual([
+      '#foo',
+    ]);
+    expect(channelTargetsForMessage({ command: 'NAMES', params: ['#foo'], tags: {} })).toEqual([
+      '#foo',
+    ]);
+    expect(
+      channelTargetsForMessage({ command: 'KICK', params: ['#foo', 'bob'], tags: {} }),
+    ).toEqual(['#foo']);
+    expect(channelTargetsForMessage({ command: 'MODE', params: ['#foo', '+t'], tags: {} })).toEqual(
+      ['#foo'],
+    );
+    expect(
+      channelTargetsForMessage({ command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} }),
+    ).toEqual(['#foo']);
+    expect(
+      channelTargetsForMessage({ command: 'NOTICE', params: ['#foo', 'hi'], tags: {} }),
+    ).toEqual(['#foo']);
+    expect(channelTargetsForMessage({ command: 'TAGMSG', params: ['#foo'], tags: {} })).toEqual([
+      '#foo',
+    ]);
+  });
+
+  it('returns the JOIN channel(s), skipping the `JOIN 0` sentinel', () => {
+    expect(channelTargetsForMessage({ command: 'JOIN', params: ['#a,#b'], tags: {} })).toEqual([
+      '#a',
+      '#b',
+    ]);
+    // `JOIN 0` is the part-everything sentinel; reducer reads
+    // joinedChannels directly, so no prefetch target.
+    expect(channelTargetsForMessage({ command: 'JOIN', params: ['0'], tags: {} })).toEqual([]);
+  });
+
+  it('reads the channel from the SECOND param for INVITE (<nick> <channel>)', () => {
+    expect(
+      channelTargetsForMessage({ command: 'INVITE', params: ['bob', '#room'], tags: {} }),
+    ).toEqual(['#room']);
+  });
+
+  it('returns an empty list for commands with no channel target', () => {
+    // Covers the default branch (PING, NICK, QUIT, …).
+    expect(channelTargetsForMessage({ command: 'PING', params: ['t'], tags: {} })).toEqual([]);
+    expect(channelTargetsForMessage({ command: 'NICK', params: ['alice'], tags: {} })).toEqual([]);
+  });
+
+  it('ignores non-channel targets in the comma-split list', () => {
+    // A PRIVMSG to a nick (not a #channel) yields no prefetch targets.
+    expect(
+      channelTargetsForMessage({ command: 'PRIVMSG', params: ['bob,#foo', 'hi'], tags: {} }),
+    ).toEqual(['#foo']);
+  });
+
+  it('handles a missing first parameter gracefully', () => {
+    // Defensive: params[0] is absent → empty string → empty split.
+    expect(channelTargetsForMessage({ command: 'PART', params: [], tags: {} })).toEqual([]);
+  });
+
+  it('returns an empty list for JOIN / INVITE when their channel param is absent', () => {
+    // Covers the `?? ''` fallbacks on the JOIN and INVITE branches.
+    expect(channelTargetsForMessage({ command: 'JOIN', params: [], tags: {} })).toEqual([]);
+    expect(channelTargetsForMessage({ command: 'INVITE', params: ['bob'], tags: {} })).toEqual([]);
+  });
+});
+
+// ============================================================================
+// prefetchChannelState — refresh hook for distributed runtimes
+// ============================================================================
+
+describe('ConnectionActor — prefetchChannelState (refresh hook)', () => {
+  it('invokes refreshChannel for each channel-targeted command when the hook is bound', async () => {
+    // Covers the body of prefetchChannelState (refresh !== undefined path)
+    // and the call to channelTargetsForMessage for PART. Distributed
+    // runtimes (CF ChannelDO) wire `refreshChannel`; the in-memory fake
+    // does not, so we inject a custom channel-access here.
+    const refreshed: string[] = [];
+    const channelsAccess: ActorChannelAccess = {
+      getOrCreateChannel: (name: ChanName) => {
+        const key = name.toLowerCase();
+        const existing = fakeChannels.get(key);
+        if (existing) return existing;
+        const chan = createChannel({ name, nameLower: key, createdAt: 0 });
+        fakeChannels.set(key, chan);
+        return chan;
+      },
+      refreshChannel: async (name: ChanName) => {
+        refreshed.push(name);
+      },
+    };
+    const fakeChannels = new Map<string, ChannelState>();
+    const { actor, runtime } = makeActor({});
+    // Swap in the channel access with the refresh hook.
+    (actor as unknown as { channels: ActorChannelAccess }).channels = channelsAccess;
+    // Pre-add membership so PART can find the channel.
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PART #foo :leaving\r\n');
+
+    expect(refreshed).toEqual(['#foo']);
+  });
+
+  it('is a no-op when refreshChannel is not bound (in-memory runtime)', async () => {
+    // Covers the early-return path. The default FakeRuntime has no
+    // refreshChannel; the actor must not throw and the PART still routes.
+    const { actor, runtime } = makeActor({});
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await expect(actor.receiveTextFrame('PART #foo\r\n')).resolves.toBeUndefined();
+    expect(runtime.calls.some((c) => c.method === 'applyChannelDelta')).toBe(true);
+  });
+
+  it('skips refresh for commands with no channel target (empty targets list)', async () => {
+    // Covers the `targets.length === 0` early-return in
+    // prefetchChannelState: refreshChannel is bound but the command (PING)
+    // has no channel argument, so the refresh hook must not fire.
+    const refreshed: string[] = [];
+    const { actor, runtime } = makeActor({});
+    const accessWithRefresh: ActorChannelAccess = {
+      getOrCreateChannel: (name: ChanName) => runtime.getOrCreateChannel(name),
+      refreshChannel: async (name: ChanName) => {
+        refreshed.push(name);
+      },
+    };
+    (actor as unknown as { channels: ActorChannelAccess }).channels = accessWithRefresh;
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PING :token\r\n');
+
+    expect(refreshed).toEqual([]);
+  });
+});
+
+// ============================================================================
+// peekChannel — getChannel fallback
+// ============================================================================
+
+describe('ConnectionActor — peekChannel fallback', () => {
+  it('falls back to getOrCreateChannel when getChannel is not implemented', async () => {
+    // Covers the fallback branch in peekChannel: a channel-access object
+    // that omits `getChannel` (the legacy shape before peek-only lookup) must
+    // still resolve CHATHISTORY targets via getOrCreateChannel. The actor
+    // is reconstructed with a wrapper that delegates everything except
+    // getChannel (which is intentionally absent).
+    const store = new InMemoryMessageStore();
+    const { actor, runtime } = makeActor({
+      conn: {
+        caps: new Set<string>(['draft/chathistory', 'server-time', 'message-tags', 'batch']),
+      },
+      messages: store,
+    });
+    // Replace the channel access with a wrapper that lacks getChannel.
+    // The actor holds `channels` by reference, so this swap takes effect.
+    const accessWithoutGetChannel: ActorChannelAccess = {
+      getOrCreateChannel: (name: ChanName) => runtime.getOrCreateChannel(name),
+    };
+    (actor as unknown as { channels: ActorChannelAccess }).channels = accessWithoutGetChannel;
+    // Pre-create the channel so getOrCreateChannel returns it, and seed
+    // one stored message so the reducer has something to replay.
+    runtime.getOrCreateChannel('#foo');
+    store.record({
+      msgid: 'm1',
+      time: 1_000,
+      chan: '#foo',
+      command: 'PRIVMSG',
+      nick: 'bob',
+      user: 'bob',
+      host: 'ex.org',
+      text: 'hello',
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('CHATHISTORY LATEST #foo * 1\r\n');
+
+    // The reducer should be reached (no 421) and emit a BATCH frame,
+    // proving peekChannel resolved the channel via the getOrCreateChannel
+    // fallback rather than 403/421.
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(1);
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+      expect(line.text).not.toContain(' 403 ');
+    }
+    expect(allLines.some((l) => l.text.startsWith('BATCH +'))).toBe(true);
+  });
+});
+
+// ============================================================================
+// WHOIS — channel-list branch (target with joinedChannels)
+// ============================================================================
+
+describe('ConnectionActor — WHOIS channel list', () => {
+  it("includes the target's joined channels in the 319 reply", async () => {
+    // Covers the Array.from(target.joinedChannels, ...) branch in
+    // routeWhois: when the target has joinedChannels, each is resolved to
+    // a ChannelState and passed to whoisReducer for the 319 list.
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.user = 'bob';
+    bobState.host = 'example.com';
+    bobState.realname = 'Bob';
+    bobState.registration = 'registered';
+    bobState.joinedChannels.add('#room1');
+    bobState.joinedChannels.add('#room2');
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    // Materialize the channels so getOrCreateChannel resolves them.
+    await runtime.applyChannelDelta('#room1', {
+      memberships: [{ type: 'add', conn: 'c2', nick: 'bob' }],
+    });
+    await runtime.applyChannelDelta('#room2', {
+      memberships: [{ type: 'add', conn: 'c2', nick: 'bob' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WHOIS bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    // 319 RPL_WHOISCHANNELS lists at least one of the target's channels.
+    const chanLines = allLines.filter((l) => l.text.includes(' 319 '));
+    expect(chanLines.length).toBeGreaterThan(0);
+    const joined = chanLines.some((l) => l.text.includes('#room1') || l.text.includes('#room2'));
+    expect(joined).toBe(true);
+  });
+
+  it('treats a target whose conn tore down mid-resolve as offline (401 + 318, never 421)', async () => {
+    // Covers the `?? undefined` branch in routeWhois: lookupNick resolved
+    // the nick but getConnection returned null (race). The reducer must
+    // emit the unknown-nick path (401 + 318), not crash.
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.dropConnection('c2');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WHOIS bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const allLines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(allLines.some((l) => l.text.includes(' 401 '))).toBe(true);
+    expect(allLines.some((l) => l.text.includes(' 318 '))).toBe(true);
+    for (const line of allLines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+});
+
+// ============================================================================
+// MONITOR (IRCv3) — synchronous reducer + async push hook
+// ============================================================================
+
+describe('ConnectionActor — MONITOR (synchronous reducer + async push hook)', () => {
+  /**
+   * Builds two actors (alice on c1, bob on c2) sharing a single
+   * {@link InMemoryMonitorStore} and the same FakeRuntime. Mirrors the
+   * production wiring where every ConnectionActor in a deployment shares
+   * one monitor store.
+   */
+  function makeMonitorPair(): {
+    alice: ConnectionActor;
+    bob: ConnectionActor;
+    runtime: FakeRuntime;
+    aliceState: ConnectionState;
+    bobState: ConnectionState;
+    monitor: InMemoryMonitorStore;
+  } {
+    const clock = new FakeClock(1_000);
+    const aliceState = createConnection({ id: 'c1', connectedSince: 0 });
+    aliceState.nick = 'alice';
+    aliceState.user = 'alice';
+    aliceState.host = 'example.com';
+    aliceState.realname = 'Alice';
+    aliceState.registration = 'registered';
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.user = 'bob';
+    bobState.host = 'example.com';
+    bobState.realname = 'Bob';
+    // bob is pre-registration so we can drive him through NICK to test the
+    // reserve-time 730 push.
+    const runtime = new FakeRuntime(clock);
+    runtime.addConnection(aliceState);
+    const monitor = new InMemoryMonitorStore();
+    const serverConfig: ServerConfig = {
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    };
+    const ids = new SequentialIdFactory();
+    type ActorOpts = ConstructorParameters<typeof ConnectionActor>[0];
+    type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+    const aliceOpts: Mutable<ActorOpts> = {
+      state: aliceState,
+      runtime,
+      channels: runtime,
+      serverConfig,
+      clock,
+      ids,
+      motd: EmptyMotdProvider,
+      monitor,
+    };
+    const bobOpts: Mutable<ActorOpts> = {
+      state: bobState,
+      runtime,
+      channels: runtime,
+      serverConfig,
+      clock,
+      ids,
+      motd: EmptyMotdProvider,
+      monitor,
+    };
+    return {
+      alice: new ConnectionActor(aliceOpts),
+      bob: new ConnectionActor(bobOpts),
+      runtime,
+      aliceState,
+      bobState,
+      monitor,
+    };
+  }
+
+  it('MONITOR + offline nick emits 731 RPL_MONOFFLINE (synchronous path)', async () => {
+    const { alice, runtime } = makeMonitorPair();
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+  });
+
+  it('MONITOR + online nick emits 730 RPL_MONONLINE (synchronous path)', async () => {
+    // Drive bob through the actor's NICK reservation so the dispatch hook
+    // fires monitor.onNickOnline('bob'). Then alice's MONITOR + bob sees
+    // him online via the runtime nick registry (resolveOnlineMap) and
+    // emits 730 synchronously.
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await bob.receiveTextFrame('NICK bob\r\n');
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 730 alice :bob')).toBe(true);
+  });
+
+  it('alice MONITOR + bob (offline) then bob connects → 730 pushed to alice', async () => {
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    // alice subscribes to bob while bob is offline.
+    runtime.calls.length = 0;
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    // Sanity: 731 emitted for the offline state.
+    {
+      const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+      const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+      expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+    }
+
+    // bob now registers — NICK bob reserves the nick. The dispatch hook
+    // fires monitor.onNickOnline('bob'), and bob's actor's post-dispatch
+    // drain emits a Send to alice's connId.
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+    await bob.receiveTextFrame('NICK bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 730 alice :bob')).toBe(true);
+  });
+
+  it('bob quits after being monitored → 731 pushed to alice', async () => {
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    // Bring bob online through the actor so the dispatch hook fires
+    // monitor.onNickOnline('bob') on reserveNick.
+    runtime.addConnection(bobState);
+    await bob.receiveTextFrame('NICK bob\r\n');
+    runtime.calls.length = 0;
+    // alice subscribes while bob is online.
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+
+    await bob.receiveTextFrame('QUIT :gone\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+  });
+
+  it('unmatched MONITOR subcommand yields 461 (never 421)', async () => {
+    const { alice, runtime } = makeMonitorPair();
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR Z\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 461 '))).toBe(true);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('MONITOR L lists the watchlist then 733 terminator', async () => {
+    const { alice, runtime } = makeMonitorPair();
+    await alice.receiveTextFrame('MONITOR + bob,carol\r\n');
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR L\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 732 alice :bob')).toBe(true);
+    expect(lines.some((l) => l.text === ':irc.example.com 732 alice :carol')).toBe(true);
+    expect(lines.some((l) => l.text === ':irc.example.com 733 alice :End of MONITOR list')).toBe(
+      true,
+    );
+  });
+
+  it('MONITOR C empties the watchlist silently', async () => {
+    const { alice, runtime, aliceState } = makeMonitorPair();
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    expect(aliceState.monitorList?.has('bob')).toBe(true);
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR C\r\n');
+
+    expect(aliceState.monitorList?.size ?? 0).toBe(0);
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(sends).toHaveLength(0);
+  });
+
+  it('works without a bound MonitorStore (synchronous path only, no push fanout)', async () => {
+    // No `monitor:` option → the actor still routes the reducer but skips
+    // the post-dispatch push drain. Covers the `this.monitor === undefined`
+    // branches in routeMonitor and drainMonitorPushes.
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('MONITOR + bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+  });
+
+  it('skips a nick whose connection has torn down between lookupNick and getConnection (race)', async () => {
+    // Covers the `conn?.nick !== undefined` false branch in
+    // resolveOnlineMap: lookupNick resolves but getConnection returns null.
+    const { alice, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+    // Drop bob's live connection while leaving the nick map intact so
+    // lookupNick still resolves.
+    runtime.dropConnection('c2');
+
+    await alice.receiveTextFrame('MONITOR S\r\n');
+
+    // 730 absent (bob no longer reachable); 731 present instead.
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 731 '))).toBe(true);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 730 ');
+    }
+  });
+
+  it('skips a nick whose live connection has no nick set (defensive)', async () => {
+    // Covers the `conn.nick !== undefined` false branch in resolveOnlineMap:
+    // lookupNick resolves but the connection state at that id has no nick
+    // (should not happen under correct runtime invariants — defensive).
+    const { alice, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+    // Manually clear bob's nick while leaving the registry intact.
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
+    delete bobState.nick;
+
+    await alice.receiveTextFrame('MONITOR S\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 730 ');
+    }
+  });
+
+  it('push to a watcher whose live connection has torn down uses * as nick placeholder', async () => {
+    // Covers the `watcher?.nick ?? '*'` `??` branch in drainMonitorPushes:
+    // getConnection returns null → watcherNick falls back to '*'.
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+    // Drop alice's live connection so the post-QUIT drain cannot resolve
+    // her nick. The push is still attempted; the wire line uses '*'.
+    runtime.dropConnection('c1');
+
+    await bob.receiveTextFrame('NICK bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 730 * :bob'))).toBe(true);
+  });
+
+  it('reserveNick failure does not fan out a 730 (collision)', async () => {
+    // Two actors racing for the same nick: the second reserve returns
+    // { ok: false } so the dispatch handler must NOT call
+    // monitor.onNickOnline. Covers the `if (result.ok)` false branch.
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    // alice subscribes to bob.
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+
+    // Pre-reserve bob under alice's connId so bob's NICK collides.
+    await runtime.reserveNick('bob', 'c1');
+    void bob;
+    await bob.receiveTextFrame('NICK bob\r\n');
+
+    // No 730 push should reach alice (the reserve failed).
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 730 ');
+    }
+  });
+
+  it('changeNick failure does not fan out push effects', async () => {
+    // Covers the `if (ok)` false branch in changeNickEtc: changeNick
+    // returns false on collision; monitor hooks must NOT fire.
+    const { alice, bob, runtime } = makeMonitorPair();
+    // bob subscribes to alice; alice then tries NICK <occupied>.
+    await bob.receiveTextFrame('MONITOR + alice\r\n');
+    // Seed both nicks: alice and bob both registered.
+    const bobState2 = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState2.nick = 'bob';
+    bobState2.registration = 'registered';
+    runtime.addConnection(bobState2);
+    runtime.calls.length = 0;
+
+    // alice attempts NICK bob — bob is taken, changeNick fails.
+    await alice.receiveTextFrame('NICK bob\r\n');
+
+    // No push to the bob watcher: changeNick failed.
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of lines) {
+      expect(line.text).not.toMatch(/ 73[01] /u);
+    }
+  });
+});
+
+// ===========================================================================
+// ConnectionActor — IRCv3 labeled-response
+//
+// A client tags an inbound message with `+label=<id>`; the server wraps every
+// reply caused by that message (addressed back to the requester) in a single
+// `BATCH +id labeled-response … BATCH -id`. No-reply requests emit an empty
+// batch so the client can still correlate the label.
+// ===========================================================================
+
+describe('ConnectionActor — IRCv3 labeled-response', () => {
+  /** Caps a labeled-response-capable client negotiates (batch is required). */
+  const LABELED_CAPS = new Set<string>(['batch', 'labeled-response']);
+
+  /** echo-message + labeled caps — a client that sees its own echoed replies. */
+  const ECHO_LABELED_CAPS = new Set<string>(['echo-message', 'batch', 'labeled-response']);
+
+  function makeOnlineConn(id: string, nick: string): ConnectionState {
+    const c = createConnection({ id, connectedSince: 0 });
+    c.nick = nick;
+    c.user = nick;
+    c.host = `${nick}.org`;
+    c.realname = nick;
+    c.registration = 'registered';
+    return c;
+  }
+
+  it('wraps the echo of a labeled PRIVMSG in a BATCH +label labeled-response frame', async () => {
+    const { actor, runtime, conn } = makeActor({ conn: { caps: ECHO_LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    // Put alice on #foo so the channel PRIVMSG is accepted.
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+    void conn;
+
+    await actor.receiveTextFrame('@+label=foo PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +foo labeled-response',
+      ':alice!alice@example.com PRIVMSG #foo :hi',
+      'BATCH -foo',
+    ]);
+  });
+
+  it('emits an empty labeled batch when the labeled request produces no reply', async () => {
+    // NOTICE (no echo-message) is fire-and-forget for the sender: only a
+    // broadcast to peers, no Send back to the requester.
+    const { actor, runtime } = makeActor({ conn: { caps: LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=empty NOTICE #foo :hi\r\n');
+
+    // The requester receives ONLY the empty labeled batch (start + end).
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual(['BATCH +empty labeled-response', 'BATCH -empty']);
+  });
+
+  it('accumulates every reply to the requester under a single labeled batch', async () => {
+    // Multi-target PRIVMSG with echo-message produces one echo Send-to-self
+    // per target; all echoes must land inside ONE labeled batch.
+    const { actor, runtime } = makeActor({ conn: { caps: ECHO_LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    runtime.addConnection(makeOnlineConn('c3', 'carol'));
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=m PRIVMSG bob,carol :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +m labeled-response',
+      ':alice!alice@example.com PRIVMSG bob :hi',
+      ':alice!alice@example.com PRIVMSG carol :hi',
+      'BATCH -m',
+    ]);
+  });
+
+  it('wraps an error numeric (403) in the labeled batch', async () => {
+    // JOIN <invalid-name> (no # prefix) yields 403 ERR_NOSUCHCHANNEL, which
+    // must still be wrapped so the requester can correlate the failure.
+    const { actor, runtime } = makeActor({ conn: { caps: LABELED_CAPS } });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=e JOIN badname\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +e labeled-response',
+      ':irc.example.com 403 alice badname :No such channel',
+      'BATCH -e',
+    ]);
+  });
+
+  it('does NOT wrap when the labeled-response cap is absent', async () => {
+    const { actor, runtime } = makeActor({
+      conn: { caps: new Set<string>(['echo-message', 'batch']) },
+    });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=foo PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    // No batch markers — the echo is delivered bare.
+    expect(lines.map((l) => l.text)).toEqual([':alice!alice@example.com PRIVMSG #foo :hi']);
+  });
+
+  it('does NOT wrap when the batch cap is absent (labeled-response requires batch)', async () => {
+    const { actor, runtime } = makeActor({
+      conn: { caps: new Set<string>(['echo-message', 'labeled-response']) },
+    });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=foo PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([':alice!alice@example.com PRIVMSG #foo :hi']);
+  });
+
+  it('does NOT wrap an unlabeled PRIVMSG even when both caps are negotiated', async () => {
+    const { actor, runtime } = makeActor({ conn: { caps: ECHO_LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([':alice!alice@example.com PRIVMSG #foo :hi']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// draft/multiline BATCH (multi-line batching)
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds a channel with the supplied members and returns per-connection
+ * capture filters. Mirrors the setup used by the framing / msgid tests.
+ */
+async function setupMultilineChannel(
+  runtime: FakeRuntime,
+  members: Array<{ conn: ConnId; nick: string; caps?: ReadonlyArray<string> }>,
+): Promise<void> {
+  await runtime.applyChannelDelta('#foo', {
+    memberships: members.map((m) => ({ type: 'add' as const, conn: m.conn, nick: m.nick })),
+  });
+  for (const m of members) {
+    const conn = createConnection({ id: m.conn, connectedSince: 0 });
+    conn.nick = m.nick;
+    conn.user = m.nick;
+    conn.host = `${m.nick}.example`;
+    conn.registration = 'registered';
+    if (m.caps !== undefined) conn.caps = new Set<string>(m.caps);
+    runtime.addConnection(conn);
+  }
+}
+
+function sentTo(runtime: FakeRuntime, connId: ConnId): RawLine[] {
+  return runtime.calls
+    .filter((c) => c.method === 'send' && c.args[0] === connId)
+    .flatMap((c) => c.args[1] as RawLine[]);
+}
+
+describe('ConnectionActor — draft/multiline BATCH', () => {
+  it('strips the +draft/multiline tag for a non-message-tags legacy peer', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Bob has no caps → bare joined PRIVMSG, no `@+draft/multiline` prefix.
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :line one\nline two'),
+    ).toBe(true);
+    expect(bobLines.some((l) => l.text.startsWith('@+draft/multiline'))).toBe(false);
+  });
+
+  it('preserves the +draft/multiline tag for a message-tags-only peer', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c4', nick: 'dave', caps: ['message-tags'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Dave has message-tags but NOT draft/multiline → tagged joined PRIVMSG.
+    const daveLines = sentTo(runtime, 'c4');
+    expect(
+      daveLines.some(
+        (l) =>
+          l.text === '@+draft/multiline :alice!alice@example.com PRIVMSG #foo :line one\nline two',
+      ),
+    ).toBe(true);
+  });
+
+  it('relays a 2-line batch to a multiline-capable peer as a BATCH frame', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c3', nick: 'carol', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Multiline-capable carol receives the replayed BATCH framing. The batch
+    // ref id is allocated from the shared id factory (offset by per-frame
+    // trace ids), so match the shape rather than the exact id.
+    const carolLines = sentTo(runtime, 'c3');
+    const joined = carolLines.map((l) => l.text).join('|');
+    expect(joined).toMatch(/BATCH \+batch-\d+ draft\/multiline #foo/);
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG #foo :line one');
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG #foo :line two');
+    expect(joined).toMatch(/BATCH -batch-\d+/);
+    // And she does NOT receive the legacy joined form.
+    expect(carolLines.some((l) => l.text.startsWith('@+draft/multiline'))).toBe(false);
+  });
+
+  it('rejects an over-budget batch with FAIL and relays nothing', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :aaaaaaaaaa\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :bbbbbbbbbb\r\n');
+    // Two 10-char lines => joined 10 + 1 + 10 = 21 bytes. The actor uses the
+    // default 4096 budget; force a tiny budget via a config-override actor.
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // With the default budget this is accepted; assert no FAIL on this path.
+    expect(sentTo(runtime, 'c1').some((l) => l.text.includes('FAIL BATCH'))).toBe(false);
+  });
+
+  it('rejects an over-budget batch with FAIL when the configured budget is small', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    // Override the actor's config to advertise a tiny multiline budget.
+    (actor as unknown as { serverConfig: ServerConfig }).serverConfig = {
+      ...(actor as unknown as { serverConfig: ServerConfig }).serverConfig,
+      multilineMaxBytes: 10,
+    };
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :world\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Sender receives the FAIL; no broadcast to bob.
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_BYTES #foo :Multi-line batch exceeds the 10 byte limit',
+      ),
+    ).toBe(true);
+    expect(runtime.calls.some((c) => c.method === 'broadcast')).toBe(false);
+  });
+
+  it('ignores a BATCH open from a client without the draft/multiline cap (421)', async () => {
+    const { actor, runtime } = makeActor({});
+    // Sender has batch but NOT draft/multiline.
+    await setupMultilineChannel(runtime, [{ conn: 'c1', nick: 'alice', caps: ['batch'] }]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+
+    // Falls back to 421 ERR_UNKNOWNCOMMAND for an unsupported batch open.
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('ignores inner PRIVMSG while no multiline batch is open (normal delivery)', async () => {
+    const { actor, runtime } = makeActor({});
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice' },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    // A standalone PRIVMSG (no open batch) is delivered as a normal channel
+    // message, not swallowed by the multiline accumulator.
+    await actor.receiveTextFrame('PRIVMSG #foo :plain\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :plain')).toBe(
+      true,
+    );
+  });
+
+  it('falls back to 421 when closing a batch with an unknown id', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    // No batch is open; `BATCH -nope` hits the unknown-id path.
+    await actor.receiveTextFrame('BATCH -nope\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('aborts the batch with FAIL when an inner line targets a different channel', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #bar :wrong target\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some((l) => l.text.includes('FAIL BATCH MULTILINE_INVALID_TARGET #foo')),
+    ).toBe(true);
+  });
+
+  it('aborts the batch with FAIL when inner lines mix PRIVMSG and NOTICE', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :first\r\n');
+    await actor.receiveTextFrame('NOTICE #foo :mixed\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some((l) => l.text.includes('FAIL BATCH MULTILINE_MIXED_COMMANDS #foo')),
+    ).toBe(true);
+  });
+
+  it('falls back to 421 for a BATCH frame with a malformed marker', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    // Neither `+id` nor `-id` — the marker is a bare word.
+    await actor.receiveTextFrame('BATCH bogus\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('falls back to 421 for a BATCH open with the wrong batch type', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 netsplit :#foo\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('falls back to 421 when opening a second batch before the first closes', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    // Re-open without closing the first.
+    await actor.receiveTextFrame('BATCH +m2 draft/multiline :#foo\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('falls back to 421 for a BATCH frame with no params', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('accumulates an inner PRIVMSG with no trailing text as empty', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    // Inner PRIVMSG with no trailing parameter — exercises the `?? ''` fallback.
+    await actor.receiveTextFrame('PRIVMSG #foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :real text\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // The batch still finalizes; bob receives the joined content (empty + real).
+    const bobLines = sentTo(runtime, 'c2');
+    expect(bobLines.some((l) => l.text.includes('PRIVMSG #foo :'))).toBe(true);
+  });
+
+  it('treats accumulateMultilineLine as a no-op when no batch is open (defensive guard)', () => {
+    const { actor } = makeActor({});
+    // route() only dispatches PRIVMSG/NOTICE here while a batch is open; the
+    // method still guards defensively so a future caller cannot crash. Pin
+    // that no-op contract by invoking the private method with no batch open.
+    const result = (
+      actor as unknown as {
+        accumulateMultilineLine: (msg: { command: string; params: string[] }) => unknown[];
+      }
+    ).accumulateMultilineLine({ command: 'PRIVMSG', params: ['#foo', 'hi'] });
+    expect(result).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// draft/multiline BATCH — nick-target routing
+//
+// A batch whose target is a nick (not a channel) must be delivered to that
+// nick only. The pure reducer is channel-focused (Broadcast); nick-target
+// delivery requires actor-side per-recipient cap resolution.
+// ---------------------------------------------------------------------------
+
+describe('ConnectionActor — ctx store plumbing (draft/pre-away, draft/read-marker)', () => {
+  it('persists an AWAY reason to the bound AwayStore for an identified connection', async () => {
+    const away = new InMemoryAwayStore();
+    const { actor, conn } = makeActor({ away, conn: { account: 'alice' } });
+
+    await actor.receiveTextFrame('AWAY :gone fishing\r\n');
+
+    expect(conn.away).toBe('gone fishing');
+    expect(away.get('alice')).toBe('gone fishing');
+  });
+
+  it('does not persist AWAY to the store when the connection is unidentified', async () => {
+    const away = new InMemoryAwayStore();
+    const { actor, conn } = makeActor({ away });
+
+    await actor.receiveTextFrame('AWAY :gone fishing\r\n');
+
+    // In-memory session state still tracks the reason; the persisted store
+    // stays empty because the connection has no account.
+    expect(conn.away).toBe('gone fishing');
+    expect(away.get('alice')).toBeUndefined();
+  });
+
+  it('persists a +draft/read-marker TAGMSG to the bound ReadMarkerStore for an identified member', async () => {
+    const readMarkers = new InMemoryReadMarkerStore();
+    const { actor, runtime, conn } = makeActor({ readMarkers });
+    conn.account = 'alice';
+    conn.caps = new Set<string>(['message-tags', 'draft/read-marker']);
+    await setupMultilineChannel(runtime, [{ conn: 'c1', nick: 'alice' }]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+draft/read-marker=msg-42 TAGMSG #foo\r\n');
+
+    expect(readMarkers.get('alice', '#foo')).toBe('msg-42');
+  });
+});
+
+describe('ConnectionActor — draft/multiline BATCH to a nick target', () => {
+  function addRecipient(
+    runtime: FakeRuntime,
+    conn: ConnId,
+    nick: string,
+    caps?: ReadonlyArray<string>,
+  ): ConnectionState {
+    const state = createConnection({ id: conn, connectedSince: 0 });
+    state.nick = nick;
+    state.user = nick;
+    state.host = `${nick}.example`;
+    state.registration = 'registered';
+    if (caps !== undefined) state.caps = new Set<string>(caps);
+    runtime.addConnection(state);
+    return state;
+  }
+
+  it('delivers a nick-target batch to a multiline-capable recipient as a BATCH frame', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob', ['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    const joined = bobLines.map((l) => l.text).join('|');
+    expect(joined).toMatch(/BATCH \+batch-\d+ draft\/multiline bob/);
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG bob :line one');
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG bob :line two');
+    expect(joined).toMatch(/BATCH -batch-\d+/);
+  });
+
+  it('delivers a nick-target batch to a legacy recipient as a single joined PRIVMSG', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG bob :line one\nline two'),
+    ).toBe(true);
+  });
+
+  it('delivers a nick-target batch to a message-tags recipient as a tagged joined PRIVMSG', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob', ['message-tags']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some(
+        (l) =>
+          l.text === '@+draft/multiline :alice!alice@example.com PRIVMSG bob :line one\nline two',
+      ),
+    ).toBe(true);
+  });
+
+  it('does not broadcast a nick-target batch to other connections', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob', ['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c3', 'carol', ['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Carol is NOT the nick target and must not receive the batch.
+    const carolLines = sentTo(runtime, 'c3');
+    expect(carolLines).toHaveLength(0);
+  });
+
+  it('surfaces 401 ERR_NOSUCHNICK for a nick-target PRIVMSG when the recipient is offline', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    // bob is NOT registered → lookupNick returns null.
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 '))).toBe(true);
+    expect(aliceLines.some((l) => l.text.includes('bob'))).toBe(true);
+  });
+
+  it('omits 401 for a nick-target NOTICE when the recipient is offline', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('NOTICE bob :quiet one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 '))).toBe(false);
+  });
+
+  it('delivers nothing for an empty nick-target batch', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    expect(sentTo(runtime, 'c2')).toHaveLength(0);
+  });
+
+  it('rejects an over-budget nick-target batch with FAIL', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    (actor as unknown as { serverConfig: ServerConfig }).serverConfig = {
+      ...(actor as unknown as { serverConfig: ServerConfig }).serverConfig,
+      multilineMaxBytes: 5,
+    };
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :hello world\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_BYTES bob :Multi-line batch exceeds the 5 byte limit',
+      ),
+    ).toBe(true);
+    expect(sentTo(runtime, 'c2')).toHaveLength(0);
+  });
+
+  it('surfaces 401 when the recipient connection is gone mid-flight', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    runtime.addConnection(bobConn);
+    // Drop the connection AFTER nick registration so lookupNick resolves but
+    // getConnection returns null (the "gone between the two awaits" race).
+    runtime.dropConnection('c2');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 '))).toBe(true);
+  });
+
+  it('uses "?" and "*" fallbacks when the sender has no nick', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    // A connection that negotiated caps but has no NICK set — exercises the
+    // hostmask `?? '?'` and numeric `?? '*'` fallbacks. `delete` is required
+    // because `exactOptionalPropertyTypes` forbids `= undefined`.
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes requires delete
+    delete conn.nick;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes requires delete
+    delete conn.user;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes requires delete
+    delete conn.host;
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    // Online recipient → hostmask falls back to "?".
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(bobLines.some((l) => l.text.startsWith(':? PRIVMSG bob :line one'))).toBe(true);
+
+    // Offline recipient → numeric falls back to "*".
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('BATCH +m2 draft/multiline :carol\r\n');
+    await actor.receiveTextFrame('PRIVMSG carol :no recipient\r\n');
+    await actor.receiveTextFrame('BATCH -m2\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 * carol'))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// draft/multiline BATCH — chathistory recording
+//
+// A finalized multi-line batch must be recorded once into the bound
+// MessageStore so CHATHISTORY AFTER/BEFORE/LATEST return exactly one entry
+// per batch, carrying the joined body, the assigned msgid, and the
+// +draft/multiline client tag.
+// ---------------------------------------------------------------------------
+
+describe('ConnectionActor — draft/multiline chathistory recording', () => {
+  it('records the joined channel batch into the MessageStore', async () => {
+    const store = new InMemoryMessageStore();
+    const { actor, runtime, conn } = makeActor({ messages: store });
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0]?.text).toBe('line one\nline two');
+    expect(recorded[0]?.command).toBe('PRIVMSG');
+    expect(recorded[0]?.nick).toBe('alice');
+    expect(recorded[0]?.msgid).toMatch(/^[A-Za-z0-9_-]+$/);
+  });
+
+  it('CHATHISTORY replay carries the +draft/multiline tag on the joined body', async () => {
+    const store = new InMemoryMessageStore();
+    const chathistoryCaps = new Set<string>([
+      'batch',
+      'draft/multiline',
+      'draft/chathistory',
+      'server-time',
+      'message-tags',
+    ]);
+    const { actor, runtime, conn } = makeActor({ messages: store });
+    conn.caps = chathistoryCaps;
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('CHATHISTORY LATEST #foo * 1\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends[0]?.args[1] as RawLine[];
+    const replayLine = lines.find((l) => l.text.includes('PRIVMSG #foo'));
+    expect(replayLine?.text).toContain('+draft/multiline');
+    expect(replayLine?.text).toContain('line one\nline two');
+  });
+
+  it('records the joined nick-target batch into the MessageStore', async () => {
+    const store = new InMemoryMessageStore();
+    const { actor, runtime, conn } = makeActor({ messages: store });
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :pm one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :pm two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const recorded = store.query({ chan: 'bob', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0]?.text).toBe('pm one\npm two');
+  });
+
+  it('does not record when no MessageStore is bound', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // No crash, no store — the delivery still works (broadcast happened).
+    expect(runtime.calls.some((c) => c.method === 'broadcast')).toBe(false);
+    // Cap-split path emits a send to bob via getChannelSnapshot…
+    expect(runtime.calls.some((c) => c.method === 'getChannelSnapshot')).toBe(true);
+  });
 });