fix(cli): use session channel when closing ACP sessions

packages/cli/src/serve/httpAcpBridge.test.ts

@@ -38,6 +38,8 @@ import type {
 import { createDaemonStatusProvider } from './daemonStatusProvider.js';
 import {
   createHttpAcpBridge,
+  detachSessionIdFromEntryChannel,
+  findChannelInfoForEntry,
   InvalidClientIdError,
   InvalidPermissionOptionError,
   InvalidSessionMetadataError,
@@ -299,6 +301,56 @@ function makeChannel(opts: FakeAgentOpts = {}): ChannelHandle {
 }
 
 describe('createHttpAcpBridge', () => {
+  it('selects a session entry channel when the current attach channel has changed', () => {
+    // Model the channel-overlap window directly: old channel A still has
+    // an entry, while new channel B is the current attach target.
+    const channelA = { name: 'A' };
+    const channelB = { name: 'B' };
+    const infoA = { channel: channelA, label: 'old-dying-channel' };
+    const infoB = { channel: channelB, label: 'fresh-attach-channel' };
+
+    expect(
+      findChannelInfoForEntry(infoB, [infoA, infoB], {
+        channel: channelA,
+      }),
+    ).toBe(infoA);
+    expect(
+      findChannelInfoForEntry(infoB, [infoB], {
+        channel: channelA,
+      }),
+    ).toBeUndefined();
+  });
+
+  it('detaches a session from its entry channel during channel overlap', () => {
+    // Model the close/kill overlap window directly: old channel A still owns
+    // the session entry while fresh channel B is the current attach target.
+    // The detach helper used by closeSession/killSession must decrement A,
+    // not the current B channel.
+    const channelA = { name: 'A' };
+    const channelB = { name: 'B' };
+    const infoA = {
+      channel: channelA,
+      sessionIds: new Set(['session-a']),
+      label: 'old-dying-channel',
+    };
+    const infoB = {
+      channel: channelB,
+      sessionIds: new Set(['session-b']),
+      label: 'fresh-attach-channel',
+    };
+
+    const selected = detachSessionIdFromEntryChannel(
+      infoB,
+      [infoA, infoB],
+      { channel: channelA },
+      'session-a',
+    );
+
+    expect(selected).toBe(infoA);
+    expect(infoA.sessionIds.has('session-a')).toBe(false);
+    expect(Array.from(infoB.sessionIds)).toEqual(['session-b']);
+  });
+
   it('accepts a valid BridgeOptions.eventRingSize at construction time', () => {
     // Smoke: positive finite integers are accepted; the underlying
     // EventBus ring-size threading is exercised end-to-end in
@@ -5840,6 +5892,37 @@ describe('createHttpAcpBridge', () => {
       await bridge.shutdown();
     });
 
+    it('keeps a shared ACP channel alive while closing one of several sessions', async () => {
+      const handles: ChannelHandle[] = [];
+      const factory: ChannelFactory = async () => {
+        const h = makeChannel({ sessionIdPrefix: `s${handles.length}` });
+        handles.push(h);
+        return h.channel;
+      };
+      const bridge = makeBridge({
+        channelFactory: factory,
+        sessionScope: 'thread',
+      });
+      const a = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
+      const b = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
+      const c = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
+      expect(handles).toHaveLength(1);
+
+      await bridge.closeSession(b.sessionId);
+      expect(bridge.sessionCount).toBe(2);
+      expect(handles[0]?.killed).toBe(false);
+
+      await bridge.closeSession(a.sessionId);
+      expect(bridge.sessionCount).toBe(1);
+      expect(handles[0]?.killed).toBe(false);
+
+      await bridge.closeSession(c.sessionId);
+      expect(bridge.sessionCount).toBe(0);
+      expect(handles[0]?.killed).toBe(true);
+
+      await bridge.shutdown();
+    });
+
     it('throws SessionNotFoundError for unknown session', async () => {
       const bridge = makeBridge();
       await expect(bridge.closeSession('nonexistent')).rejects.toThrow(

packages/cli/src/serve/httpAcpBridge.ts

@@ -278,6 +278,33 @@ interface ChannelInfo {
   isDying: boolean;
 }
 
+/** @internal Visible for bridge lifecycle regression tests. */
+export function findChannelInfoForEntry<T extends { channel: unknown }>(
+  current: T | undefined,
+  alive: Iterable<T>,
+  entry: { channel: unknown },
+): T | undefined {
+  if (current?.channel === entry.channel) return current;
+  for (const info of alive) {
+    if (info.channel === entry.channel) return info;
+  }
+  return undefined;
+}
+
+/** @internal Visible for bridge lifecycle regression tests. */
+export function detachSessionIdFromEntryChannel<
+  T extends { channel: unknown; sessionIds: Set<string> },
+>(
+  current: T | undefined,
+  alive: Iterable<T>,
+  entry: { channel: unknown },
+  sessionId: string,
+): T | undefined {
+  const info = findChannelInfoForEntry(current, alive, entry);
+  info?.sessionIds.delete(sessionId);
+  return info;
+}
+
 interface SessionEntry {
   sessionId: string;
   workspaceCwd: string;
@@ -2031,15 +2058,8 @@ export function createHttpAcpBridge(opts: BridgeOptions): HttpAcpBridge {
     return channelInfo;
   };
 
-  const channelInfoForEntry = (
-    entry: SessionEntry,
-  ): ChannelInfo | undefined => {
-    if (channelInfo?.channel === entry.channel) return channelInfo;
-    for (const info of aliveChannels) {
-      if (info.channel === entry.channel) return info;
-    }
-    return undefined;
-  };
+  const channelInfoForEntry = (entry: SessionEntry): ChannelInfo | undefined =>
+    findChannelInfoForEntry(channelInfo, aliveChannels, entry);
 
   const getChannelClosedReject = (info: ChannelInfo): Promise<never> => {
     if (!info.statusClosedReject) {
@@ -2887,10 +2907,12 @@ export function createHttpAcpBridge(opts: BridgeOptions): HttpAcpBridge {
             : ''),
       );
       if (defaultEntry === entry) defaultEntry = undefined;
-      const ci = channelInfo;
-      if (ci && ci.channel === entry.channel) {
-        ci.sessionIds.delete(sessionId);
-      }
+      const ci = detachSessionIdFromEntryChannel(
+        channelInfo,
+        aliveChannels,
+        entry,
+        sessionId,
+      );
       for (const id of Array.from(entry.pendingPermissionIds)) {
         resolvePending(id, { outcome: { outcome: 'cancelled' } });
       }
@@ -3717,10 +3739,12 @@ export function createHttpAcpBridge(opts: BridgeOptions): HttpAcpBridge {
       // Detach from the channel. The channel dies only when its LAST
       // session leaves — other sessions on the same channel keep
       // running.
-      const ci = channelInfo;
-      if (ci && ci.channel === entry.channel) {
-        ci.sessionIds.delete(sessionId);
-      }
+      const ci = detachSessionIdFromEntryChannel(
+        channelInfo,
+        aliveChannels,
+        entry,
+        sessionId,
+      );
       // PR 14b fix (codex round 5): tombstone the killed sessionId
       // so any in-flight `extNotification` from the (about-to-be-
       // killed) child can't seed the early-event buffer for a