feat(desktop): preserve Side Conversations across linked-session navigation

apps/desktop/renderer-architecture.json

@@ -853,7 +853,7 @@
           "react": 1
         },
         "importSpecifiers": 103,
-        "nonTriviaTokens": 13381
+        "nonTriviaTokens": 13379
       },
       "src/renderer/use-app-shell-composer-quotes.ts": {
         "importDeclarations": 2,

apps/desktop/src/main/__tests__/quote-companion-retry.test.ts

@@ -3301,6 +3301,7 @@ function QuoteCompanionProbe(props: {
   const sourceSession = props.sourceSession ?? SOURCE_SESSION;
   const companion = useQuoteCompanion({
     panelId: 'retry-panel',
+    sourceSessionId: sourceSession.id,
     pendingQuotes: [],
     sourceSession,
     modelChoices: props.modelChoices ?? [choiceFor(sourceSession)],
@@ -3332,6 +3333,7 @@ function QuoteCompanionOwnershipProbe(props: {
   const sourceSession = props.sourceSession ?? SOURCE_SESSION;
   const companion = useQuoteCompanion({
     panelId: 'ownership-panel',
+    sourceSessionId: sourceSession.id,
     pendingQuotes: props.pendingQuotes ?? [],
     sourceSession,
     modelChoices: props.modelChoices ?? [choiceFor(sourceSession)],

apps/desktop/src/main/__tests__/workbar-controller.test.ts

@@ -25,6 +25,7 @@ import type { ShellRunUpdate } from '@maka/core/events';
 import type { SessionSummary } from '@maka/core/session';
 import type { WorkBoardActiveItem, WorkBoardItem, WorkBoardLinkedSession } from '@maka/core/work-board';
 import { LocaleProvider, type ToastApi } from '@maka/ui';
+import { pendingSessionView } from '../../renderer/pending-session-view.js';
 import { cleanupFakeDom, installReactRenderer } from './fake-dom.js';
 import { TerminalCloseIntents } from '../terminal-close-intents.js';
 import type { TerminalCloseChange } from '../../shared/runtime-host-identity.js';
@@ -72,6 +73,15 @@ function shellUpdate(sessionId: string, ref: string): ShellRunUpdate {
     result: { ref },
   } as ShellRunUpdate;
 }
+
+function pendingSession(sessionId: string): SessionSummary {
+  return pendingSessionView({
+    sessionId,
+    name: sessionId,
+    permissionMode: 'ask',
+  });
+}
+
 let latestController: WorkbarController | undefined;
 let latestTaskEntryController: TaskEntryController | undefined;
 let controllerRenderSnapshots: Array<{
@@ -169,14 +179,17 @@ function createFakeToastApi(errors: string[] = []): ToastApi {
 function input(
   activeSession: SessionSummary | undefined,
   toastApi: ToastApi = createFakeToastApi(),
+  sessionCatalog?: readonly SessionSummary[],
 ): UseWorkbarControllerInput {
+  const sessions = sessionCatalog ?? (activeSession ? [activeSession] : []);
   return {
     available: true,
     layoutSessionId: activeSession?.id,
     activeSession,
+    sessions,
     projectId: activeSession?.projectId,
     projectAliases: [],
-    authoritativeSessionIds: new Set(['a', 'b', ...(activeSession ? [activeSession.id] : [])]),
+    authoritativeSessionIds: new Set(['a', 'b', ...sessions.map((session) => session.id)]),
     shellObscured: false,
     modelChoices: [],
     toastApi,
@@ -941,6 +954,240 @@ describe('useWorkbarController', () => {
     );
   });
 
+  it('preserves Side Chat across linked child navigation and restores its tabs', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const child = session('child');
+    child.subagent = { parentSessionId: parent.id };
+    const services = createFakeWorkbarServices();
+    const sessions = [parent, child];
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), sessions)));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panel = controller().host.quotes?.[0];
+    assert.ok(panel);
+    const tab = controller().host.panelsState.right.tabs.find(
+      (candidate) => candidate.id === `side-chat:${panel.id}`,
+    );
+    assert.ok(tab);
+    await act(async () => controller().host.onActivityStateChange?.(panel.id, true));
+
+    await act(async () => renderController(root, services, input(child, createFakeToastApi(), sessions)));
+
+    assert.equal(controller().host.quotes?.[0], panel);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === tab.id,
+      ),
+      true,
+    );
+    assert.equal(controller().host.activeSideChatPanelIds?.has(panel.id), true);
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), sessions)));
+    assert.equal(controller().host.quotes?.[0], panel);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === tab.id,
+      ),
+      true,
+    );
+  });
+
+  it('retains Side Chat across source revision updates', async () => {
+    const { root } = installReactRenderer();
+    const services = createFakeWorkbarServices();
+    const source = session('source-a');
+    source.revisionRootSessionId = 'source-root';
+    const sourceRevision = session('source-a-revision');
+    sourceRevision.revisionRootSessionId = 'source-root';
+    const child = session('child-a');
+    child.subagent = { parentSessionId: sourceRevision.id };
+
+    await act(async () =>
+      renderController(root, services, input(source, createFakeToastApi(), [source])),
+    );
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+
+    await act(async () =>
+      renderController(root, services, input(sourceRevision, createFakeToastApi(), [source, sourceRevision, child])),
+    );
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), true);
+
+    await act(async () =>
+      renderController(root, services, input(child, createFakeToastApi(), [source, sourceRevision, child])),
+    );
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), true);
+  });
+
+  it('retains the source and Side Chat through a pending child catalog gap', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const child = session('child');
+    child.subagent = { parentSessionId: parent.id };
+    const services = createFakeWorkbarServices();
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), [parent])));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+
+    await act(async () => renderController(root, services, {
+      ...input(undefined, createFakeToastApi(), [parent]),
+      layoutSessionId: child.id,
+    }));
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), true);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === `side-chat:${panelId}`,
+      ),
+      true,
+    );
+
+    await act(async () => renderController(root, services, input(child, createFakeToastApi(), [parent, child])));
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), true);
+  });
+
+  it('cleans Side Chat when its source is deleted during a pending navigation', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const services = createFakeWorkbarServices();
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), [parent])));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+    await act(async () => renderController(root, services, {
+      ...input(undefined, createFakeToastApi(), []), layoutSessionId: 'child',
+    }));
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), false);
+    assert.equal(controller().host.panelsState.right.tabs.some(
+      (tab) => tab.id === `side-chat:${panelId}`,
+    ), false);
+  });
+
+  it('cleans Side Chat when a new task clears the active Session', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const services = createFakeWorkbarServices();
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), [parent])));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+
+    await act(async () => renderController(root, services, input(undefined, createFakeToastApi(), [parent])));
+
+    assert.equal(controller().host.activeId, undefined);
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), false);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === `side-chat:${panelId}`,
+      ),
+      false,
+    );
+  });
+
+  it('cleans Side Chat for an uncataloged unrelated Session', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const unrelated = session('unrelated');
+    const services = createFakeWorkbarServices();
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), [parent])));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+
+    await act(async () => renderController(root, services, input(unrelated, createFakeToastApi(), [parent])));
+
+    assert.equal(controller().host.activeId, unrelated.id);
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), false);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === `side-chat:${panelId}`,
+      ),
+      false,
+    );
+  });
+
+  it('keeps the remaining Side Chat when one of multiple source panels closes', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const child = session('child');
+    child.subagent = { parentSessionId: parent.id };
+    const sessions = [parent, child];
+    const services = createFakeWorkbarServices();
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), sessions)));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const parentPanelId = controller().host.quotes?.[0]?.id;
+    assert.ok(parentPanelId);
+
+    await act(async () => renderController(root, services, input(child, createFakeToastApi(), sessions)));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const childPanel = controller().host.quotes?.find(
+      (panel) => panel.sourceSessionId === child.id,
+    );
+    assert.ok(childPanel);
+
+    const parentTab = controller().host.panelsState.right.tabs.find(
+      (tab) => tab.id === `side-chat:${parentPanelId}`,
+    );
+    assert.ok(parentTab);
+    await act(async () => controller().host.onCloseTab('right', parentTab));
+
+    assert.equal(
+      controller().host.quotes?.some((panel) => panel.id === childPanel.id),
+      true,
+    );
+  });
+
+  it('cleans Side Chat when its source Session is removed', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const child = session('child');
+    child.subagent = { parentSessionId: parent.id };
+    const services = createFakeWorkbarServices();
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), [parent, child])));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+
+    await act(async () => renderController(root, services, input(child, createFakeToastApi(), [child])));
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), false);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === `side-chat:${panelId}`,
+      ),
+      false,
+    );
+  });
+
+  it('cleans a child-owned Side Chat when navigating back to its parent', async () => {
+    const { root } = installReactRenderer();
+    const parent = session('parent');
+    const child = session('child');
+    child.subagent = { parentSessionId: parent.id };
+    const sessions = [parent, child];
+    const services = createFakeWorkbarServices();
+
+    await act(async () => renderController(root, services, input(child, createFakeToastApi(), sessions)));
+    await act(async () => controller().commands.openTool('side-chat'));
+    const panelId = controller().host.quotes?.[0]?.id;
+    assert.ok(panelId);
+
+    await act(async () => renderController(root, services, input(parent, createFakeToastApi(), sessions)));
+    assert.equal(controller().host.quotes?.some((panel) => panel.id === panelId), false);
+    assert.equal(
+      controller().host.panelsState.right.tabs.some(
+        (candidate) => candidate.id === `side-chat:${panelId}`,
+      ),
+      false,
+    );
+  });
+
   it('keeps a newly created companion hidden through panel changes and stale catalogs until cleanup', async () => {
     const { root } = installReactRenderer();
     const services = createFakeWorkbarServices();

apps/desktop/src/renderer/app-shell.tsx

@@ -1342,9 +1342,10 @@ function AppShellContent({
     available: workbarAvailable,
     layoutSessionId: activeId,
     activeSession: activeHostSession,
+    sessions,
     projectId: currentProjectId,
     projectAliases: currentProject?.aliases ?? [],
-    authoritativeSessionIds: authoritativeSessionIds ?? undefined,
+    authoritativeSessionIds,
     shellObscured,
     modelChoices: chatModelChoices,
     toastApi,

apps/desktop/src/renderer/features/workbar/README.md

@@ -21,8 +21,10 @@
 
 Workbar is a vertical renderer feature. Its application-level model owns the
 right/bottom panel topology, active tabs, dimensions and persisted collapse
-state. Tool data remains session-scoped, and the session content surface is
-remounted when the active session changes.
+state. Tool data remains session-scoped. The content surface stays mounted
+across navigation; tools receive a new `sessionId` in place and must reset
+any session-derived data themselves. Side Chat keeps its immutable source owner
+while navigating that source's revision family and linked descendants.
 
 ## Dependency direction
 
@@ -80,7 +82,9 @@ remounted when the active session changes.
 - Removing a Session from the authoritative catalog retires its Terminal views.
   Host owns admission of Session retirement while processes are live.
 - Side Chat survives panel collapse and is cleaned only when its tab closes or
-  when navigation leaves its source session.
+  when navigation leaves its source Session and linked descendants. Unknown
+  navigation targets defer cleanup only while the previous source remains in
+  the current catalog.
 - Fork creation hides the internal Session until cleanup succeeds. Catalog
   absence does not confirm cleanup because a snapshot may predate creation.
 - Disposed Side Chat operations are fenced at every fork/send boundary; a late