@cloudcli-ai/cloudcli 1.37.2 → 1.37.3

package/server/modules/websocket/services/session-upsert-broadcast.service.ts

@@ -0,0 +1,108 @@
+import path from 'node:path';
+
+import { projectsDb, sessionsDb } from '@/modules/database/index.js';
+import { generateDisplayName } from '@/modules/projects/index.js';
+import { connectedClients, WS_OPEN_STATE } from '@/modules/websocket/services/websocket-state.service.js';
+import type { SessionUpsertedEvent } from '@/shared/types.js';
+
+/**
+ * The single producer of the `session_upserted` delta.
+ *
+ * The event carries everything a sidebar needs to upsert a session in place
+ * (its summary plus the owning project's metadata), so clients never refetch
+ * the whole project list because one transcript changed on disk.
+ *
+ * It used to be built in two places — the on-disk sessions watcher and the
+ * chat run registry — and only the registry's copy set `providerSessionId`.
+ * That field is how the client notices a row it is showing has been merged
+ * into its canonical app-session row, so a merge announced by any other path
+ * left a stale duplicate in the sidebar. One builder, one shape.
+ */
+async function buildSessionUpsertedEvent(
+  sessionIdOrProviderSessionId: string,
+): Promise<SessionUpsertedEvent | null> {
+  // Resolving by provider id first covers the watcher, which only ever sees
+  // the id written in the transcript. For a row where the two ids are equal
+  // — legacy rows, and any session indexed from disk before its mapping
+  // existed — both lookups land on the same row anyway.
+  const row = sessionsDb.getSessionByProviderSessionId(sessionIdOrProviderSessionId)
+    ?? sessionsDb.getSessionById(sessionIdOrProviderSessionId);
+  if (!row || row.isArchived) {
+    return null;
+  }
+
+  const projectPath = row.project_path;
+  const project = projectPath ? projectsDb.getProjectPath(projectPath) : null;
+  const displayName = project?.custom_project_name?.trim()
+    ? project.custom_project_name
+    : await generateDisplayName(path.basename(projectPath ?? '') || (projectPath ?? ''), projectPath);
+
+  return {
+    kind: 'session_upserted',
+    sessionId: row.session_id,
+    providerSessionId: row.provider_session_id ?? null,
+    // The column is a plain TEXT and typed as `string` on the row, but only
+    // provider adapters ever write it.
+    provider: row.provider as SessionUpsertedEvent['provider'],
+    session: {
+      id: row.session_id,
+      summary: row.custom_name || '',
+      messageCount: 0,
+      lastActivity: row.updated_at ?? row.created_at ?? new Date().toISOString(),
+    },
+    project: project
+      ? {
+        projectId: project.project_id,
+        path: project.project_path,
+        fullPath: project.project_path,
+        displayName,
+        isStarred: Boolean(project.isStarred),
+      }
+      : null,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function sendToConnectedClients(payloads: string[]): void {
+  if (payloads.length === 0) {
+    return;
+  }
+
+  connectedClients.forEach((client) => {
+    if (client.readyState === WS_OPEN_STATE) {
+      for (const payload of payloads) {
+        client.send(payload);
+      }
+    }
+  });
+}
+
+/** Announces one session. Used by the chat run registry when a run reports its provider-native id. */
+export async function broadcastSessionUpserted(sessionIdOrProviderSessionId: string): Promise<void> {
+  const event = await buildSessionUpsertedEvent(sessionIdOrProviderSessionId);
+  if (event) {
+    sendToConnectedClients([JSON.stringify(event)]);
+  }
+}
+
+/**
+ * Announces a batch of sessions. Used by the providers module's sessions
+ * watcher, whose debounced flush can carry dozens of ids at once — the client
+ * set is walked once for the whole batch rather than once per session.
+ */
+export async function broadcastSessionUpsertedBatch(
+  sessionIds: Iterable<string>,
+): Promise<void> {
+  const payloads: string[] = [];
+  for (const sessionId of sessionIds) {
+    const event = await buildSessionUpsertedEvent(sessionId);
+    if (event) {
+      payloads.push(JSON.stringify(event));
+    }
+  }
+
+  sendToConnectedClients(payloads);
+}
+
+/** @internal Exported for the broadcast tests, which assert the payload shape directly. */
+export { buildSessionUpsertedEvent };

package/server/modules/websocket/services/shell-websocket.service.ts

@@ -19,6 +19,7 @@ type ShellIncomingMessage = {
   initialCommand?: string;
   isPlainShell?: boolean;
   forceRestart?: boolean;
+  bypassPermissions?: boolean;
 };
 
 type PtySessionEntry = {
@@ -216,12 +217,18 @@ function buildShellCommand(
     return initialCommand || 'opencode';
   }
 
-  const command = initialCommand || 'claude';
+  // Launching with the flag is what unlocks "bypass permissions" in the CLI's
+  // shift+tab permission-mode cycle; it cannot be enabled from inside a
+  // session started without it.
+  const bypassFlag = readBoolean(message.bypassPermissions)
+    ? ' --dangerously-skip-permissions'
+    : '';
+  const command = initialCommand || `claude${bypassFlag}`;
   if (resumeSessionId) {
     if (os.platform() === 'win32') {
-      return `claude --resume "${resumeSessionId}"; if ($LASTEXITCODE -ne 0) { claude }`;
+      return `claude --resume "${resumeSessionId}"${bypassFlag}; if ($LASTEXITCODE -ne 0) { claude${bypassFlag} }`;
     }
-    return `claude --resume "${resumeSessionId}" || claude`;
+    return `claude --resume "${resumeSessionId}"${bypassFlag} || claude${bypassFlag}`;
   }
   return command;
 }

package/server/modules/websocket/tests/chat-edit-send.test.ts

@@ -0,0 +1,309 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { sessionsService } from '@/modules/providers/index.js';
+import { handleChatConnection } from '@/modules/websocket/services/chat-websocket.service.js';
+import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
+import { connectedClients } from '@/modules/websocket/services/websocket-state.service.js';
+
+const SESSION_ID = 'edit-session';
+
+function createFakeSocket() {
+  const socket = new EventEmitter() as EventEmitter & {
+    readyState: number;
+    frames: Array<Record<string, unknown>>;
+    send: (data: string) => void;
+  };
+  socket.readyState = 1;
+  socket.frames = [];
+  socket.send = (data: string) => socket.frames.push(JSON.parse(data) as Record<string, unknown>);
+  return socket;
+}
+
+/** Two turns and an edit of the second, which is the transcript the gateway reads. */
+const TRANSCRIPT_ROWS = [
+  {
+    type: 'user', uuid: 'e-u1', parentUuid: null, sessionId: SESSION_ID,
+    timestamp: '2026-08-23T10:00:00.000Z',
+    message: { role: 'user', content: [{ type: 'text', text: 'first' }] },
+  },
+  {
+    type: 'assistant', uuid: 'e-a1', parentUuid: 'e-u1', sessionId: SESSION_ID,
+    timestamp: '2026-08-23T10:00:01.000Z',
+    message: { role: 'assistant', model: 'claude-opus-5', content: [{ type: 'text', text: 'reply' }] },
+  },
+  {
+    type: 'user', uuid: 'e-u2', parentUuid: 'e-a1', sessionId: SESSION_ID,
+    timestamp: '2026-08-23T10:00:02.000Z',
+    message: { role: 'user', content: [{ type: 'text', text: 'second' }] },
+  },
+];
+
+/**
+ * The same two turns as a Codex rollout. Codex rows carry no id of their own,
+ * so the edit anchor is the enclosing turn — which is also the unit its fork
+ * endpoint cuts at.
+ */
+const CODEX_TRANSCRIPT_ROWS = [
+  { type: 'event_msg', payload: { type: 'task_started', turn_id: 'turn-a' } },
+  { type: 'event_msg', payload: { type: 'user_message', message: 'first' } },
+  { type: 'event_msg', payload: { type: 'task_complete', turn_id: 'turn-a' } },
+  { type: 'event_msg', payload: { type: 'task_started', turn_id: 'turn-b' } },
+  { type: 'event_msg', payload: { type: 'user_message', message: 'second' } },
+  { type: 'event_msg', payload: { type: 'task_complete', turn_id: 'turn-b' } },
+];
+
+type RunCall = { provider: string; command: string; options: Record<string, unknown> };
+
+/**
+ * Set by a test that needs a run to still be in flight when the next frame
+ * arrives; the stub runtime returns immediately otherwise. Released when the
+ * test ends, so no stub run is left pending for the rest of the file.
+ */
+let holdRun: Promise<void> | null = null;
+let releaseHeldRun: (() => void) | null = null;
+
+function holdTheNextRun(): void {
+  holdRun = new Promise<void>((resolve) => { releaseHeldRun = resolve; });
+}
+
+async function withGateway(
+  provider: string,
+  runTest: (context: {
+    socket: ReturnType<typeof createFakeSocket>;
+    runs: RunCall[];
+  }) => Promise<void>,
+  rows: unknown[] = TRANSCRIPT_ROWS,
+): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'chat-edit-send-'));
+  const transcriptPath = path.join(tempDirectory, `${SESSION_ID}.jsonl`);
+  await writeFile(transcriptPath, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`, 'utf8');
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  const runs: RunCall[] = [];
+  const socket = createFakeSocket();
+
+  try {
+    const now = new Date().toISOString();
+    sessionsDb.createSession(SESSION_ID, provider, tempDirectory, 'Edit session', now, now, transcriptPath);
+
+    handleChatConnection(
+      socket as never,
+      { user: { id: 1 } } as never,
+      {
+        runtime: {
+          hasRuntime: () => true,
+          run: async (runProvider: string, command: string, options: Record<string, unknown>) => {
+            runs.push({ provider: runProvider, command, options });
+            if (holdRun) {
+              await holdRun;
+            }
+          },
+        } as never,
+      },
+    );
+
+    await runTest({ socket, runs });
+  } finally {
+    releaseHeldRun?.();
+    releaseHeldRun = null;
+    holdRun = null;
+    connectedClients.clear();
+    chatRunRegistry.clearAll();
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+/** The handler is async and the socket listener does not await it. */
+const settle = () => new Promise((resolve) => { setTimeout(resolve, 30); });
+
+test('an edit resumes through the turn before the one being replaced', async () => {
+  await withGateway('claude', async ({ socket, runs }) => {
+    socket.emit('message', JSON.stringify({
+      type: 'chat.edit-send',
+      sessionId: SESSION_ID,
+      anchorId: 'e-u2',
+      content: 'a better second prompt',
+    }));
+    await settle();
+
+    assert.equal(runs.length, 1);
+    assert.equal(runs[0].command, 'a better second prompt');
+    // Inclusive of the row it names, so this is the last turn KEPT.
+    assert.equal(runs[0].options.resumeAnchorId, 'e-a1');
+    assert.equal(runs[0].options.resumeFromScratch, false);
+  });
+});
+
+test('editing the first prompt starts the conversation over', async () => {
+  await withGateway('claude', async ({ socket, runs }) => {
+    socket.emit('message', JSON.stringify({
+      type: 'chat.edit-send',
+      sessionId: SESSION_ID,
+      anchorId: 'e-u1',
+      content: 'a better first prompt',
+    }));
+    await settle();
+
+    assert.equal(runs.length, 1);
+    assert.equal(runs[0].options.resumeAnchorId, undefined);
+    assert.equal(runs[0].options.resumeFromScratch, true);
+  });
+});
+
+test('every subscribed client is told to drop the superseded turns', async () => {
+  await withGateway('claude', async ({ socket }) => {
+    socket.emit('message', JSON.stringify({
+      type: 'chat.edit-send',
+      sessionId: SESSION_ID,
+      anchorId: 'e-u2',
+      content: 'replacement',
+    }));
+    await settle();
+
+    const truncation = socket.frames.find((frame) => frame.kind === 'history_truncated');
+    assert.ok(truncation, 'a history_truncated frame is emitted');
+    assert.equal(truncation?.anchorId, 'e-u2');
+    assert.equal(truncation?.sessionId, SESSION_ID);
+    // Sequenced like every other run event, so a reconnecting tab replays it.
+    assert.equal(typeof truncation?.seq, 'number');
+  });
+});
+
+test('an edit without an anchor is refused', async () => {
+  await withGateway('claude', async ({ socket, runs }) => {
+    socket.emit('message', JSON.stringify({
+      type: 'chat.edit-send',
+      sessionId: SESSION_ID,
+      content: 'no anchor',
+    }));
+    await settle();
+
+    assert.equal(runs.length, 0);
+    assert.equal(socket.frames.at(-1)?.code, 'ANCHOR_REQUIRED');
+  });
+});
+
+test('an anchor the transcript does not hold is refused', async () => {
+  await withGateway('claude', async ({ socket, runs }) => {
+    socket.emit('message', JSON.stringify({
+      type: 'chat.edit-send',
+      sessionId: SESSION_ID,
+      anchorId: 'not-in-transcript',
+      content: 'replacement',
+    }));
+    await settle();
+
+    assert.equal(runs.length, 0);
+    assert.equal(socket.frames.at(-1)?.code, 'ANCHOR_NOT_FOUND');
+  });
+});
+
+test('a provider that cannot re-run from a point is refused rather than sending a new message', async () => {
+  await withGateway('cursor', async ({ socket, runs }) => {
+    socket.emit('message', JSON.stringify({
+      type: 'chat.edit-send',
+      sessionId: SESSION_ID,
+      anchorId: 'e-u2',
+      content: 'replacement',
+    }));
+    await settle();
+
+    assert.equal(runs.length, 0);
+    assert.equal(socket.frames.at(-1)?.code, 'EDIT_NOT_SUPPORTED');
+  });
+});
+
+test('a refused send never rewinds the conversation', async () => {
+  await withGateway('codex', async ({ socket, runs }) => {
+    // The rewind moves the session onto a different provider transcript and
+    // cannot be undone, so a send the gateway is about to refuse must not
+    // reach it. A run already in flight is the realistic way that happens: a
+    // scheduled message, or another device.
+    const realRewind = sessionsService.rewindSessionForEdit;
+    let rewound = false;
+    sessionsService.rewindSessionForEdit = async () => { rewound = true; };
+    holdTheNextRun();
+
+    try {
+      socket.emit('message', JSON.stringify({
+        type: 'chat.send',
+        sessionId: SESSION_ID,
+        content: 'a turn that is already running',
+      }));
+      await settle();
+      assert.equal(runs.length, 1);
+
+      socket.emit('message', JSON.stringify({
+        type: 'chat.edit-send',
+        sessionId: SESSION_ID,
+        anchorId: 'turn-b',
+        content: 'an edit that arrives too late',
+      }));
+      await settle();
+    } finally {
+      sessionsService.rewindSessionForEdit = realRewind;
+    }
+
+    assert.equal(rewound, false);
+    assert.equal(runs.length, 1);
+    assert.equal(socket.frames.at(-1)?.code, 'RUN_IN_PROGRESS');
+  }, CODEX_TRANSCRIPT_ROWS);
+});
+
+test('a provider that has to branch to rewind is rewound before the run, not during it', async () => {
+  await withGateway('codex', async ({ socket, runs }) => {
+    // The rewind itself belongs to the provider and is covered there; what
+    // this asserts is the gateway's half — that a provider which reports it
+    // rewound gets an ordinary run instead of one carrying a resume anchor its
+    // runtime would not know what to do with.
+    const realRewind = sessionsService.rewindSessionForEdit;
+    const rewindCalls: unknown[] = [];
+    let truncatedBeforeRewind = false;
+    sessionsService.rewindSessionForEdit = async (sessionId: string, keepThroughId: string | null) => {
+      truncatedBeforeRewind = socket.frames.some((frame) => frame.kind === 'history_truncated');
+      rewindCalls.push({ sessionId, keepThroughId });
+    };
+
+    try {
+      socket.emit('message', JSON.stringify({
+        type: 'chat.edit-send',
+        sessionId: SESSION_ID,
+        anchorId: 'turn-b',
+        content: 'a better second prompt',
+      }));
+      await settle();
+    } finally {
+      sessionsService.rewindSessionForEdit = realRewind;
+    }
+
+    // Resolved from the real Codex rollout: the turn before the edited one.
+    assert.deepEqual(rewindCalls, [{ sessionId: SESSION_ID, keepThroughId: 'turn-a' }]);
+    assert.equal(runs.length, 1);
+    assert.equal(runs[0].command, 'a better second prompt');
+    assert.equal(runs[0].options.resumeAnchorId, undefined);
+    assert.equal(runs[0].options.resumeFromScratch, undefined);
+
+    // Clients still hear about the cut; how it was made is the server's
+    // business. And they hear about it first: a rewind that branches waits on
+    // a spawned process, and holding the frame until it returned left the
+    // replaced message on screen for about a second.
+    assert.ok(socket.frames.some((frame) => frame.kind === 'history_truncated'));
+    assert.equal(truncatedBeforeRewind, true);
+  }, CODEX_TRANSCRIPT_ROWS);
+});

package/server/modules/websocket/tests/chat-run-registry.test.ts

@@ -70,7 +70,7 @@ test('live events are remapped to the app session id and sequenced', async () =>
 });
 
 test('session_created is swallowed and persisted as the provider-id mapping', async () => {
-  await withIsolatedDatabase(() => {
+  await withIsolatedDatabase(async () => {
     sessionsDb.createAppSession('app-run-2', 'cursor', '/workspace/demo');
     const connection = new FakeConnection();
     connectedClients.add(connection as never);
@@ -90,6 +90,10 @@ test('session_created is swallowed and persisted as the provider-id mapping', as
       newSessionId: 'cursor-native-7',
     });
 
+    // The upsert is broadcast without blocking the run: resolving the owning
+    // project's display name is async, so let that settle before asserting.
+    await new Promise((resolve) => { setTimeout(resolve, 0); });
+
     // The provider-native event itself is never forwarded...
     const sessionUpserts = connection.frames.filter((frame) => frame.kind === 'session_upserted');
     assert.equal(sessionUpserts.length, 1);
@@ -222,7 +226,7 @@ test('replayEvents returns only events after the requested seq', async () => {
   });
 });
 
-test('attachConnection reroutes the live stream to a new socket', async () => {
+test('attachConnection adds a socket without cutting off the ones already watching', async () => {
   await withIsolatedDatabase(() => {
     sessionsDb.createAppSession('app-run-5', 'opencode', '/workspace/demo');
     const firstConnection = new FakeConnection();
@@ -237,15 +241,42 @@ test('attachConnection reroutes the live stream to a new socket', async () => {
 
     run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'before' });
 
+    // A second tab on the same session subscribes mid-run.
     const secondConnection = new FakeConnection();
     assert.equal(chatRunRegistry.attachConnection('app-run-5', secondConnection), true);
     run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'after' });
 
-    assert.deepEqual(firstConnection.frames.map((frame) => frame.content), ['before']);
+    assert.deepEqual(firstConnection.frames.map((frame) => frame.content), ['before', 'after']);
     assert.deepEqual(secondConnection.frames.map((frame) => frame.content), ['after']);
   });
 });
 
+test('a refreshed tab stops receiving once its old socket is closed', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-5b', 'opencode', '/workspace/demo');
+    const staleConnection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-5b',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection: staleConnection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    // The page reloads: the original socket closes and the fresh one subscribes.
+    staleConnection.readyState = 3;
+    const reloadedConnection = new FakeConnection();
+    assert.equal(chatRunRegistry.attachConnection('app-run-5b', reloadedConnection), true);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'after' });
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'later' });
+
+    assert.deepEqual(staleConnection.frames, []);
+    assert.deepEqual(reloadedConnection.frames.map((frame) => frame.content), ['after', 'later']);
+  });
+});
+
 test('startRun rejects a second concurrent run for the same session', async () => {
   await withIsolatedDatabase(() => {
     sessionsDb.createAppSession('app-run-6', 'opencode', '/workspace/demo');

package/server/modules/websocket/tests/session-upsert-broadcast.test.ts

@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import {
+  broadcastSessionUpserted,
+  broadcastSessionUpsertedBatch,
+} from '@/modules/websocket/services/session-upsert-broadcast.service.js';
+import { connectedClients } from '@/modules/websocket/services/websocket-state.service.js';
+
+class FakeConnection {
+  readyState = 1; // WS_OPEN_STATE
+  frames: Array<Record<string, unknown>> = [];
+
+  send(data: string): void {
+    this.frames.push(JSON.parse(data) as Record<string, unknown>);
+  }
+}
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'session-upsert-broadcast-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    connectedClients.clear();
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('an upsert always carries the provider session id', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-1', 'opencode', '/workspace/demo');
+    sessionsDb.assignProviderSessionId('app-1', 'native-1');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpserted('app-1');
+
+    assert.equal(connection.frames.length, 1);
+    assert.equal(connection.frames[0].kind, 'session_upserted');
+    assert.equal(connection.frames[0].sessionId, 'app-1');
+    assert.equal(connection.frames[0].providerSessionId, 'native-1');
+  });
+});
+
+test('the watcher path resolves a provider-native id to the same canonical event', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-2', 'opencode', '/workspace/demo');
+    sessionsDb.assignProviderSessionId('app-2', 'native-2');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    // The sessions watcher only ever knows the id written in the transcript.
+    await broadcastSessionUpsertedBatch(['native-2']);
+
+    assert.equal(connection.frames.length, 1);
+    assert.equal(connection.frames[0].sessionId, 'app-2');
+    assert.equal(connection.frames[0].providerSessionId, 'native-2');
+  });
+});
+
+test('a session with no provider id yet reports null rather than omitting the field', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-3', 'claude', '/workspace/demo');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpserted('app-3');
+
+    assert.equal(connection.frames.length, 1);
+    assert.ok('providerSessionId' in connection.frames[0]);
+    assert.equal(connection.frames[0].providerSessionId, null);
+  });
+});
+
+test('an unresolvable id broadcasts nothing', async () => {
+  await withIsolatedDatabase(async () => {
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpserted('does-not-exist');
+    await broadcastSessionUpsertedBatch(['also-missing']);
+
+    assert.deepEqual(connection.frames, []);
+  });
+});
+
+test('a batch delivers every resolvable session and skips the rest', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-4', 'claude', '/workspace/demo');
+    sessionsDb.createAppSession('app-5', 'claude', '/workspace/demo');
+
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+
+    await broadcastSessionUpsertedBatch(['app-4', 'missing', 'app-5']);
+
+    assert.deepEqual(
+      connection.frames.map((frame) => frame.sessionId),
+      ['app-4', 'app-5'],
+    );
+  });
+});
+
+test('a closed socket is skipped', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('app-6', 'claude', '/workspace/demo');
+
+    const open = new FakeConnection();
+    const closing = new FakeConnection();
+    closing.readyState = 3;
+    connectedClients.add(open as never);
+    connectedClients.add(closing as never);
+
+    await broadcastSessionUpserted('app-6');
+
+    assert.equal(open.frames.length, 1);
+    assert.deepEqual(closing.frames, []);
+  });
+});