@@ -16,9 +16,9 @@ export function SideChatSurface({ parentSessionId, sideChatId, visible = true }:
   const empty = useChatStore(state => !state.sessions[sideChatId]?.messages.length && !state.sessions[sideChatId]?.streamingText && (state.sessions[sideChatId]?.chatState ?? 'idle') === 'idle')
   const released = useChatStore(state => (state.sessions[sideChatId]?.connectionState ?? 'disconnected') === 'disconnected')
   const owned = Boolean(entry && entry.parentSessionId === parentSessionId)
-  // Reconnect a lost transport when shown. Hidden-session cleanup keeps this
-  // temporary runtime connected: its CLI context cannot be restored from the
-  // cached transcript after the server reclaims it.
+  // A side chat is released with its parent once the parent leaves the warm
+  // set (hiddenSessionRelease); showing it again reconnects on top of the
+  // transcript it kept.
   useEffect(() => {
     if (owned && visible && released) {
       useChatStore.getState().connectToSession(sideChatId, { prewarm: false, applyRuntimeSelection: false })
 
@@ -9,7 +9,6 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import '@testing-library/jest-dom'
 
 const notifyDesktopMock = vi.hoisted(() => vi.fn())
-const discardSideChatMock = vi.hoisted(() => vi.fn(async () => ({})))
 const sessionsApiMock = vi.hoisted(() => ({
   delete: vi.fn(() => Promise.resolve()),
   getSlashCommands: vi.fn(async () => ({ commands: [] })),
@@ -19,7 +18,6 @@ const sessionsApiMock = vi.hoisted(() => ({
 }))
 
 vi.mock('../api/sessions', () => ({ sessionsApi: sessionsApiMock }))
-vi.mock('../api/sideChats', () => ({ sideChatsApi: { discard: discardSideChatMock } }))
 vi.mock('../api/teams', () => ({ teamsApi: { getWorkbenchForSession: vi.fn() } }))
 vi.mock('../lib/desktopNotifications', () => ({ notifyDesktop: notifyDesktopMock }))
 
@@ -30,7 +28,6 @@ import { registerSideChatSession, unregisterSideChatSession } from '../lib/sideC
 import { WARM_SESSION_LIMIT, useTabStore, type Tab } from './tabStore'
 import { useTeamStore } from './teamStore'
 import { useSessionStore } from './sessionStore'
-import { useSideChatStore } from './sideChatStore'
 import { navigateMobileUp } from '../components/mobile/mobileNavigation'
 import type { ServerMessage } from '../types/chat'
 
@@ -176,8 +173,6 @@ describe('releasing sessions that no tab shows (#1485)', () => {
     wsManager.disconnectAll()
     disconnectSpy = vi.spyOn(wsManager, 'disconnect')
     notifyDesktopMock.mockClear()
-    discardSideChatMock.mockClear()
-    useSideChatStore.setState({ entries: {} })
     uninstall = installHiddenSessionRelease(useChatStore)
 
     class ResizeObserverMock {
@@ -432,64 +427,28 @@ describe('releasing sessions that no tab shows (#1485)', () => {
     expect(isHeld('source')).toBe(false)
   })
 
-  it.each([
-    { scope: 'open-tabs' as const, finishesWhileHidden: false },
-    { scope: 'open-tabs' as const, finishesWhileHidden: true },
-    { scope: 'active-tab' as const, finishesWhileHidden: false },
-    { scope: 'active-tab' as const, finishesWhileHidden: true },
-  ])('keeps a temporary side chat usable until explicitly closed ($scope, finishes while hidden: $finishesWhileHidden)', async ({ scope, finishesWhileHidden }) => {
-    uninstall()
-    uninstall = installHiddenSessionRelease(useChatStore, { scope })
+  it('releases a side chat with its parent once both are done, keeping its transcript', async () => {
     registerSideChatSession('side-of-parent', 'parent')
     try {
-      useSideChatStore.setState({ entries: {
-        'side-of-parent': { sessionId: 'side-of-parent', parentSessionId: 'parent', workDir: '/repo', title: 'Side chat', ephemeral: true },
-      } })
       useTabStore.setState({ tabs: [sessionTab('parent', 'Parent chat')], activeTabId: 'parent' })
       const parentSocket = connect('parent')
       const sideSocket = connect('side-of-parent')
       serverSays(parentSocket, TURN_COMPLETE)
-      serverSays(sideSocket, cliRun('running'))
       serverSays(sideSocket, { type: 'status', state: 'thinking' })
-      for (const message of replyText('Side chat context.')) serverSays(sideSocket, message)
-      if (!finishesWhileHidden) {
-        serverSays(sideSocket, TURN_COMPLETE)
-        serverSays(sideSocket, cliRun('idle'))
-      }
       await settle()
+      act(() => { vi.advanceTimersByTime(EIGHTEEN_HOURS_MS) })
+      // While the parent is in the warm set its workspace, side chat included, stays.
+      expect(isHeld('side-of-parent')).toBe(true)
 
       moveOnFrom('parent')
       await settle()
       expect(isHeld('parent')).toBe(false)
-      if (finishesWhileHidden) {
-        serverSays(sideSocket, TURN_COMPLETE)
-        serverSays(sideSocket, cliRun('idle'))
-      }
-      await settle()
-      // #1513 released this socket when the parent left the warm set. The
-      // server then destroyed the non-persistent CLI after its idle grace,
-      // and a later send failed with SESSION_DELETED despite cached messages.
-      act(() => { vi.advanceTimersByTime(EIGHTEEN_HOURS_MS) })
-      await settle()
-      expect(sideSocket.closedByClient).toBe(false)
+      // Still answering: it finishes first.
       expect(isHeld('side-of-parent')).toBe(true)
-      expect(disconnectSpy).not.toHaveBeenCalledWith('side-of-parent')
 
-      act(() => useTabStore.getState().openTab('parent', 'Parent chat'))
-      act(() => useChatStore.getState().sendMessage('side-of-parent', 'Continue the side chat'))
-      expect(socketsFor('side-of-parent')).toEqual([sideSocket])
-      expect(sideSocket.sent).toContainEqual(expect.objectContaining({ type: 'user_message', content: 'Continue the side chat' }))
-      expect(useChatStore.getState().sessions['side-of-parent']?.messages).toContainEqual(expect.objectContaining({ type: 'assistant_text', content: 'Side chat context.' }))
       serverSays(sideSocket, TURN_COMPLETE)
-      serverSays(sideSocket, cliRun('idle'))
       await settle()
-
-      await act(async () => { await useSideChatStore.getState().close('side-of-parent') })
-      expect(discardSideChatMock).toHaveBeenCalledWith('parent', 'side-of-parent')
-      expect(sideSocket.closedByClient).toBe(true)
-      expect(isHeld('side-of-parent')).toBe(false)
-      expect(useChatStore.getState().sessions['side-of-parent']).toBeUndefined()
-      expect(useSideChatStore.getState().entries['side-of-parent']).toBeUndefined()
+      expectReleasedWithTranscript('side-of-parent')
     } finally {
       unregisterSideChatSession('side-of-parent')
     }
 
@@ -94,15 +94,15 @@ function isCliStillWorking(session: PerSessionState): boolean {
  * was kept for is done. Kept: a pending prompt (the user's move; its
  * notification or the waiting list brings them back), a CLI still running
  * background work, and a team lead, whose socket carries every member's
- * approvals and team events. Temporary side chats also stay connected until
- * explicitly closed: their CLI context is not persisted, so reclaiming the
- * runtime would make the conversation impossible to resume.
+ * approvals and team events. Side chats are shown by their parent's workspace
+ * and released with it.
  *
  * Releasing never drops the transcript, draft or queued messages. Chats leave
  * the desktop's warm set on their own (`WARM_SESSION_LIMIT`), not because
  * someone closed them, so going back has to find the conversation where it
  * was. The chat store's history budget bounds the cached messages, and
  * `RELEASED_TRANSCRIPT_LIMIT` bounds how many released records are kept.
+ * A side chat is released with its parent and reconnects when shown again.
  */
 export function installHiddenSessionRelease(
   chatStore: Pick<StoreApi<HiddenSessionChatState>, 'getState' | 'subscribe'>,
@@ -138,7 +138,6 @@ export function installHiddenSessionRelease(
     const session = sessions[sessionId]
     if (
       !session ||
-      isSideChatSession(sessionId) ||
       isShown(sessionId, scope) ||
       !wsManager.getConnectedSessionIds().includes(sessionId) ||
       hasForegroundWork(session) ||
@@ -152,8 +151,7 @@ export function installHiddenSessionRelease(
     pruneReleased()
   }
 
-  // Recheck workspace sessions with their parent; the release guard keeps
-  // temporary side chats alive even when the parent is no longer shown.
+  // A parent leaving the screen takes its side chats with it.
   const scheduleWithSideChats = (sessionId: string) => {
     schedule(sessionId)
     for (const id in chatStore.getState().sessions) {