From 9bd1047e59d99404b14ab62e38528d639e1e651c Mon Sep 17 00:00:00 2001
From: Rod-fernandez <rodrigo@nxtlevelsaas.com>
Date: Sat, 4 Jul 2026 02:14:39 -0400
Subject: [PATCH 1/6] feat(desktop): add Kanban board UI
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Board overlay (CronView pattern) over the existing /api/plugins/kanban
backend: 8 dnd-kit columns in BOARD_COLUMNS order, card drawer with
comments/events/runs/worker-log/attachments/DAG links, new-card dialog,
board switcher, dispatcher nudge.

- HOME-scoped by design: no profileScoped()/?profile= on kanban routes.
- Server-authoritative mutations: optimistic moves reconcile from the
  server response (rule bounces like done→review render where the server
  put them, with an info toast); 409s revert with the backend's detail.
- 'running' is never a drag target (backend 400s direct PATCH; ready→
  running only via dispatcher claim) — Nudge dispatcher instead.
- 4s visibility-gated polling with latest_event_id cursor (atom identity
  preserved when unchanged); overlay wrapped in its own ErrorBoundary.
- parseKanbanApiError unwraps the Electron IPC error prefix so HTTP
  status/detail survive the bridge.
- i18n en+zh (+types); ja/zh-hant fall back to English.
- 22 vitest cases (store rules, move/revert/bounce, cursor identity,
  component smoke via mocked hermes:api).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/src/app/chat/sidebar/index.tsx   |   6 +-
 .../desktop/src/app/command-palette/index.tsx |  10 +
 apps/desktop/src/app/desktop-controller.tsx   |   9 +
 apps/desktop/src/app/hooks/use-keybinds.ts    |   2 +
 apps/desktop/src/app/kanban/card-drawer.tsx   | 547 ++++++++++++++++++
 apps/desktop/src/app/kanban/index.test.tsx    | 159 +++++
 apps/desktop/src/app/kanban/index.tsx         | 441 ++++++++++++++
 .../src/app/kanban/new-card-dialog.tsx        | 245 ++++++++
 apps/desktop/src/app/routes.ts                |   7 +-
 .../app/shell/hooks/use-overlay-routing.ts    |   2 +
 apps/desktop/src/app/types.ts                 |   9 +-
 apps/desktop/src/i18n/en.ts                   |  79 ++-
 apps/desktop/src/i18n/types.ts                |  65 +++
 apps/desktop/src/i18n/zh.ts                   |  79 ++-
 apps/desktop/src/kanban-api.ts                | 179 ++++++
 apps/desktop/src/lib/icons.ts                 |   2 +
 apps/desktop/src/lib/keybinds/actions.ts      |   1 +
 apps/desktop/src/store/kanban.test.ts         | 336 +++++++++++
 apps/desktop/src/store/kanban.ts              | 231 ++++++++
 apps/desktop/src/types/kanban.ts              | 229 ++++++++
 20 files changed, 2632 insertions(+), 6 deletions(-)
 create mode 100644 apps/desktop/src/app/kanban/card-drawer.tsx
 create mode 100644 apps/desktop/src/app/kanban/index.test.tsx
 create mode 100644 apps/desktop/src/app/kanban/index.tsx
 create mode 100644 apps/desktop/src/app/kanban/new-card-dialog.tsx
 create mode 100644 apps/desktop/src/kanban-api.ts
 create mode 100644 apps/desktop/src/store/kanban.test.ts
 create mode 100644 apps/desktop/src/store/kanban.ts
 create mode 100644 apps/desktop/src/types/kanban.ts

diff --git a/apps/desktop/src/app/chat/sidebar/index.tsx b/apps/desktop/src/app/chat/sidebar/index.tsx
index 416483dde427c..b97a1c0e5f5ba 100644
--- a/apps/desktop/src/app/chat/sidebar/index.tsx
+++ b/apps/desktop/src/app/chat/sidebar/index.tsx
@@ -95,7 +95,7 @@ import {
   setCurrentCwd
 } from '@/store/session'
 
-import { type AppView, ARTIFACTS_ROUTE, MESSAGING_ROUTE, SKILLS_ROUTE } from '../../routes'
+import { type AppView, ARTIFACTS_ROUTE, KANBAN_ROUTE, MESSAGING_ROUTE, SKILLS_ROUTE } from '../../routes'
 import type { SidebarNavItem } from '../../types'
 
 import { countLabel } from './chrome'
@@ -144,7 +144,8 @@ const SIDEBAR_NAV: SidebarNavItem[] = [
     route: SKILLS_ROUTE
   },
   { id: 'messaging', label: '', icon: props => <Codicon name="comment" {...props} />, route: MESSAGING_ROUTE },
-  { id: 'artifacts', label: '', icon: props => <Codicon name="files" {...props} />, route: ARTIFACTS_ROUTE }
+  { id: 'artifacts', label: '', icon: props => <Codicon name="files" {...props} />, route: ARTIFACTS_ROUTE },
+  { id: 'kanban', label: '', icon: props => <Codicon name="project" {...props} />, route: KANBAN_ROUTE }
 ]
 
 // Two modes via the `compact` height variant (styles.css):
@@ -1051,6 +1052,7 @@ export function ChatSidebar({
                 const isInteractive = Boolean(item.action) || Boolean(item.route)
 
                 const active =
+                  (item.id === 'kanban' && currentView === 'kanban') ||
                   (item.id === 'skills' && currentView === 'skills') ||
                   (item.id === 'messaging' && currentView === 'messaging') ||
                   (item.id === 'artifacts' && currentView === 'artifacts')
diff --git a/apps/desktop/src/app/command-palette/index.tsx b/apps/desktop/src/app/command-palette/index.tsx
index be89ebb4e128a..859c3ae11d2c3 100644
--- a/apps/desktop/src/app/command-palette/index.tsx
+++ b/apps/desktop/src/app/command-palette/index.tsx
@@ -25,6 +25,7 @@ import {
   Globe,
   type IconComponent,
   Info,
+  Kanban,
   KeyRound,
   Layers3,
   MessageCircle,
@@ -68,6 +69,7 @@ import {
   ARTIFACTS_ROUTE,
   COMMAND_CENTER_ROUTE,
   CRON_ROUTE,
+  KANBAN_ROUTE,
   MESSAGING_ROUTE,
   NEW_CHAT_ROUTE,
   PROFILES_ROUTE,
@@ -453,6 +455,14 @@ export function CommandPalette() {
             label: t.shell.statusbar.cron,
             run: go(CRON_ROUTE)
           },
+          {
+            action: 'nav.kanban',
+            icon: Kanban,
+            id: 'nav-kanban',
+            keywords: ['kanban', 'board', 'tasks', 'cards', 'dispatcher'],
+            label: t.kanban.title,
+            run: go(KANBAN_ROUTE)
+          },
           { action: 'nav.profiles', icon: Users, id: 'nav-profiles', label: t.profiles.title, run: go(PROFILES_ROUTE) },
           { action: 'nav.agents', icon: Cpu, id: 'nav-agents', label: t.agents.title, run: go(AGENTS_ROUTE) },
           {
diff --git a/apps/desktop/src/app/desktop-controller.tsx b/apps/desktop/src/app/desktop-controller.tsx
index 4b8c249bced68..0695a15638dc1 100644
--- a/apps/desktop/src/app/desktop-controller.tsx
+++ b/apps/desktop/src/app/desktop-controller.tsx
@@ -131,6 +131,7 @@ const AgentsView = lazy(async () => ({ default: (await import('./agents')).Agent
 const ArtifactsView = lazy(async () => ({ default: (await import('./artifacts')).ArtifactsView }))
 const CommandCenterView = lazy(async () => ({ default: (await import('./command-center')).CommandCenterView }))
 const CronView = lazy(async () => ({ default: (await import('./cron')).CronView }))
+const KanbanView = lazy(async () => ({ default: (await import('./kanban')).KanbanView }))
 const StarmapView = lazy(async () => ({ default: (await import('./starmap')).StarmapView }))
 const MessagingView = lazy(async () => ({ default: (await import('./messaging')).MessagingView }))
 const ProfilesView = lazy(async () => ({ default: (await import('./profiles')).ProfilesView }))
@@ -221,6 +222,7 @@ export function DesktopController() {
     commandCenterOpen,
     cronOpen,
     currentView,
+    kanbanOpen,
     openAgents,
     openCommandCenterSection,
     openStarmap,
@@ -1118,6 +1120,12 @@ export function DesktopController() {
         </Suspense>
       )}
 
+      {kanbanOpen && (
+        <Suspense fallback={null}>
+          <KanbanView onClose={closeOverlayToPreviousRoute} />
+        </Suspense>
+      )}
+
       {profilesOpen && (
         <Suspense fallback={null}>
           <ProfilesView onClose={closeOverlayToPreviousRoute} />
@@ -1338,6 +1346,7 @@ export function DesktopController() {
             path="artifacts"
           />
           <Route element={null} path="cron" />
+          <Route element={null} path="kanban" />
           <Route element={null} path="profiles" />
           <Route element={null} path="settings" />
           <Route element={null} path="command-center" />
diff --git a/apps/desktop/src/app/hooks/use-keybinds.ts b/apps/desktop/src/app/hooks/use-keybinds.ts
index 379c719ad0363..68dbb4ceafad7 100644
--- a/apps/desktop/src/app/hooks/use-keybinds.ts
+++ b/apps/desktop/src/app/hooks/use-keybinds.ts
@@ -50,6 +50,7 @@ import {
   AGENTS_ROUTE,
   ARTIFACTS_ROUTE,
   CRON_ROUTE,
+  KANBAN_ROUTE,
   MESSAGING_ROUTE,
   PROFILES_ROUTE,
   sessionRoute,
@@ -128,6 +129,7 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void {
     'nav.messaging': () => navigate(MESSAGING_ROUTE),
     'nav.artifacts': () => navigate(ARTIFACTS_ROUTE),
     'nav.cron': () => navigate(CRON_ROUTE),
+    'nav.kanban': () => navigate(KANBAN_ROUTE),
     'nav.agents': () => navigate(AGENTS_ROUTE),
 
     'session.new': () => {
diff --git a/apps/desktop/src/app/kanban/card-drawer.tsx b/apps/desktop/src/app/kanban/card-drawer.tsx
new file mode 100644
index 0000000000000..9814e2657fda9
--- /dev/null
+++ b/apps/desktop/src/app/kanban/card-drawer.tsx
@@ -0,0 +1,547 @@
+import { useStore } from '@nanostores/react'
+import { useCallback, useEffect, useState } from 'react'
+
+import { Button } from '@/components/ui/button'
+import { Codicon } from '@/components/ui/codicon'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { Textarea } from '@/components/ui/textarea'
+import { type Translations, useI18n } from '@/i18n'
+import { addKanbanComment, getKanbanAssignees, getKanbanTask, getKanbanTaskLog, updateKanbanTask } from '@/kanban-api'
+import { cn } from '@/lib/utils'
+import {
+  $kanbanActiveBoard,
+  $kanbanBoard,
+  allowedDropColumns,
+  applyKanbanTaskPatch,
+  refreshKanbanBoard,
+  setKanbanSelectedTaskId
+} from '@/store/kanban'
+import { notify, notifyError } from '@/store/notifications'
+import type { KanbanRun, KanbanTaskDetail, KanbanUpdateTaskPayload } from '@/types/kanban'
+
+import { PanelBlock, PanelPill, type PanelPillTone, PanelSectionLabel } from '../overlays/panel'
+
+// Sentinel for the Radix Select "unassigned" row (empty item values are not
+// allowed); mapped to `assignee: ''` on PATCH, which unassigns server-side.
+const UNASSIGNED = '__unassigned__'
+
+const RUN_TONE: Record<string, PanelPillTone> = {
+  running: 'good',
+  done: 'good',
+  blocked: 'warn',
+  released: 'muted',
+  reclaimed: 'muted',
+  crashed: 'bad',
+  failed: 'bad',
+  timed_out: 'bad'
+}
+
+function formatEpoch(seconds?: null | number): string {
+  if (!seconds) {
+    return '—'
+  }
+
+  const date = new Date(seconds * 1000)
+
+  return Number.isNaN(date.valueOf()) ? '—' : date.toLocaleString()
+}
+
+function formatBytes(size?: null | number): string {
+  if (size === null || size === undefined) {
+    return '—'
+  }
+
+  if (size < 1024) {
+    return `${size} B`
+  }
+
+  if (size < 1024 * 1024) {
+    return `${(size / 1024).toFixed(1)} KB`
+  }
+
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`
+}
+
+interface KanbanCardDrawerProps {
+  onClose: () => void
+  taskId: string
+}
+
+export function KanbanCardDrawer({ onClose, taskId }: KanbanCardDrawerProps) {
+  const { t } = useI18n()
+  const k = t.kanban
+  const board = useStore($kanbanBoard)
+  const activeBoard = useStore($kanbanActiveBoard)
+
+  const [detail, setDetail] = useState<KanbanTaskDetail | null>(null)
+  const [loadError, setLoadError] = useState<null | string>(null)
+  const [assignees, setAssignees] = useState<string[]>([])
+  const [saving, setSaving] = useState(false)
+  const [commentDraft, setCommentDraft] = useState('')
+  const [sendingComment, setSendingComment] = useState(false)
+
+  const reload = useCallback(async () => {
+    try {
+      setDetail(await getKanbanTask(taskId, $kanbanActiveBoard.get()))
+      setLoadError(null)
+    } catch (error) {
+      setLoadError(error instanceof Error ? error.message : String(error))
+    }
+  }, [taskId])
+
+  useEffect(() => {
+    void reload()
+    // Re-pull the detail whenever the board cursor moves — comments/events/runs
+    // append task_events rows, so the cursor is a reliable staleness signal.
+  }, [reload, board?.latest_event_id])
+
+  useEffect(() => {
+    let cancelled = false
+
+    getKanbanAssignees(activeBoard)
+      .then(list => {
+        if (!cancelled) {
+          setAssignees(list.map(entry => entry.name))
+        }
+      })
+      .catch(() => undefined)
+
+    return () => {
+      cancelled = true
+    }
+  }, [activeBoard])
+
+  const patchTask = useCallback(
+    async (updates: KanbanUpdateTaskPayload) => {
+      setSaving(true)
+
+      try {
+        const response = await updateKanbanTask(taskId, updates, $kanbanActiveBoard.get())
+
+        // Server-authoritative: render whatever came back (a status PATCH may
+        // land on a different column than requested under local board rules).
+        if (response.task) {
+          applyKanbanTaskPatch(response.task)
+
+          if (updates.status && response.task.status !== updates.status) {
+            notify({
+              kind: 'info',
+              message: k.movedByRules(k.columnLabels[response.task.status] ?? response.task.status)
+            })
+          }
+        }
+
+        await reload()
+        void refreshKanbanBoard()
+      } catch (error) {
+        notifyError(error, k.updateFailed)
+        // Refetch so the editors snap back to the server's state.
+        await reload()
+      } finally {
+        setSaving(false)
+      }
+    },
+    [k, reload, taskId]
+  )
+
+  async function submitComment() {
+    const body = commentDraft.trim()
+
+    if (!body || sendingComment) {
+      return
+    }
+
+    setSendingComment(true)
+
+    try {
+      await addKanbanComment(taskId, body, $kanbanActiveBoard.get())
+      setCommentDraft('')
+      await reload()
+      void refreshKanbanBoard()
+    } catch (error) {
+      notifyError(error, k.commentFailed)
+    } finally {
+      setSendingComment(false)
+    }
+  }
+
+  const task = detail?.task
+  const statusOptions = task ? [task.status, ...allowedDropColumns(task.status)] : []
+
+  const assigneeOptions =
+    task?.assignee && !assignees.includes(task.assignee) ? [task.assignee, ...assignees] : assignees
+
+  return (
+    <aside className="flex w-80 shrink-0 flex-col overflow-hidden rounded-lg border border-(--ui-stroke-secondary) bg-(--ui-chat-surface-background)">
+      <header className="flex shrink-0 items-start justify-between gap-2 border-b border-(--ui-stroke-secondary) px-3 py-2.5">
+        <div className="min-w-0">
+          <h3 className="break-words text-[0.85rem] font-semibold leading-snug text-foreground">
+            {task?.title ?? taskId}
+          </h3>
+          <p className="font-mono text-[0.62rem] text-muted-foreground/55">{taskId}</p>
+        </div>
+        <Button
+          aria-label={t.common.close}
+          className="shrink-0 text-(--ui-text-tertiary) hover:text-foreground"
+          onClick={onClose}
+          size="icon"
+          variant="ghost"
+        >
+          <Codicon name="close" size="0.875rem" />
+        </Button>
+      </header>
+
+      <div className="min-h-0 flex-1 space-y-4 overflow-y-auto overscroll-contain px-3 py-3">
+        {!detail && !loadError ? (
+          <div className="flex items-center gap-1.5 py-2 text-xs text-muted-foreground">
+            <Codicon name="loading" size="0.75rem" spinning />
+            {k.loadingDetail}
+          </div>
+        ) : loadError && !detail ? (
+          <div className="rounded bg-destructive/10 p-2 text-xs text-destructive">{loadError}</div>
+        ) : task ? (
+          <>
+            <section className="grid grid-cols-1 gap-2">
+              <DrawerField label={k.status}>
+                <Select
+                  disabled={saving}
+                  onValueChange={value => void patchTask({ status: value })}
+                  value={task.status}
+                >
+                  <SelectTrigger className="h-7 rounded-md text-xs">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {statusOptions.map(status => (
+                      <SelectItem key={status} value={status}>
+                        {k.columnLabels[status] ?? status}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </DrawerField>
+
+              <DrawerField label={k.assignee}>
+                <Select
+                  disabled={saving}
+                  onValueChange={value => void patchTask({ assignee: value === UNASSIGNED ? '' : value })}
+                  value={task.assignee ?? UNASSIGNED}
+                >
+                  <SelectTrigger className="h-7 rounded-md text-xs">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value={UNASSIGNED}>{k.unassigned}</SelectItem>
+                    {assigneeOptions.map(name => (
+                      <SelectItem key={name} value={name}>
+                        {name}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </DrawerField>
+
+              <DrawerField label={k.priority}>
+                <Input
+                  className="h-7 text-xs tabular-nums"
+                  defaultValue={String(task.priority)}
+                  disabled={saving}
+                  key={`priority-${task.priority}`}
+                  onBlur={event => {
+                    const next = Number.parseInt(event.target.value, 10)
+
+                    if (Number.isInteger(next) && next !== task.priority) {
+                      void patchTask({ priority: next })
+                    }
+                  }}
+                  onKeyDown={event => {
+                    if (event.key === 'Enter') {
+                      event.currentTarget.blur()
+                    }
+                  }}
+                  type="number"
+                />
+              </DrawerField>
+            </section>
+
+            <section className="space-y-1.5">
+              <PanelSectionLabel>{k.description}</PanelSectionLabel>
+              {task.body?.trim() ? (
+                <PanelBlock className="max-h-56">{task.body}</PanelBlock>
+              ) : (
+                <p className="text-xs text-muted-foreground/60">{k.noDescription}</p>
+              )}
+            </section>
+
+            {task.latest_summary?.trim() ? (
+              <section className="space-y-1.5">
+                <PanelSectionLabel>{k.latestSummary}</PanelSectionLabel>
+                <PanelBlock className="max-h-56">{task.latest_summary}</PanelBlock>
+              </section>
+            ) : null}
+
+            {(task.diagnostics?.length ?? 0) > 0 && (
+              <section className="space-y-1.5">
+                <PanelSectionLabel>{k.diagnostics}</PanelSectionLabel>
+                <div className="space-y-1">
+                  {task.diagnostics?.map(diag => (
+                    <div
+                      className={cn(
+                        'rounded p-2 text-[0.68rem] leading-relaxed',
+                        diag.severity === 'warning'
+                          ? 'bg-amber-500/10 text-amber-600 dark:text-amber-300'
+                          : 'bg-destructive/10 text-destructive'
+                      )}
+                      key={`${diag.kind}-${diag.last_seen_at}`}
+                    >
+                      <div className="font-medium">{diag.title}</div>
+                      <div className="opacity-80">{diag.detail}</div>
+                    </div>
+                  ))}
+                </div>
+              </section>
+            )}
+
+            <section className="space-y-1.5">
+              <PanelSectionLabel>{k.dependencies}</PanelSectionLabel>
+              <LinkChips ids={detail.links.parents} k={k} label={k.parents} />
+              <LinkChips ids={detail.links.children} k={k} label={k.children} />
+            </section>
+
+            <section className="space-y-1.5">
+              <PanelSectionLabel>
+                {k.comments}
+                {detail.comments.length > 0 ? ` · ${detail.comments.length}` : ''}
+              </PanelSectionLabel>
+              {detail.comments.length === 0 ? (
+                <p className="text-xs text-muted-foreground/60">{k.noComments}</p>
+              ) : (
+                <div className="space-y-1.5">
+                  {detail.comments.map(comment => (
+                    <div className="rounded bg-foreground/5 p-2" key={comment.id}>
+                      <div className="mb-0.5 flex items-baseline justify-between gap-2 text-[0.62rem] text-muted-foreground/60">
+                        <span className="truncate font-medium">{comment.author ?? '—'}</span>
+                        <span className="shrink-0 tabular-nums">{formatEpoch(comment.created_at)}</span>
+                      </div>
+                      <div className="whitespace-pre-wrap break-words text-[0.7rem] leading-relaxed text-foreground/85">
+                        {comment.body}
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              )}
+              <div className="flex flex-col gap-1.5">
+                <Textarea
+                  className="min-h-14 text-xs"
+                  onChange={event => setCommentDraft(event.target.value)}
+                  onKeyDown={event => {
+                    if (event.key === 'Enter' && (event.metaKey || event.ctrlKey)) {
+                      event.preventDefault()
+                      void submitComment()
+                    }
+                  }}
+                  placeholder={k.commentPlaceholder}
+                  value={commentDraft}
+                />
+                <Button
+                  className="self-end"
+                  disabled={sendingComment || !commentDraft.trim()}
+                  onClick={() => void submitComment()}
+                  size="sm"
+                  variant="outline"
+                >
+                  {sendingComment ? t.common.saving : k.addComment}
+                </Button>
+              </div>
+            </section>
+
+            <section className="space-y-1.5">
+              <PanelSectionLabel>
+                {k.runHistory}
+                {detail.runs.length > 0 ? ` · ${detail.runs.length}` : ''}
+              </PanelSectionLabel>
+              {detail.runs.length === 0 ? (
+                <p className="text-xs text-muted-foreground/60">{k.noRuns}</p>
+              ) : (
+                <div className="space-y-1">
+                  {detail.runs.map(run => (
+                    <RunRow k={k} key={run.id} run={run} />
+                  ))}
+                </div>
+              )}
+              <WorkerLogSection k={k} taskId={taskId} />
+            </section>
+
+            <section className="space-y-1.5">
+              <PanelSectionLabel>
+                {k.attachments}
+                {detail.attachments.length > 0 ? ` · ${detail.attachments.length}` : ''}
+              </PanelSectionLabel>
+              {detail.attachments.length === 0 ? (
+                <p className="text-xs text-muted-foreground/60">{k.noAttachments}</p>
+              ) : (
+                <div className="space-y-px">
+                  {detail.attachments.map(attachment => (
+                    <div
+                      className="flex items-center justify-between gap-2 rounded px-1.5 py-1 text-[0.7rem] text-foreground/85"
+                      key={attachment.id}
+                    >
+                      <span className="flex min-w-0 items-center gap-1.5">
+                        <Codicon className="shrink-0 text-muted-foreground/55" name="file" size="0.75rem" />
+                        <span className="truncate">{attachment.filename}</span>
+                      </span>
+                      <span className="shrink-0 text-[0.62rem] tabular-nums text-muted-foreground/50">
+                        {formatBytes(attachment.size)}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              )}
+            </section>
+
+            <section className="space-y-1.5">
+              <PanelSectionLabel>
+                {k.events}
+                {detail.events.length > 0 ? ` · ${detail.events.length}` : ''}
+              </PanelSectionLabel>
+              {detail.events.length === 0 ? (
+                <p className="text-xs text-muted-foreground/60">{k.noEvents}</p>
+              ) : (
+                <div className="space-y-px">
+                  {[...detail.events].reverse().map(event => (
+                    <div
+                      className="flex items-baseline justify-between gap-2 rounded px-1.5 py-0.5 text-[0.66rem]"
+                      key={event.id}
+                    >
+                      <span className="min-w-0">
+                        <span className="font-medium text-foreground/80">{event.kind}</span>
+                        {event.payload ? (
+                          <span className="ml-1.5 break-all text-muted-foreground/60">
+                            {JSON.stringify(event.payload)}
+                          </span>
+                        ) : null}
+                      </span>
+                      <span className="shrink-0 tabular-nums text-muted-foreground/45">
+                        {formatEpoch(event.created_at)}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              )}
+            </section>
+          </>
+        ) : null}
+      </div>
+    </aside>
+  )
+}
+
+function DrawerField({ children, label }: { children: React.ReactNode; label: string }) {
+  return (
+    <div className="grid grid-cols-[4.5rem_1fr] items-center gap-2">
+      <span className="text-[0.68rem] text-muted-foreground/60">{label}</span>
+      {children}
+    </div>
+  )
+}
+
+function LinkChips({ ids, k, label }: { ids: string[]; k: Translations['kanban']; label: string }) {
+  return (
+    <div className="flex flex-wrap items-center gap-1 text-[0.66rem]">
+      <span className="text-muted-foreground/55">{label}</span>
+      {ids.length === 0 ? (
+        <span className="text-muted-foreground/40">{k.none}</span>
+      ) : (
+        ids.map(id => (
+          <button
+            className="rounded-full bg-foreground/8 px-1.5 py-px font-mono text-[0.62rem] text-foreground/75 transition-colors hover:bg-foreground/15 hover:text-foreground"
+            key={id}
+            onClick={() => setKanbanSelectedTaskId(id)}
+            type="button"
+          >
+            {id}
+          </button>
+        ))
+      )}
+    </div>
+  )
+}
+
+function RunRow({ k, run }: { k: Translations['kanban']; run: KanbanRun }) {
+  const state = run.outcome ?? run.status
+
+  return (
+    <div className="rounded bg-foreground/5 p-2 text-[0.66rem]">
+      <div className="flex items-center justify-between gap-2">
+        <span className="flex min-w-0 items-center gap-1.5">
+          <span className="shrink-0 font-mono text-muted-foreground/55">#{run.id}</span>
+          <span className="truncate text-foreground/80">{run.profile ?? '—'}</span>
+        </span>
+        <PanelPill tone={RUN_TONE[state] ?? 'muted'}>{state}</PanelPill>
+      </div>
+      <div className="mt-0.5 flex items-baseline justify-between gap-2 tabular-nums text-muted-foreground/50">
+        <span>{formatEpoch(run.started_at)}</span>
+        <span>{run.ended_at ? formatEpoch(run.ended_at) : k.runActive}</span>
+      </div>
+      {run.summary?.trim() ? (
+        <div className="mt-1 line-clamp-3 whitespace-pre-wrap break-words leading-relaxed text-foreground/75">
+          {run.summary}
+        </div>
+      ) : null}
+      {run.error?.trim() ? <div className="mt-1 break-words text-destructive/85">{run.error}</div> : null}
+    </div>
+  )
+}
+
+function WorkerLogSection({ k, taskId }: { k: Translations['kanban']; taskId: string }) {
+  const [open, setOpen] = useState(false)
+  const [log, setLog] = useState<null | string>(null)
+  const [loading, setLoading] = useState(false)
+
+  async function toggle() {
+    if (open) {
+      setOpen(false)
+
+      return
+    }
+
+    setOpen(true)
+    setLoading(true)
+
+    try {
+      const result = await getKanbanTaskLog(taskId, $kanbanActiveBoard.get())
+
+      setLog(result.exists ? result.content : null)
+    } catch {
+      setLog(null)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return (
+    <div className="space-y-1">
+      <button
+        className="flex items-center gap-1 text-[0.66rem] text-muted-foreground/70 transition-colors hover:text-foreground"
+        onClick={() => void toggle()}
+        type="button"
+      >
+        <Codicon name={open ? 'chevron-down' : 'chevron-right'} size="0.7rem" />
+        {k.workerLog}
+      </button>
+      {open ? (
+        loading ? (
+          <div className="flex items-center gap-1.5 py-1 text-xs text-muted-foreground">
+            <Codicon name="loading" size="0.75rem" spinning />
+            {k.loadingLog}
+          </div>
+        ) : log ? (
+          <PanelBlock className="max-h-64 font-mono">{log}</PanelBlock>
+        ) : (
+          <p className="text-xs text-muted-foreground/60">{k.noWorkerLog}</p>
+        )
+      ) : null}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/app/kanban/index.test.tsx b/apps/desktop/src/app/kanban/index.test.tsx
new file mode 100644
index 0000000000000..236b1bdbd21c8
--- /dev/null
+++ b/apps/desktop/src/app/kanban/index.test.tsx
@@ -0,0 +1,159 @@
+// @vitest-environment jsdom
+import { cleanup, render, screen } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  $kanbanActiveBoard,
+  $kanbanBoard,
+  $kanbanBoardError,
+  $kanbanBoards,
+  $kanbanRefreshing,
+  $kanbanSelectedTaskId,
+  KANBAN_COLUMNS
+} from '@/store/kanban'
+import type { KanbanBoardPayload, KanbanCard } from '@/types/kanban'
+
+import { KanbanView } from './index'
+
+function card(id: string, status: string, extra: Partial<KanbanCard> = {}): KanbanCard {
+  return {
+    id,
+    title: `Task ${id}`,
+    body: null,
+    assignee: 'coder',
+    status,
+    priority: 0,
+    created_by: 'test',
+    created_at: 1,
+    started_at: null,
+    completed_at: null,
+    workspace_kind: 'scratch',
+    workspace_path: null,
+    claim_lock: null,
+    claim_expires: null,
+    tenant: null,
+    ...extra
+  }
+}
+
+const boardPayload: KanbanBoardPayload = {
+  columns: KANBAN_COLUMNS.map(name => ({
+    name,
+    tasks:
+      name === 'todo'
+        ? [
+            card('t_alpha', 'todo', {
+              comment_count: 2,
+              progress: { done: 1, total: 3 },
+              warnings: { count: 1, kinds: { worker_crashed: 1 }, latest_at: 5, highest_severity: 'error' }
+            })
+          ]
+        : name === 'running'
+          ? [card('t_beta', 'running', { assignee: 'researcher', priority: 2 })]
+          : []
+  })),
+  tenants: [],
+  assignees: ['coder', 'researcher'],
+  latest_event_id: 3,
+  now: 1000
+}
+
+describe('KanbanView', () => {
+  let api: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    api = vi.fn(async (request: { path: string }) => {
+      if (request.path.startsWith('/api/plugins/kanban/boards')) {
+        return {
+          boards: [{ slug: 'default', name: 'Default', description: '', icon: '', color: '', is_current: true }],
+          current: 'default'
+        }
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/board')) {
+        return boardPayload
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/assignees')) {
+        return { assignees: [] }
+      }
+
+      throw new Error(`unexpected path ${request.path}`)
+    })
+    Object.defineProperty(window, 'hermesDesktop', {
+      configurable: true,
+      value: { api }
+    })
+    window.localStorage.clear()
+    $kanbanBoards.set([])
+    $kanbanActiveBoard.set(null)
+    $kanbanBoard.set(null)
+    $kanbanBoardError.set(null)
+    $kanbanRefreshing.set(false)
+    $kanbanSelectedTaskId.set(null)
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+    Reflect.deleteProperty(window, 'hermesDesktop')
+  })
+
+  it('renders every column and the mocked cards', async () => {
+    render(<KanbanView onClose={() => undefined} />)
+
+    // Cards from the mocked board payload.
+    expect(await screen.findByText('Task t_alpha')).toBeTruthy()
+    expect(screen.getByText('Task t_beta')).toBeTruthy()
+
+    // All eight columns, in BOARD_COLUMNS order.
+    for (const label of ['Triage', 'Todo', 'Scheduled', 'Ready', 'In progress', 'Blocked', 'Review', 'Done']) {
+      expect(screen.getByText(label)).toBeTruthy()
+    }
+
+    // Card rollup chips: comments, progress, diagnostics badge.
+    expect(screen.getByText('1/3')).toBeTruthy()
+
+    // Header actions.
+    expect(screen.getByText('Nudge dispatcher')).toBeTruthy()
+    expect(screen.getByText('New card')).toBeTruthy()
+
+    expect(api).toHaveBeenCalledWith(expect.objectContaining({ path: '/api/plugins/kanban/board' }))
+  })
+
+  it('opens the card drawer when a card is selected', async () => {
+    api.mockImplementation(async (request: { path: string }) => {
+      if (request.path.startsWith('/api/plugins/kanban/boards')) {
+        return { boards: [], current: 'default' }
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/board')) {
+        return boardPayload
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/assignees')) {
+        return { assignees: [{ name: 'coder', on_disk: true, counts: {} }] }
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/tasks/t_alpha')) {
+        return {
+          task: card('t_alpha', 'todo', { body: 'Do the thing', latest_summary: null }),
+          comments: [{ id: 1, task_id: 't_alpha', author: 'coder', body: 'On it', created_at: 10 }],
+          events: [{ id: 1, task_id: 't_alpha', kind: 'created', payload: null, created_at: 9, run_id: null }],
+          attachments: [],
+          links: { parents: [], children: [] },
+          runs: []
+        }
+      }
+
+      throw new Error(`unexpected path ${request.path}`)
+    })
+
+    $kanbanSelectedTaskId.set('t_alpha')
+    render(<KanbanView onClose={() => undefined} />)
+
+    expect(await screen.findByText('Do the thing')).toBeTruthy()
+    expect(screen.getByText('On it')).toBeTruthy()
+    expect(screen.getByText('Run history')).toBeTruthy()
+  })
+})
diff --git a/apps/desktop/src/app/kanban/index.tsx b/apps/desktop/src/app/kanban/index.tsx
new file mode 100644
index 0000000000000..c11013f30f84b
--- /dev/null
+++ b/apps/desktop/src/app/kanban/index.tsx
@@ -0,0 +1,441 @@
+import {
+  DndContext,
+  type DragEndEvent,
+  DragOverlay,
+  type DragStartEvent,
+  PointerSensor,
+  pointerWithin,
+  useDraggable,
+  useDroppable,
+  useSensor,
+  useSensors
+} from '@dnd-kit/core'
+import { useStore } from '@nanostores/react'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
+import { ErrorBoundary } from '@/components/error-boundary'
+import { PageLoader } from '@/components/page-loader'
+import { Button } from '@/components/ui/button'
+import { Codicon } from '@/components/ui/codicon'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { type Translations, useI18n } from '@/i18n'
+import { kanbanDispatchNudge } from '@/kanban-api'
+import { cn } from '@/lib/utils'
+import {
+  $kanbanActiveBoard,
+  $kanbanBoard,
+  $kanbanBoardError,
+  $kanbanBoards,
+  $kanbanSelectedTaskId,
+  isAllowedDrop,
+  KANBAN_COLUMNS,
+  moveKanbanTask,
+  refreshKanbanBoard,
+  refreshKanbanBoards,
+  setKanbanActiveBoard,
+  setKanbanSelectedTaskId
+} from '@/store/kanban'
+import { notify, notifyError } from '@/store/notifications'
+import type { KanbanCard as KanbanCardData, KanbanColumn as KanbanColumnData } from '@/types/kanban'
+
+import { useRefreshHotkey } from '../hooks/use-refresh-hotkey'
+import { Panel, PanelEmpty, PanelHeader } from '../overlays/panel'
+
+import { KanbanCardDrawer } from './card-drawer'
+import { NewCardDialog } from './new-card-dialog'
+
+// Live updates via polling (WS /events plumbing is out of scope for v1): the
+// board payload's latest_event_id is the change cursor, so an unchanged poll
+// keeps the previous atom identity and re-renders nothing. Paused while the
+// window is hidden, same as the cron/messaging pollers.
+const BOARD_POLL_INTERVAL_MS = 4_000
+
+const PRIORITY_TONE: Record<string, string> = {
+  high: 'bg-destructive/10 text-destructive',
+  low: 'bg-foreground/10 text-muted-foreground'
+}
+
+const SEVERITY_TONE: Record<string, string> = {
+  critical: 'bg-destructive/15 text-destructive',
+  error: 'bg-destructive/10 text-destructive',
+  warning: 'bg-amber-500/10 text-amber-600 dark:text-amber-300'
+}
+
+interface KanbanViewProps {
+  onClose: () => void
+}
+
+export function KanbanView({ onClose }: KanbanViewProps) {
+  const { t } = useI18n()
+
+  return (
+    <Panel closeLabel={t.kanban.close} onClose={onClose}>
+      {/* The board must never crash the shell — everything inside the panel
+          chrome mounts behind its own boundary so the close button survives. */}
+      <ErrorBoundary label="kanban">
+        <KanbanBoardContent />
+      </ErrorBoundary>
+    </Panel>
+  )
+}
+
+function KanbanBoardContent() {
+  const { t } = useI18n()
+  const k = t.kanban
+  const boards = useStore($kanbanBoards)
+  const activeBoard = useStore($kanbanActiveBoard)
+  const board = useStore($kanbanBoard)
+  const boardError = useStore($kanbanBoardError)
+  const selectedTaskId = useStore($kanbanSelectedTaskId)
+
+  const [nudging, setNudging] = useState(false)
+  const [newCardOpen, setNewCardOpen] = useState(false)
+  const [dragCard, setDragCard] = useState<KanbanCardData | null>(null)
+
+  const refresh = useCallback(() => {
+    void refreshKanbanBoards()
+    void refreshKanbanBoard()
+  }, [])
+
+  useRefreshHotkey(refresh)
+
+  useEffect(() => {
+    refresh()
+  }, [refresh, activeBoard])
+
+  useEffect(() => {
+    const tick = () => {
+      if (document.visibilityState === 'visible') {
+        void refreshKanbanBoard()
+      }
+    }
+
+    const intervalId = window.setInterval(tick, BOARD_POLL_INTERVAL_MS)
+
+    document.addEventListener('visibilitychange', tick)
+
+    return () => {
+      window.clearInterval(intervalId)
+      document.removeEventListener('visibilitychange', tick)
+    }
+  }, [])
+
+  const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 6 } }))
+
+  const columns = useMemo<KanbanColumnData[]>(() => {
+    const byName = new Map((board?.columns ?? []).map(column => [column.name, column]))
+
+    return KANBAN_COLUMNS.map(name => byName.get(name) ?? { name, tasks: [] })
+  }, [board])
+
+  const totalCount = useMemo(() => columns.reduce((sum, column) => sum + column.tasks.length, 0), [columns])
+
+  const boardValue = activeBoard ?? boards.find(entry => entry.is_current)?.slug ?? 'default'
+
+  const handleDragStart = useCallback(({ active }: DragStartEvent) => {
+    setDragCard((active.data.current?.card as KanbanCardData | undefined) ?? null)
+  }, [])
+
+  const handleDragEnd = useCallback(
+    ({ active, over }: DragEndEvent) => {
+      setDragCard(null)
+
+      const card = active.data.current?.card as KanbanCardData | undefined
+      const target = over ? String(over.id) : null
+
+      if (!card || !target || target === card.status || !isAllowedDrop(card.status, target)) {
+        return
+      }
+
+      void moveKanbanTask(card.id, target).then(result => {
+        if (!result.ok) {
+          notify({ kind: 'error', title: k.moveFailed, message: result.error ?? '' })
+        } else if (result.ruleMoved && result.status) {
+          notify({ kind: 'info', message: k.movedByRules(k.columnLabels[result.status] ?? result.status) })
+        }
+      })
+    },
+    [k]
+  )
+
+  async function handleNudge() {
+    setNudging(true)
+
+    try {
+      const result = await kanbanDispatchNudge(activeBoard)
+
+      notify({
+        kind: 'success',
+        message: k.nudgeSent(result.spawned?.length ?? 0, result.promoted ?? 0)
+      })
+      void refreshKanbanBoard()
+    } catch (error) {
+      notifyError(error, k.nudgeFailed)
+    } finally {
+      setNudging(false)
+    }
+  }
+
+  if (!board && !boardError) {
+    return <PageLoader label={k.loading} />
+  }
+
+  return (
+    <>
+      <PanelHeader
+        actions={
+          <>
+            <Select onValueChange={value => setKanbanActiveBoard(value)} value={boardValue}>
+              <SelectTrigger aria-label={k.board} className="h-7 w-40 rounded-md text-xs">
+                <SelectValue placeholder={k.board} />
+              </SelectTrigger>
+              <SelectContent>
+                {(boards.length > 0 ? boards : [{ slug: boardValue, name: boardValue }]).map(entry => (
+                  <SelectItem key={entry.slug} value={entry.slug}>
+                    {entry.name || entry.slug}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+            <Button
+              className="gap-1.5 text-muted-foreground hover:text-foreground"
+              disabled={nudging}
+              onClick={() => void handleNudge()}
+              size="sm"
+              variant="ghost"
+            >
+              <Codicon name={nudging ? 'loading' : 'zap'} size="0.875rem" spinning={nudging} />
+              {k.nudgeDispatcher}
+            </Button>
+            <Button onClick={() => setNewCardOpen(true)} size="sm">
+              {k.newCard}
+            </Button>
+          </>
+        }
+        subtitle={boardError ? boardError : k.count(totalCount)}
+        title={k.title}
+      />
+
+      <div className="flex min-h-0 flex-1 gap-4 overflow-hidden">
+        {boardError && !board ? (
+          <PanelEmpty description={boardError} icon="warning" title={k.failedLoad} />
+        ) : (
+          <DndContext
+            collisionDetection={pointerWithin}
+            onDragCancel={() => setDragCard(null)}
+            onDragEnd={handleDragEnd}
+            onDragStart={handleDragStart}
+            sensors={sensors}
+          >
+            <div className="flex min-h-0 flex-1 gap-2.5 overflow-x-auto overscroll-contain pb-2">
+              {columns.map(column => (
+                <KanbanColumn
+                  column={column}
+                  dragCard={dragCard}
+                  k={k}
+                  key={column.name}
+                  onSelect={setKanbanSelectedTaskId}
+                  selectedTaskId={selectedTaskId}
+                />
+              ))}
+            </div>
+
+            <DragOverlay dropAnimation={null}>
+              {dragCard ? <KanbanCardTile card={dragCard} dragging k={k} /> : null}
+            </DragOverlay>
+          </DndContext>
+        )}
+
+        {selectedTaskId ? (
+          <KanbanCardDrawer
+            key={selectedTaskId}
+            onClose={() => setKanbanSelectedTaskId(null)}
+            taskId={selectedTaskId}
+          />
+        ) : null}
+      </div>
+
+      <NewCardDialog onClose={() => setNewCardOpen(false)} open={newCardOpen} />
+    </>
+  )
+}
+
+function KanbanColumn({
+  column,
+  dragCard,
+  k,
+  onSelect,
+  selectedTaskId
+}: {
+  column: KanbanColumnData
+  dragCard: KanbanCardData | null
+  k: Translations['kanban']
+  onSelect: (id: string) => void
+  selectedTaskId: null | string
+}) {
+  const { isOver, setNodeRef } = useDroppable({ id: column.name })
+
+  const dropAllowed = dragCard ? isAllowedDrop(dragCard.status, column.name) : false
+  const dropBlocked = dragCard !== null && !dropAllowed && column.name !== dragCard.status
+
+  return (
+    <div
+      className={cn(
+        'flex w-52 shrink-0 flex-col rounded-lg bg-foreground/[0.03] transition-opacity',
+        dropBlocked && 'opacity-40',
+        isOver && dropAllowed && 'bg-primary/8 ring-1 ring-primary/30'
+      )}
+      ref={setNodeRef}
+    >
+      <div className="flex shrink-0 items-center justify-between px-2.5 pb-1 pt-2">
+        <span className="text-[0.6rem] font-medium uppercase tracking-wider text-muted-foreground/60">
+          {k.columnLabels[column.name] ?? column.name}
+        </span>
+        <span className="text-[0.62rem] tabular-nums text-muted-foreground/45">{column.tasks.length}</span>
+      </div>
+      <div className="flex min-h-0 flex-1 flex-col gap-1.5 overflow-y-auto overscroll-contain p-1.5 pt-0.5">
+        {column.tasks.length === 0 ? (
+          <div className="py-3 text-center text-[0.65rem] text-muted-foreground/40">{k.noTasks}</div>
+        ) : (
+          column.tasks.map(card => (
+            <DraggableCard
+              active={card.id === selectedTaskId}
+              card={card}
+              k={k}
+              key={card.id}
+              onSelect={() => onSelect(card.id)}
+            />
+          ))
+        )}
+      </div>
+    </div>
+  )
+}
+
+function DraggableCard({
+  active,
+  card,
+  k,
+  onSelect
+}: {
+  active: boolean
+  card: KanbanCardData
+  k: Translations['kanban']
+  onSelect: () => void
+}) {
+  const { attributes, isDragging, listeners, setNodeRef } = useDraggable({
+    id: card.id,
+    data: { card }
+  })
+
+  return (
+    <div
+      className={cn('touch-none', isDragging && 'opacity-30')}
+      ref={setNodeRef}
+      {...attributes}
+      {...listeners}
+      onClick={onSelect}
+      onKeyDown={event => {
+        if (event.key === 'Enter' || event.key === ' ') {
+          event.preventDefault()
+          onSelect()
+        }
+      }}
+      role="button"
+      tabIndex={0}
+    >
+      <KanbanCardTile active={active} card={card} k={k} />
+    </div>
+  )
+}
+
+function priorityTone(priority: number): string {
+  if (priority > 0) {
+    return PRIORITY_TONE.high
+  }
+
+  return PRIORITY_TONE.low
+}
+
+export function KanbanCardTile({
+  active,
+  card,
+  dragging,
+  k
+}: {
+  active?: boolean
+  card: KanbanCardData
+  dragging?: boolean
+  k: Translations['kanban']
+}) {
+  const warnings = card.warnings
+  const commentCount = card.comment_count ?? 0
+  const progress = card.progress
+
+  return (
+    <div
+      className={cn(
+        'cursor-pointer select-none rounded-md border border-(--ui-stroke-secondary) bg-(--ui-chat-surface-background) p-2 text-left shadow-xs transition-colors hover:border-(--ui-stroke-tertiary)',
+        active && 'border-primary/50 ring-1 ring-primary/30',
+        dragging && 'shadow-md'
+      )}
+      data-kanban-card={card.id}
+    >
+      <div className="mb-1 line-clamp-3 text-[0.74rem] font-medium leading-snug text-foreground/90">
+        {card.title || card.id}
+      </div>
+      <div className="flex flex-wrap items-center gap-1">
+        <span
+          className={cn(
+            'inline-flex max-w-24 items-center gap-0.5 truncate rounded-full bg-foreground/8 px-1.5 py-px text-[0.6rem] text-muted-foreground'
+          )}
+          title={card.assignee ?? k.unassigned}
+        >
+          <Codicon className="shrink-0" name="account" size="0.6rem" />
+          <span className="truncate">{card.assignee ?? k.unassigned}</span>
+        </span>
+        {card.priority !== 0 && (
+          <span
+            className={cn(
+              'inline-flex items-center rounded-full px-1.5 py-px text-[0.6rem] tabular-nums',
+              priorityTone(card.priority)
+            )}
+            title={k.priority}
+          >
+            P{card.priority}
+          </span>
+        )}
+        {progress && progress.total > 0 && (
+          <span
+            className="inline-flex items-center gap-0.5 rounded-full bg-foreground/8 px-1.5 py-px text-[0.6rem] tabular-nums text-muted-foreground"
+            title={k.progressTitle(progress.done, progress.total)}
+          >
+            <Codicon name="type-hierarchy-sub" size="0.6rem" />
+            {progress.done}/{progress.total}
+          </span>
+        )}
+        {warnings && warnings.count > 0 && (
+          <span
+            className={cn(
+              'inline-flex items-center gap-0.5 rounded-full px-1.5 py-px text-[0.6rem] tabular-nums',
+              SEVERITY_TONE[warnings.highest_severity ?? 'warning'] ?? SEVERITY_TONE.warning
+            )}
+            title={k.diagnostics}
+          >
+            <Codicon name="warning" size="0.6rem" />
+            {warnings.count}
+          </span>
+        )}
+        {commentCount > 0 && (
+          <span
+            className="inline-flex items-center gap-0.5 rounded-full bg-foreground/8 px-1.5 py-px text-[0.6rem] tabular-nums text-muted-foreground"
+            title={k.comments}
+          >
+            <Codicon name="comment" size="0.6rem" />
+            {commentCount}
+          </span>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/apps/desktop/src/app/kanban/new-card-dialog.tsx b/apps/desktop/src/app/kanban/new-card-dialog.tsx
new file mode 100644
index 0000000000000..0157a02487677
--- /dev/null
+++ b/apps/desktop/src/app/kanban/new-card-dialog.tsx
@@ -0,0 +1,245 @@
+import { useStore } from '@nanostores/react'
+import type * as React from 'react'
+import { useEffect, useMemo, useState } from 'react'
+
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { Textarea } from '@/components/ui/textarea'
+import { useI18n } from '@/i18n'
+import { createKanbanTask, getKanbanAssignees, parseKanbanApiError } from '@/kanban-api'
+import { $kanbanActiveBoard, $kanbanBoard, refreshKanbanBoard } from '@/store/kanban'
+import { notify } from '@/store/notifications'
+
+// Radix Select items may not use '' — sentinel for "no parent link".
+const NO_PARENT = '__none__'
+
+interface NewCardDialogProps {
+  onClose: () => void
+  open: boolean
+}
+
+export function NewCardDialog({ onClose, open }: NewCardDialogProps) {
+  const { t } = useI18n()
+  const k = t.kanban
+  const board = useStore($kanbanBoard)
+  const activeBoard = useStore($kanbanActiveBoard)
+
+  const [title, setTitle] = useState('')
+  const [assignee, setAssignee] = useState('')
+  const [body, setBody] = useState('')
+  const [priority, setPriority] = useState('0')
+  const [parent, setParent] = useState(NO_PARENT)
+  const [assignees, setAssignees] = useState<string[]>([])
+  const [saving, setSaving] = useState(false)
+  const [error, setError] = useState<null | string>(null)
+
+  useEffect(() => {
+    if (!open) {
+      return
+    }
+
+    setTitle('')
+    setAssignee('')
+    setBody('')
+    setPriority('0')
+    setParent(NO_PARENT)
+    setError(null)
+    setSaving(false)
+
+    let cancelled = false
+
+    // Assignee choices: the /assignees union (on-disk profiles + names already
+    // on the board), falling back to the board payload's assignees.
+    getKanbanAssignees($kanbanActiveBoard.get())
+      .then(list => {
+        if (!cancelled) {
+          setAssignees(list.map(entry => entry.name))
+        }
+      })
+      .catch(() => {
+        if (!cancelled) {
+          setAssignees($kanbanBoard.get()?.assignees ?? [])
+        }
+      })
+
+    return () => {
+      cancelled = true
+    }
+  }, [open, activeBoard])
+
+  const parentOptions = useMemo(
+    () => (board?.columns ?? []).flatMap(column => column.tasks.map(task => ({ id: task.id, title: task.title }))),
+    [board]
+  )
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault()
+
+    const trimmedTitle = title.trim()
+
+    if (!trimmedTitle) {
+      setError(k.titleRequired)
+
+      return
+    }
+
+    if (!assignee) {
+      setError(k.assigneeRequired)
+
+      return
+    }
+
+    setSaving(true)
+    setError(null)
+
+    try {
+      const parsedPriority = Number.parseInt(priority, 10)
+
+      const response = await createKanbanTask(
+        {
+          title: trimmedTitle,
+          assignee,
+          body: body.trim() || undefined,
+          priority: Number.isInteger(parsedPriority) ? parsedPriority : 0,
+          parents: parent === NO_PARENT ? [] : [parent]
+        },
+        $kanbanActiveBoard.get()
+      )
+
+      notify({ kind: 'success', message: k.created })
+
+      if (response.warning) {
+        notify({ kind: 'warning', message: response.warning })
+      }
+
+      void refreshKanbanBoard()
+      onClose()
+    } catch (err) {
+      setError(parseKanbanApiError(err).detail || k.createFailed)
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <Dialog onOpenChange={value => !value && !saving && onClose()} open={open}>
+      <DialogContent className="max-w-lg">
+        <DialogHeader>
+          <DialogTitle>{k.newCardTitle}</DialogTitle>
+          <DialogDescription>{k.newCardDesc}</DialogDescription>
+        </DialogHeader>
+
+        <form className="grid gap-4" onSubmit={handleSubmit}>
+          <Field htmlFor="kanban-card-title" label={k.titleLabel}>
+            <Input
+              autoFocus
+              id="kanban-card-title"
+              onChange={event => setTitle(event.target.value)}
+              placeholder={k.titlePlaceholder}
+              value={title}
+            />
+          </Field>
+
+          <div className="grid items-start gap-4 sm:grid-cols-2">
+            <Field htmlFor="kanban-card-assignee" label={k.assigneeLabel}>
+              <Select onValueChange={setAssignee} value={assignee || undefined}>
+                <SelectTrigger className="h-9 rounded-md" id="kanban-card-assignee">
+                  <SelectValue placeholder={k.assigneePlaceholder} />
+                </SelectTrigger>
+                <SelectContent>
+                  {assignees.map(name => (
+                    <SelectItem key={name} value={name}>
+                      {name}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </Field>
+
+            <Field htmlFor="kanban-card-priority" label={k.priorityLabel}>
+              <Input
+                className="tabular-nums"
+                id="kanban-card-priority"
+                onChange={event => setPriority(event.target.value)}
+                type="number"
+                value={priority}
+              />
+            </Field>
+          </div>
+
+          <Field htmlFor="kanban-card-body" label={k.bodyLabel} optional optionalLabel={k.optional}>
+            <Textarea
+              className="min-h-24"
+              id="kanban-card-body"
+              onChange={event => setBody(event.target.value)}
+              placeholder={k.bodyPlaceholder}
+              value={body}
+            />
+          </Field>
+
+          {parentOptions.length > 0 && (
+            <Field htmlFor="kanban-card-parent" label={k.parentLabel} optional optionalLabel={k.optional}>
+              <Select onValueChange={setParent} value={parent}>
+                <SelectTrigger className="h-9 rounded-md" id="kanban-card-parent">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value={NO_PARENT}>{k.parentNone}</SelectItem>
+                  {parentOptions.map(option => (
+                    <SelectItem key={option.id} value={option.id}>
+                      {option.title || option.id}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </Field>
+          )}
+
+          {error && <div className="rounded-md bg-destructive/10 px-3 py-2 text-xs text-destructive">{error}</div>}
+
+          <DialogFooter>
+            <Button disabled={saving} onClick={onClose} type="button" variant="outline">
+              {t.common.cancel}
+            </Button>
+            <Button disabled={saving} type="submit">
+              {saving ? k.creating : k.createCard}
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+function Field({
+  children,
+  htmlFor,
+  label,
+  optional,
+  optionalLabel
+}: {
+  children: React.ReactNode
+  htmlFor: string
+  label: string
+  optional?: boolean
+  optionalLabel?: string
+}) {
+  return (
+    <div className="grid gap-1.5">
+      <label className="flex items-baseline gap-2 text-xs font-medium text-foreground" htmlFor={htmlFor}>
+        {label}
+        {optional && <span className="text-[0.65rem] font-normal text-muted-foreground">{optionalLabel}</span>}
+      </label>
+      {children}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/app/routes.ts b/apps/desktop/src/app/routes.ts
index 66ab264e474bb..e42f13a7ea00b 100644
--- a/apps/desktop/src/app/routes.ts
+++ b/apps/desktop/src/app/routes.ts
@@ -9,6 +9,7 @@ export const CRON_ROUTE = '/cron'
 export const PROFILES_ROUTE = '/profiles'
 export const AGENTS_ROUTE = '/agents'
 export const STARMAP_ROUTE = '/starmap'
+export const KANBAN_ROUTE = '/kanban'
 
 export type AppView =
   | 'agents'
@@ -16,6 +17,7 @@ export type AppView =
   | 'chat'
   | 'command-center'
   | 'cron'
+  | 'kanban'
   | 'messaging'
   | 'profiles'
   | 'settings'
@@ -27,6 +29,7 @@ export type AppRouteId =
   | 'artifacts'
   | 'command-center'
   | 'cron'
+  | 'kanban'
   | 'messaging'
   | 'new'
   | 'profiles'
@@ -50,7 +53,8 @@ export const APP_ROUTES = [
   { id: 'cron', path: CRON_ROUTE, view: 'cron' },
   { id: 'profiles', path: PROFILES_ROUTE, view: 'profiles' },
   { id: 'agents', path: AGENTS_ROUTE, view: 'agents' },
-  { id: 'starmap', path: STARMAP_ROUTE, view: 'starmap' }
+  { id: 'starmap', path: STARMAP_ROUTE, view: 'starmap' },
+  { id: 'kanban', path: KANBAN_ROUTE, view: 'kanban' }
 ] as const satisfies readonly AppRoute[]
 
 const APP_VIEW_BY_PATH = new Map<string, AppView>(APP_ROUTES.map(route => [route.path, route.view]))
@@ -63,6 +67,7 @@ export const OVERLAY_VIEWS: ReadonlySet<AppView> = new Set([
   'agents',
   'command-center',
   'cron',
+  'kanban',
   'profiles',
   'settings',
   'starmap'
diff --git a/apps/desktop/src/app/shell/hooks/use-overlay-routing.ts b/apps/desktop/src/app/shell/hooks/use-overlay-routing.ts
index 01873b08dd69d..4fe2c6541a0fc 100644
--- a/apps/desktop/src/app/shell/hooks/use-overlay-routing.ts
+++ b/apps/desktop/src/app/shell/hooks/use-overlay-routing.ts
@@ -23,6 +23,7 @@ export function useOverlayRouting() {
   const agentsOpen = currentView === 'agents'
   const starmapOpen = currentView === 'starmap'
   const cronOpen = currentView === 'cron'
+  const kanbanOpen = currentView === 'kanban'
   const profilesOpen = currentView === 'profiles'
   const chatOpen = currentView === 'chat'
   const overlayOpen = isOverlayView(currentView)
@@ -71,6 +72,7 @@ export function useOverlayRouting() {
     commandCenterOpen,
     cronOpen,
     currentView,
+    kanbanOpen,
     openAgents,
     openCommandCenterSection,
     openStarmap,
diff --git a/apps/desktop/src/app/types.ts b/apps/desktop/src/app/types.ts
index 1adc2bdec4e14..062adcbca19e5 100644
--- a/apps/desktop/src/app/types.ts
+++ b/apps/desktop/src/app/types.ts
@@ -122,7 +122,14 @@ export type CommandDispatchResponse =
   | SendCommandDispatchResponse
   | PrefillCommandDispatchResponse
 
-export type SidebarNavId = 'artifacts' | 'command-center' | 'messaging' | 'new-session' | 'settings' | 'skills'
+export type SidebarNavId =
+  | 'artifacts'
+  | 'command-center'
+  | 'kanban'
+  | 'messaging'
+  | 'new-session'
+  | 'settings'
+  | 'skills'
 
 export interface SidebarNavItem {
   id: SidebarNavId
diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts
index dcfccaed707a7..121af73717730 100644
--- a/apps/desktop/src/i18n/en.ts
+++ b/apps/desktop/src/i18n/en.ts
@@ -213,6 +213,7 @@ export const en: Translations = {
       'nav.messaging': 'Open messaging',
       'nav.artifacts': 'Open artifacts',
       'nav.cron': 'Open scheduled jobs',
+      'nav.kanban': 'Open kanban board',
       'nav.agents': 'Open agents',
       'session.new': 'New session',
       'session.newWindow': 'New session in window',
@@ -1438,6 +1439,81 @@ export const en: Translations = {
     createAction: 'Create cron'
   },
 
+  kanban: {
+    title: 'Kanban',
+    close: 'Close kanban',
+    loading: 'Loading kanban board…',
+    failedLoad: 'Failed to load kanban board',
+    count: count => (count === 1 ? '1 card' : `${count} cards`),
+    board: 'Board',
+    nudgeDispatcher: 'Nudge dispatcher',
+    nudgeSent: (spawned, promoted) => `Dispatcher nudged — spawned ${spawned}, promoted ${promoted}`,
+    nudgeFailed: 'Dispatch nudge failed',
+    newCard: 'New card',
+    noTasks: 'No cards',
+    unassigned: 'Unassigned',
+    priority: 'Priority',
+    progressTitle: (done, total) => `${done} of ${total} children done`,
+    diagnostics: 'Diagnostics',
+    movedByRules: column => `Moved to ${column} by board rules`,
+    moveFailed: 'Move failed',
+    columnLabels: {
+      triage: 'Triage',
+      todo: 'Todo',
+      scheduled: 'Scheduled',
+      ready: 'Ready',
+      running: 'In progress',
+      blocked: 'Blocked',
+      review: 'Review',
+      done: 'Done',
+      archived: 'Archived'
+    },
+    loadingDetail: 'Loading card…',
+    status: 'Status',
+    assignee: 'Assignee',
+    description: 'Description',
+    noDescription: 'No description',
+    latestSummary: 'Latest summary',
+    dependencies: 'Dependencies',
+    parents: 'Parents:',
+    children: 'Children:',
+    none: 'none',
+    comments: 'Comments',
+    noComments: 'No comments yet',
+    commentPlaceholder: 'Add a comment… (⌘Enter to send)',
+    addComment: 'Comment',
+    commentFailed: 'Failed to add comment',
+    events: 'Events',
+    noEvents: 'No events',
+    runHistory: 'Run history',
+    noRuns: 'No runs yet',
+    runActive: 'active',
+    workerLog: 'Worker log',
+    loadingLog: 'Loading log…',
+    noWorkerLog: 'No worker log yet',
+    attachments: 'Attachments',
+    noAttachments: 'No attachments',
+    updateFailed: 'Update failed',
+    newCardTitle: 'New card',
+    newCardDesc: 'The dispatcher hands ready cards to their assigned profile.',
+    titleLabel: 'Title',
+    titlePlaceholder: 'What needs to be done?',
+    assigneeLabel: 'Assignee',
+    assigneePlaceholder: 'Pick a profile',
+    bodyLabel: 'Description',
+    bodyPlaceholder: 'Goal, approach, acceptance criteria…',
+    priorityLabel: 'Priority',
+    parentLabel: 'Parent card',
+    parentNone: 'No parent',
+    optional: 'Optional',
+    createCard: 'Create card',
+    creating: 'Creating…',
+    created: 'Card created',
+    createFailed: 'Failed to create card',
+    titleRequired: 'Title is required.',
+    assigneeRequired: 'Assignee is required.'
+  },
+
   artifacts: {
     search: 'Search artifacts...',
     refresh: 'Refresh artifacts',
@@ -1478,7 +1554,8 @@ export const en: Translations = {
       'new-session': 'New session',
       skills: 'Capabilities',
       messaging: 'Messaging',
-      artifacts: 'Artifacts'
+      artifacts: 'Artifacts',
+      kanban: 'Kanban'
     },
     searchAria: 'Search sessions',
     searchPlaceholder: 'Search sessions…',
diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts
index 2d14c02d84848..94809f2ad4ee8 100644
--- a/apps/desktop/src/i18n/types.ts
+++ b/apps/desktop/src/i18n/types.ts
@@ -1177,6 +1177,71 @@ export interface Translations {
     createAction: string
   }
 
+  kanban: {
+    title: string
+    close: string
+    loading: string
+    failedLoad: string
+    count: (count: number) => string
+    board: string
+    nudgeDispatcher: string
+    nudgeSent: (spawned: number, promoted: number) => string
+    nudgeFailed: string
+    newCard: string
+    noTasks: string
+    unassigned: string
+    priority: string
+    progressTitle: (done: number, total: number) => string
+    diagnostics: string
+    movedByRules: (column: string) => string
+    moveFailed: string
+    columnLabels: Record<string, string>
+    loadingDetail: string
+    status: string
+    assignee: string
+    description: string
+    noDescription: string
+    latestSummary: string
+    dependencies: string
+    parents: string
+    children: string
+    none: string
+    comments: string
+    noComments: string
+    commentPlaceholder: string
+    addComment: string
+    commentFailed: string
+    events: string
+    noEvents: string
+    runHistory: string
+    noRuns: string
+    runActive: string
+    workerLog: string
+    loadingLog: string
+    noWorkerLog: string
+    attachments: string
+    noAttachments: string
+    updateFailed: string
+    newCardTitle: string
+    newCardDesc: string
+    titleLabel: string
+    titlePlaceholder: string
+    assigneeLabel: string
+    assigneePlaceholder: string
+    bodyLabel: string
+    bodyPlaceholder: string
+    priorityLabel: string
+    parentLabel: string
+    parentNone: string
+    optional: string
+    createCard: string
+    creating: string
+    created: string
+    createFailed: string
+    titleRequired: string
+    assigneeRequired: string
+  }
+
   artifacts: {
     search: string
     refresh: string
diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts
index 6f6cebef79012..0eb909a9f3215 100644
--- a/apps/desktop/src/i18n/zh.ts
+++ b/apps/desktop/src/i18n/zh.ts
@@ -208,6 +208,7 @@ export const zh: Translations = {
       'nav.messaging': '打开消息',
       'nav.artifacts': '打开制品',
       'nav.cron': '打开定时任务',
+      'nav.kanban': '打开看板',
       'nav.agents': '打开智能体',
       'session.new': '新建会话',
       'session.newWindow': '在新窗口中新建会话',
@@ -1616,6 +1617,81 @@ export const zh: Translations = {
     createAction: '创建定时任务'
   },
 
+  kanban: {
+    title: '看板',
+    close: '关闭看板',
+    loading: '正在加载看板…',
+    failedLoad: '加载看板失败',
+    count: count => `${count} 张卡片`,
+    board: '面板',
+    nudgeDispatcher: '触发调度器',
+    nudgeSent: (spawned, promoted) => `已触发调度器 — 启动 ${spawned}，晋级 ${promoted}`,
+    nudgeFailed: '触发调度器失败',
+    newCard: '新建卡片',
+    noTasks: '暂无卡片',
+    unassigned: '未分配',
+    priority: '优先级',
+    progressTitle: (done, total) => `子任务已完成 ${done}/${total}`,
+    diagnostics: '诊断',
+    movedByRules: column => `已按面板规则移至「${column}」`,
+    moveFailed: '移动失败',
+    columnLabels: {
+      triage: '分诊',
+      todo: '待办',
+      scheduled: '已排程',
+      ready: '就绪',
+      running: '进行中',
+      blocked: '受阻',
+      review: '评审',
+      done: '完成',
+      archived: '已归档'
+    },
+    loadingDetail: '正在加载卡片…',
+    status: '状态',
+    assignee: '负责人',
+    description: '描述',
+    noDescription: '暂无描述',
+    latestSummary: '最新摘要',
+    dependencies: '依赖关系',
+    parents: '父任务：',
+    children: '子任务：',
+    none: '无',
+    comments: '评论',
+    noComments: '暂无评论',
+    commentPlaceholder: '添加评论…（⌘Enter 发送）',
+    addComment: '评论',
+    commentFailed: '添加评论失败',
+    events: '事件',
+    noEvents: '暂无事件',
+    runHistory: '运行历史',
+    noRuns: '暂无运行记录',
+    runActive: '进行中',
+    workerLog: '工作进程日志',
+    loadingLog: '正在加载日志…',
+    noWorkerLog: '暂无工作进程日志',
+    attachments: '附件',
+    noAttachments: '暂无附件',
+    updateFailed: '更新失败',
+    newCardTitle: '新建卡片',
+    newCardDesc: '调度器会把就绪卡片交给其指定的配置档案执行。',
+    titleLabel: '标题',
+    titlePlaceholder: '需要做什么？',
+    assigneeLabel: '负责人',
+    assigneePlaceholder: '选择配置档案',
+    bodyLabel: '描述',
+    bodyPlaceholder: '目标、方案、验收标准…',
+    priorityLabel: '优先级',
+    parentLabel: '父卡片',
+    parentNone: '无父卡片',
+    optional: '可选',
+    createCard: '创建卡片',
+    creating: '创建中…',
+    created: '卡片已创建',
+    createFailed: '创建卡片失败',
+    titleRequired: '标题为必填项。',
+    assigneeRequired: '负责人为必填项。'
+  },
+
   artifacts: {
     search: '搜索产物…',
     refresh: '刷新产物',
@@ -1656,7 +1732,8 @@ export const zh: Translations = {
       'new-session': '新建会话',
       skills: '技能与工具',
       messaging: '消息平台',
-      artifacts: '产物'
+      artifacts: '产物',
+      kanban: '看板'
     },
     searchAria: '搜索会话',
     searchPlaceholder: '搜索会话…',
diff --git a/apps/desktop/src/kanban-api.ts b/apps/desktop/src/kanban-api.ts
new file mode 100644
index 0000000000000..3b3024d38c656
--- /dev/null
+++ b/apps/desktop/src/kanban-api.ts
@@ -0,0 +1,179 @@
+import type {
+  KanbanAssignee,
+  KanbanBoardPayload,
+  KanbanBoardsResponse,
+  KanbanCreateTaskPayload,
+  KanbanCreateTaskResponse,
+  KanbanDispatchResult,
+  KanbanTaskDetail,
+  KanbanTaskLog,
+  KanbanUpdateTaskPayload,
+  KanbanUpdateTaskResponse
+} from '@/types/kanban'
+
+export type {
+  KanbanAssignee,
+  KanbanAttachment,
+  KanbanBoardInfo,
+  KanbanBoardPayload,
+  KanbanBoardsResponse,
+  KanbanCard,
+  KanbanColumn,
+  KanbanComment,
+  KanbanCreateTaskPayload,
+  KanbanCreateTaskResponse,
+  KanbanDiagnostic,
+  KanbanDispatchResult,
+  KanbanEvent,
+  KanbanLinks,
+  KanbanRun,
+  KanbanTask,
+  KanbanTaskDetail,
+  KanbanTaskLog,
+  KanbanUpdateTaskPayload,
+  KanbanUpdateTaskResponse,
+  KanbanWarningsSummary
+} from '@/types/kanban'
+
+// Kanban REST wrappers, deliberately split out of hermes.ts: kanban is
+// HOME-scoped, not profile-scoped. Boards are the shared cross-profile
+// coordination bus (profiles are the assignees/workers), so these calls must
+// NEVER carry profileScoped() / ?profile= — every profile sees the same board.
+// Board selection rides the explicit ?board= query param instead; omitting it
+// falls through to the backend's active board (env → current file → default).
+
+const KANBAN_BASE = '/api/plugins/kanban'
+
+function kanbanPath(path: string, board?: null | string): string {
+  if (!board) {
+    return `${KANBAN_BASE}${path}`
+  }
+
+  const sep = path.includes('?') ? '&' : '?'
+
+  return `${KANBAN_BASE}${path}${sep}board=${encodeURIComponent(board)}`
+}
+
+export function getKanbanBoards(): Promise<KanbanBoardsResponse> {
+  return window.hermesDesktop.api<KanbanBoardsResponse>({
+    path: kanbanPath('/boards')
+  })
+}
+
+export function getKanbanBoard(board?: null | string): Promise<KanbanBoardPayload> {
+  return window.hermesDesktop.api<KanbanBoardPayload>({
+    path: kanbanPath('/board', board)
+  })
+}
+
+export function getKanbanTask(taskId: string, board?: null | string): Promise<KanbanTaskDetail> {
+  return window.hermesDesktop.api<KanbanTaskDetail>({
+    path: kanbanPath(`/tasks/${encodeURIComponent(taskId)}`, board)
+  })
+}
+
+export function createKanbanTask(
+  payload: KanbanCreateTaskPayload,
+  board?: null | string
+): Promise<KanbanCreateTaskResponse> {
+  return window.hermesDesktop.api<KanbanCreateTaskResponse>({
+    path: kanbanPath('/tasks', board),
+    method: 'POST',
+    body: payload
+  })
+}
+
+export function updateKanbanTask(
+  taskId: string,
+  updates: KanbanUpdateTaskPayload,
+  board?: null | string
+): Promise<KanbanUpdateTaskResponse> {
+  return window.hermesDesktop.api<KanbanUpdateTaskResponse>({
+    path: kanbanPath(`/tasks/${encodeURIComponent(taskId)}`, board),
+    method: 'PATCH',
+    body: updates
+  })
+}
+
+export function addKanbanComment(
+  taskId: string,
+  body: string,
+  board?: null | string,
+  author = 'desktop'
+): Promise<{ ok: boolean }> {
+  return window.hermesDesktop.api<{ ok: boolean }>({
+    path: kanbanPath(`/tasks/${encodeURIComponent(taskId)}/comments`, board),
+    method: 'POST',
+    body: { body, author }
+  })
+}
+
+/** POST /dispatch — run one dispatcher pass now instead of waiting for the
+ *  ~60s gateway tick. This is the only sanctioned path into 'running'
+ *  ('ready → running' happens via dispatcher claim; a direct PATCH
+ *  status=running is rejected with 400 — 409 is reserved for invalid
+ *  transitions / blocking parents). */
+export function kanbanDispatchNudge(board?: null | string): Promise<KanbanDispatchResult> {
+  return window.hermesDesktop.api<KanbanDispatchResult>({
+    path: kanbanPath('/dispatch', board),
+    method: 'POST',
+    body: {},
+    // Spawning workers (git worktrees, process launch) can be slow.
+    timeoutMs: 60_000
+  })
+}
+
+/** Union of on-disk profiles and board assignees — feeds the assignee pickers
+ *  so a fresh profile is selectable before it holds any task. */
+export async function getKanbanAssignees(board?: null | string): Promise<KanbanAssignee[]> {
+  const { assignees } = await window.hermesDesktop.api<{ assignees: KanbanAssignee[] }>({
+    path: kanbanPath('/assignees', board)
+  })
+
+  return assignees ?? []
+}
+
+export function getKanbanTaskLog(taskId: string, board?: null | string, tailBytes = 20_000): Promise<KanbanTaskLog> {
+  return window.hermesDesktop.api<KanbanTaskLog>({
+    path: kanbanPath(`/tasks/${encodeURIComponent(taskId)}/log?tail=${tailBytes}`, board)
+  })
+}
+
+export interface KanbanApiError {
+  status: null | number
+  detail: string
+}
+
+// Electron's fetchJson rejects HTTP errors as `Error("<status>: <body>")` where
+// the body is FastAPI JSON like {"detail": "..."}. By the time that rejection
+// crosses ipcRenderer.invoke it arrives wrapped as
+// `Error invoking remote method 'hermes:api': Error: <status>: <body>`, so
+// unwrap the IPC prefix first (same pattern as store/notifications.ts). 409
+// payloads carry actionable transition messages (blocking parents, invalid
+// transitions), so surface the detail text and keep the status for revert
+// decisions.
+export function parseKanbanApiError(error: unknown): KanbanApiError {
+  const raw = error instanceof Error ? error.message : String(error ?? '')
+  const unwrapped = /Error invoking remote method '[^']+': Error: ([\s\S]+)$/.exec(raw)?.[1] ?? raw
+  const message = unwrapped.replace(/^Error:\s*/, '').trim()
+  const match = /^(\d{3}):\s*([\s\S]*)$/.exec(message)
+
+  if (!match) {
+    return { status: null, detail: message }
+  }
+
+  const status = Number(match[1])
+  const body = match[2].trim()
+
+  try {
+    const parsed = JSON.parse(body) as { detail?: unknown }
+
+    if (parsed && typeof parsed.detail === 'string' && parsed.detail) {
+      return { status, detail: parsed.detail }
+    }
+  } catch {
+    // Non-JSON body — fall through to the raw text.
+  }
+
+  return { status, detail: body || message }
+}
diff --git a/apps/desktop/src/lib/icons.ts b/apps/desktop/src/lib/icons.ts
index e863aa3928045..392c6f1730a03 100644
--- a/apps/desktop/src/lib/icons.ts
+++ b/apps/desktop/src/lib/icons.ts
@@ -46,6 +46,7 @@ import {
   IconHelpCircle as HelpCircle,
   IconPhoto as ImageIcon,
   IconInfoCircle as Info,
+  IconLayoutKanban as Kanban,
   IconKey as KeyRound,
   IconLayersIntersect2 as Layers3,
   IconLayoutDashboard as LayoutDashboard,
@@ -161,6 +162,7 @@ export {
   HelpCircle,
   ImageIcon,
   Info,
+  Kanban,
   KeyRound,
   Layers3,
   LayoutDashboard,
diff --git a/apps/desktop/src/lib/keybinds/actions.ts b/apps/desktop/src/lib/keybinds/actions.ts
index 913b7c96a8f71..be0c53a0b68fa 100644
--- a/apps/desktop/src/lib/keybinds/actions.ts
+++ b/apps/desktop/src/lib/keybinds/actions.ts
@@ -89,6 +89,7 @@ export const KEYBIND_ACTIONS: readonly KeybindActionMeta[] = [
   { id: 'nav.messaging', category: 'navigation', defaults: [] },
   { id: 'nav.artifacts', category: 'navigation', defaults: [] },
   { id: 'nav.cron', category: 'navigation', defaults: [] },
+  { id: 'nav.kanban', category: 'navigation', defaults: [] },
   { id: 'nav.agents', category: 'navigation', defaults: [] },
 
   // ── View (layout + appearance + the shortcuts panel itself) ───────────────
diff --git a/apps/desktop/src/store/kanban.test.ts b/apps/desktop/src/store/kanban.test.ts
new file mode 100644
index 0000000000000..baf22f59b50d3
--- /dev/null
+++ b/apps/desktop/src/store/kanban.test.ts
@@ -0,0 +1,336 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { parseKanbanApiError } from '@/kanban-api'
+import type { KanbanBoardPayload, KanbanCard } from '@/types/kanban'
+
+import {
+  $kanbanActiveBoard,
+  $kanbanBoard,
+  $kanbanBoardError,
+  $kanbanRefreshing,
+  $kanbanSelectedTaskId,
+  allowedDropColumns,
+  applyKanbanCardMove,
+  findKanbanCard,
+  isAllowedDrop,
+  KANBAN_COLUMNS,
+  KANBAN_DRAG_TARGETS,
+  moveKanbanTask,
+  reconcileKanbanBoard,
+  refreshKanbanBoard,
+  setKanbanActiveBoard
+} from './kanban'
+
+function card(id: string, status: string, extra: Partial<KanbanCard> = {}): KanbanCard {
+  return {
+    id,
+    title: `Task ${id}`,
+    body: null,
+    assignee: 'coder',
+    status,
+    priority: 0,
+    created_by: 'test',
+    created_at: 1,
+    started_at: null,
+    completed_at: null,
+    workspace_kind: 'scratch',
+    workspace_path: null,
+    claim_lock: null,
+    claim_expires: null,
+    tenant: null,
+    ...extra
+  }
+}
+
+function boardWith(cards: KanbanCard[], latestEventId = 10): KanbanBoardPayload {
+  return {
+    columns: KANBAN_COLUMNS.map(name => ({
+      name,
+      tasks: cards.filter(entry => entry.status === name)
+    })),
+    tenants: [],
+    assignees: ['coder'],
+    latest_event_id: latestEventId,
+    now: 1000
+  }
+}
+
+function columnTasks(board: KanbanBoardPayload | null, name: string): string[] {
+  return board?.columns.find(column => column.name === name)?.tasks.map(task => task.id) ?? []
+}
+
+describe('kanban transition rules', () => {
+  it('never offers running as a drag target (dispatcher-claim only)', () => {
+    expect(KANBAN_DRAG_TARGETS).not.toContain('running')
+
+    for (const status of KANBAN_COLUMNS) {
+      expect(allowedDropColumns(status)).not.toContain('running')
+    }
+  })
+
+  it("excludes the card's own column from its drop targets", () => {
+    expect(allowedDropColumns('todo')).not.toContain('todo')
+    expect(allowedDropColumns('todo')).toEqual(['triage', 'scheduled', 'ready', 'blocked', 'review', 'done'])
+  })
+
+  it('allows dragging OFF running (reclaim back to the queue)', () => {
+    expect(isAllowedDrop('running', 'ready')).toBe(true)
+    expect(isAllowedDrop('ready', 'running')).toBe(false)
+    expect(isAllowedDrop('todo', 'todo')).toBe(false)
+  })
+})
+
+describe('reconcileKanbanBoard (polling cursor)', () => {
+  it('keeps the previous atom identity when latest_event_id is unchanged', () => {
+    const prev = boardWith([card('t_1', 'todo')], 42)
+    // Same cursor, different `now`/age churn — must be treated as no change.
+    const next = { ...boardWith([card('t_1', 'todo')], 42), now: 2000 }
+
+    expect(reconcileKanbanBoard(prev, next)).toBe(prev)
+  })
+
+  it('adopts the new payload when the cursor advanced', () => {
+    const prev = boardWith([card('t_1', 'todo')], 42)
+    const next = boardWith([card('t_1', 'ready')], 43)
+
+    expect(reconcileKanbanBoard(prev, next)).toBe(next)
+    expect(reconcileKanbanBoard(null, next)).toBe(next)
+  })
+})
+
+describe('board card helpers', () => {
+  it('finds cards across columns and moves them immutably', () => {
+    const board = boardWith([card('t_1', 'todo'), card('t_2', 'ready')])
+
+    expect(findKanbanCard(board, 't_2')?.status).toBe('ready')
+    expect(findKanbanCard(board, 't_x')).toBeNull()
+
+    const moved = applyKanbanCardMove(board, 't_1', 'review')
+
+    expect(columnTasks(moved, 'todo')).toEqual([])
+    expect(columnTasks(moved, 'review')).toEqual(['t_1'])
+    expect(findKanbanCard(moved, 't_1')?.status).toBe('review')
+    // Original untouched.
+    expect(columnTasks(board, 'todo')).toEqual(['t_1'])
+  })
+})
+
+describe('moveKanbanTask', () => {
+  let api: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    api = vi.fn()
+    Object.defineProperty(window, 'hermesDesktop', {
+      configurable: true,
+      value: { api }
+    })
+    window.localStorage.clear()
+    $kanbanBoard.set(boardWith([card('t_1', 'todo'), card('t_2', 'running')]))
+    $kanbanBoardError.set(null)
+    $kanbanRefreshing.set(false)
+    $kanbanSelectedTaskId.set(null)
+    $kanbanActiveBoard.set(null)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    Reflect.deleteProperty(window, 'hermesDesktop')
+  })
+
+  it('PATCHes the status and reconciles from the server response', async () => {
+    api.mockImplementation(async (request: { path: string; method?: string }) => {
+      if (request.method === 'PATCH') {
+        return { task: card('t_1', 'ready') }
+      }
+
+      // Post-mutation authoritative refetch.
+      return boardWith([card('t_1', 'ready'), card('t_2', 'running')], 11)
+    })
+
+    const result = await moveKanbanTask('t_1', 'ready')
+
+    expect(result).toEqual({ ok: true, status: 'ready', ruleMoved: false })
+    expect(api).toHaveBeenCalledWith(
+      expect.objectContaining({
+        path: '/api/plugins/kanban/tasks/t_1',
+        method: 'PATCH',
+        body: { status: 'ready' }
+      })
+    )
+    expect(columnTasks($kanbanBoard.get(), 'ready')).toContain('t_1')
+    expect(columnTasks($kanbanBoard.get(), 'todo')).not.toContain('t_1')
+  })
+
+  it("renders the server's column when board rules redirect the transition", async () => {
+    // Production backends can bounce done → review (review-required auto-inject).
+    api.mockImplementation(async (request: { method?: string }) => {
+      if (request.method === 'PATCH') {
+        return { task: card('t_1', 'review') }
+      }
+
+      return boardWith([card('t_1', 'review'), card('t_2', 'running')], 11)
+    })
+
+    const result = await moveKanbanTask('t_1', 'done')
+
+    expect(result.ok).toBe(true)
+    expect(result.ruleMoved).toBe(true)
+    expect(result.status).toBe('review')
+    expect(columnTasks($kanbanBoard.get(), 'review')).toContain('t_1')
+    expect(columnTasks($kanbanBoard.get(), 'done')).not.toContain('t_1')
+  })
+
+  it('reverts the optimistic move and surfaces the 409 detail', async () => {
+    const snapshot = $kanbanBoard.get()
+
+    // Model the real renderer shape: fetchJson's `409: {json}` rejection is
+    // re-wrapped by ipcRenderer.invoke before it reaches the store.
+    api.mockRejectedValue(
+      new Error(
+        'Error invoking remote method \'hermes:api\': Error: 409: {"detail": "Cannot move to \'ready\': blocked by parent(s) not done — \'Parent\' (t_9, status=todo)"}'
+      )
+    )
+
+    const result = await moveKanbanTask('t_1', 'ready')
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toContain('blocked by parent(s)')
+    expect($kanbanBoard.get()).toBe(snapshot)
+    expect(columnTasks($kanbanBoard.get(), 'todo')).toContain('t_1')
+  })
+
+  it('refuses running as a target without calling the backend', async () => {
+    const result = await moveKanbanTask('t_1', 'running')
+
+    expect(result.ok).toBe(false)
+    expect(api).not.toHaveBeenCalled()
+  })
+
+  it('no-ops when dropped back on its own column', async () => {
+    const result = await moveKanbanTask('t_1', 'todo')
+
+    expect(result).toEqual({ ok: true, status: 'todo' })
+    expect(api).not.toHaveBeenCalled()
+  })
+})
+
+describe('refreshKanbanBoard', () => {
+  let api: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    api = vi.fn()
+    Object.defineProperty(window, 'hermesDesktop', {
+      configurable: true,
+      value: { api }
+    })
+    window.localStorage.clear()
+    $kanbanBoard.set(null)
+    $kanbanBoardError.set(null)
+    $kanbanRefreshing.set(false)
+    $kanbanActiveBoard.set(null)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    Reflect.deleteProperty(window, 'hermesDesktop')
+  })
+
+  it('keeps atom identity across polls with an unchanged cursor', async () => {
+    api.mockResolvedValue(boardWith([card('t_1', 'todo')], 7))
+
+    await refreshKanbanBoard()
+    const first = $kanbanBoard.get()
+
+    await refreshKanbanBoard()
+
+    expect($kanbanBoard.get()).toBe(first)
+    expect(api).toHaveBeenCalledTimes(2)
+  })
+
+  it('scopes the fetch to the active board slug', async () => {
+    $kanbanActiveBoard.set('atm10-server')
+    api.mockResolvedValue(boardWith([], 1))
+
+    await refreshKanbanBoard()
+
+    expect(api).toHaveBeenCalledWith(expect.objectContaining({ path: '/api/plugins/kanban/board?board=atm10-server' }))
+  })
+
+  it('falls back to the default board when the persisted slug 404s', async () => {
+    $kanbanActiveBoard.set('deleted-board')
+    api.mockRejectedValue(
+      new Error(
+        'Error invoking remote method \'hermes:api\': Error: 404: {"detail": "board \'deleted-board\' does not exist"}'
+      )
+    )
+
+    await refreshKanbanBoard()
+
+    expect($kanbanActiveBoard.get()).toBeNull()
+    expect($kanbanBoardError.get()).toContain('does not exist')
+  })
+})
+
+describe('setKanbanActiveBoard', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+    $kanbanActiveBoard.set(null)
+    $kanbanBoard.set(boardWith([card('t_1', 'todo')]))
+    $kanbanSelectedTaskId.set('t_1')
+  })
+
+  it('persists the slug and resets board-scoped state', () => {
+    setKanbanActiveBoard('side-project')
+
+    expect($kanbanActiveBoard.get()).toBe('side-project')
+    expect(window.localStorage.getItem('hermes.desktop.kanban.activeBoard')).toBe('side-project')
+    expect($kanbanBoard.get()).toBeNull()
+    expect($kanbanSelectedTaskId.get()).toBeNull()
+  })
+})
+
+describe('parseKanbanApiError', () => {
+  it('extracts status and FastAPI detail', () => {
+    const parsed = parseKanbanApiError(
+      new Error('409: {"detail": "status transition to \'done\' not valid from current state"}')
+    )
+
+    expect(parsed.status).toBe(409)
+    expect(parsed.detail).toBe("status transition to 'done' not valid from current state")
+  })
+
+  it('unwraps the Electron IPC prefix before parsing', () => {
+    // window.hermesDesktop.api errors cross ipcRenderer.invoke, which rewrites
+    // the rejection to this wrapped form — the production shape of every
+    // kanban API error in the renderer.
+    const parsed = parseKanbanApiError(
+      new Error(
+        'Error invoking remote method \'hermes:api\': Error: 409: {"detail": "Cannot move to \'ready\': blocked by parent(s) not done — \'Parent\' (t1, status=todo)"}'
+      )
+    )
+
+    expect(parsed.status).toBe(409)
+    expect(parsed.detail).toBe("Cannot move to 'ready': blocked by parent(s) not done — 'Parent' (t1, status=todo)")
+  })
+
+  it('unwraps the IPC prefix for non-HTTP errors too', () => {
+    expect(parseKanbanApiError(new Error("Error invoking remote method 'hermes:api': Error: socket hang up"))).toEqual(
+      {
+        status: null,
+        detail: 'socket hang up'
+      }
+    )
+  })
+
+  it('passes through non-HTTP errors', () => {
+    expect(parseKanbanApiError(new Error('socket hang up'))).toEqual({ status: null, detail: 'socket hang up' })
+  })
+
+  it('tolerates non-JSON bodies', () => {
+    expect(parseKanbanApiError(new Error('500: Internal Server Error'))).toEqual({
+      status: 500,
+      detail: 'Internal Server Error'
+    })
+  })
+})
diff --git a/apps/desktop/src/store/kanban.ts b/apps/desktop/src/store/kanban.ts
new file mode 100644
index 0000000000000..f83ae7e691d93
--- /dev/null
+++ b/apps/desktop/src/store/kanban.ts
@@ -0,0 +1,231 @@
+import { atom } from 'nanostores'
+
+import { getKanbanBoard, getKanbanBoards, parseKanbanApiError, updateKanbanTask } from '@/kanban-api'
+import { persistString, storedString } from '@/lib/storage'
+import type { KanbanBoardInfo, KanbanBoardPayload, KanbanCard, KanbanTask } from '@/types/kanban'
+
+// Column order mirrors BOARD_COLUMNS in plugins/kanban/dashboard/plugin_api.py.
+export const KANBAN_COLUMNS = ['triage', 'todo', 'scheduled', 'ready', 'running', 'blocked', 'review', 'done'] as const
+
+export type KanbanColumnName = (typeof KANBAN_COLUMNS)[number]
+
+// 'running' is NEVER a drag target: ready → running happens only via the
+// dispatcher's claim path, and the backend rejects a direct PATCH to
+// 'running' with 400 (409 is reserved for invalid transitions / blocking
+// parents). Everything
+// else is a legal drop column (the server still owns transition semantics —
+// review-required rules may bounce done → review, blocked stickiness may keep
+// a card put; we render whatever it returns).
+export const KANBAN_DRAG_TARGETS: readonly KanbanColumnName[] = KANBAN_COLUMNS.filter(name => name !== 'running')
+
+/** Columns a card in `fromStatus` may be dropped on (excludes its own column). */
+export function allowedDropColumns(fromStatus: string): KanbanColumnName[] {
+  return KANBAN_DRAG_TARGETS.filter(name => name !== fromStatus)
+}
+
+export function isAllowedDrop(fromStatus: string, toColumn: string): boolean {
+  return (allowedDropColumns(fromStatus) as string[]).includes(toColumn)
+}
+
+const BOARD_STORAGE_KEY = 'hermes.desktop.kanban.activeBoard'
+
+export const $kanbanBoards = atom<KanbanBoardInfo[]>([])
+
+// Active board slug. null → the backend's current board (env → current file →
+// default). Client-side selection only (persisted locally) so picking a board
+// here never flips the CLI/gateway's shared current-board pointer.
+export const $kanbanActiveBoard = atom<null | string>(storedString(BOARD_STORAGE_KEY))
+
+export const $kanbanBoard = atom<KanbanBoardPayload | null>(null)
+export const $kanbanBoardError = atom<null | string>(null)
+export const $kanbanSelectedTaskId = atom<null | string>(null)
+
+// Polling state: true while a background refresh is in flight (prevents
+// overlapping fetches when the interval outpaces a slow backend).
+export const $kanbanRefreshing = atom(false)
+
+export function setKanbanActiveBoard(slug: null | string): void {
+  const next = slug || null
+
+  if (next === $kanbanActiveBoard.get()) {
+    return
+  }
+
+  persistString(BOARD_STORAGE_KEY, next)
+  $kanbanActiveBoard.set(next)
+  // Different board → old columns/selection are meaningless.
+  $kanbanBoard.set(null)
+  $kanbanBoardError.set(null)
+  $kanbanSelectedTaskId.set(null)
+}
+
+export function setKanbanSelectedTaskId(id: null | string): void {
+  $kanbanSelectedTaskId.set(id)
+}
+
+// latest_event_id is the cheap change cursor: an unchanged cursor means no
+// task_events row was appended, so keep the previous atom value (identity)
+// and skip all downstream re-render work. `now`/age fields churn every fetch,
+// which is exactly why the cursor comparison replaces deep-equality here.
+export function reconcileKanbanBoard(prev: KanbanBoardPayload | null, next: KanbanBoardPayload): KanbanBoardPayload {
+  if (prev && prev.latest_event_id === next.latest_event_id) {
+    return prev
+  }
+
+  return next
+}
+
+export async function refreshKanbanBoards(): Promise<void> {
+  try {
+    const { boards } = await getKanbanBoards()
+
+    $kanbanBoards.set(boards)
+
+    // A persisted slug whose board has since been deleted/archived would 404
+    // every poll — fall back to the server's current board.
+    const active = $kanbanActiveBoard.get()
+
+    if (active && !boards.some(board => board.slug === active)) {
+      setKanbanActiveBoard(null)
+    }
+  } catch {
+    // Board list is auxiliary chrome; the board fetch surfaces real errors.
+  }
+}
+
+export async function refreshKanbanBoard(): Promise<void> {
+  if ($kanbanRefreshing.get()) {
+    return
+  }
+
+  $kanbanRefreshing.set(true)
+
+  try {
+    const next = await getKanbanBoard($kanbanActiveBoard.get())
+
+    $kanbanBoard.set(reconcileKanbanBoard($kanbanBoard.get(), next))
+    $kanbanBoardError.set(null)
+  } catch (error) {
+    const parsed = parseKanbanApiError(error)
+
+    if (parsed.status === 404 && $kanbanActiveBoard.get()) {
+      // Stale persisted board — reset and let the next poll load the default.
+      setKanbanActiveBoard(null)
+    }
+
+    $kanbanBoardError.set(parsed.detail)
+  } finally {
+    $kanbanRefreshing.set(false)
+  }
+}
+
+export function findKanbanCard(board: KanbanBoardPayload | null, taskId: string): KanbanCard | null {
+  if (!board) {
+    return null
+  }
+
+  for (const column of board.columns) {
+    const card = column.tasks.find(task => task.id === taskId)
+
+    if (card) {
+      return card
+    }
+  }
+
+  return null
+}
+
+/** Immutably move a card to `toStatus`'s column (appended; server ordering is
+ *  restored by the authoritative refetch). `patch` overlays server task fields. */
+export function applyKanbanCardMove(
+  board: KanbanBoardPayload,
+  taskId: string,
+  toStatus: string,
+  patch?: Partial<KanbanTask>
+): KanbanBoardPayload {
+  const card = findKanbanCard(board, taskId)
+
+  if (!card) {
+    return board
+  }
+
+  const moved: KanbanCard = { ...card, ...patch, status: toStatus }
+
+  return {
+    ...board,
+    columns: board.columns.map(column => {
+      const without = column.tasks.filter(task => task.id !== taskId)
+      const tasks = column.name === toStatus ? [...without, moved] : without
+
+      return tasks === column.tasks ? column : { ...column, tasks }
+    })
+  }
+}
+
+export interface KanbanMoveResult {
+  ok: boolean
+  /** Status the server actually landed the card on (success only). */
+  status?: string
+  /** True when board rules redirected the move (e.g. done bounced to review). */
+  ruleMoved?: boolean
+  error?: string
+}
+
+// Server-authoritative move: optimistic column swap for immediate feedback,
+// then reconcile from the PATCH response (production backends carry local
+// transition patches — review-required auto-inject, blocked-initial-status
+// stickiness — so the card may land somewhere other than the drop target).
+// Errors (409 with an actionable detail) revert to the pre-drag snapshot.
+export async function moveKanbanTask(taskId: string, targetStatus: string): Promise<KanbanMoveResult> {
+  const board = $kanbanBoard.get()
+  const card = findKanbanCard(board, taskId)
+
+  if (!board || !card) {
+    return { ok: false, error: 'task not on board' }
+  }
+
+  if (card.status === targetStatus) {
+    return { ok: true, status: card.status }
+  }
+
+  if (!isAllowedDrop(card.status, targetStatus)) {
+    return { ok: false, error: `cannot move to ${targetStatus}` }
+  }
+
+  const snapshot = board
+
+  $kanbanBoard.set(applyKanbanCardMove(board, taskId, targetStatus))
+
+  try {
+    const response = await updateKanbanTask(taskId, { status: targetStatus }, $kanbanActiveBoard.get())
+    const serverTask = response.task
+    const serverStatus = serverTask?.status ?? targetStatus
+    const current = $kanbanBoard.get()
+
+    if (current) {
+      $kanbanBoard.set(applyKanbanCardMove(current, taskId, serverStatus, serverTask ?? undefined))
+    }
+
+    // Refetch so rollups (progress, ready-recompute side effects on other
+    // cards) reflect the server, not our local guess.
+    void refreshKanbanBoard()
+
+    return { ok: true, status: serverStatus, ruleMoved: serverStatus !== targetStatus }
+  } catch (error) {
+    $kanbanBoard.set(snapshot)
+
+    return { ok: false, error: parseKanbanApiError(error).detail }
+  }
+}
+
+/** Overlay a server-returned task onto its board card in place (post-PATCH
+ *  reconcile for non-move edits: assignee, priority, title, body). */
+export function applyKanbanTaskPatch(task: KanbanTask): void {
+  const board = $kanbanBoard.get()
+
+  if (!board || !findKanbanCard(board, task.id)) {
+    return
+  }
+
+  $kanbanBoard.set(applyKanbanCardMove(board, task.id, task.status, task))
+}
diff --git a/apps/desktop/src/types/kanban.ts b/apps/desktop/src/types/kanban.ts
new file mode 100644
index 0000000000000..684722d131acd
--- /dev/null
+++ b/apps/desktop/src/types/kanban.ts
@@ -0,0 +1,229 @@
+// Response shapes for the kanban dashboard plugin REST API
+// (plugins/kanban/dashboard/plugin_api.py, mounted at /api/plugins/kanban/).
+// Kanban is HOME-scoped: boards are shared across profiles by design, so none
+// of these payloads carry a profile dimension.
+
+export interface KanbanTaskAge {
+  created_age_seconds: null | number
+  started_age_seconds: null | number
+  time_to_complete_seconds: null | number
+}
+
+export interface KanbanDiagnosticAction {
+  kind: string
+  label: string
+  payload: Record<string, unknown>
+  suggested: boolean
+}
+
+export interface KanbanDiagnostic {
+  kind: string
+  severity: 'critical' | 'error' | 'warning' | (string & {})
+  title: string
+  detail: string
+  actions: KanbanDiagnosticAction[]
+  first_seen_at: number
+  last_seen_at: number
+  count: number
+}
+
+export interface KanbanWarningsSummary {
+  count: number
+  kinds: Record<string, number>
+  latest_at: number
+  highest_severity: null | string
+}
+
+export interface KanbanTask {
+  id: string
+  title: string
+  body: null | string
+  assignee: null | string
+  status: string
+  priority: number
+  created_by: null | string
+  created_at: number
+  started_at: null | number
+  completed_at: null | number
+  workspace_kind: string
+  workspace_path: null | string
+  claim_lock: null | string
+  claim_expires: null | number
+  tenant: null | string
+  branch_name?: null | string
+  project_id?: null | string
+  result?: null | string
+  idempotency_key?: null | string
+  consecutive_failures?: number
+  worker_pid?: null | number
+  last_failure_error?: null | string
+  max_runtime_seconds?: null | number
+  last_heartbeat_at?: null | number
+  current_run_id?: null | number
+  workflow_template_id?: null | string
+  current_step_key?: null | string
+  skills?: null | string[]
+  model_override?: null | string
+  session_id?: null | string
+  age?: KanbanTaskAge
+  /** Latest non-null run summary. 200-char preview on /board, full on /tasks/:id. */
+  latest_summary?: null | string
+  diagnostics?: KanbanDiagnostic[]
+  warnings?: KanbanWarningsSummary | null
+}
+
+/** Board-card projection: a task plus the per-card rollups /board attaches. */
+export interface KanbanCard extends KanbanTask {
+  link_counts?: { parents: number; children: number }
+  comment_count?: number
+  /** Children progress rollup; null/absent when the task has no children. */
+  progress?: { done: number; total: number } | null
+}
+
+export interface KanbanColumn {
+  name: string
+  tasks: KanbanCard[]
+}
+
+export interface KanbanBoardPayload {
+  columns: KanbanColumn[]
+  tenants: string[]
+  assignees: string[]
+  /** Max task_events id — cheap change cursor for polling. */
+  latest_event_id: number
+  now: number
+}
+
+export interface KanbanComment {
+  id: number
+  task_id: string
+  author: null | string
+  body: string
+  created_at: number
+}
+
+export interface KanbanEvent {
+  id: number
+  task_id: string
+  kind: string
+  payload: null | Record<string, unknown>
+  created_at: number
+  run_id: null | number
+}
+
+export interface KanbanAttachment {
+  id: number
+  task_id: string
+  filename: string
+  content_type: null | string
+  size: null | number
+  uploaded_by: null | string
+  stored_path: string
+  created_at: number
+}
+
+export interface KanbanRun {
+  id: number
+  task_id: string
+  profile: null | string
+  step_key: null | string
+  status: string
+  claim_lock: null | string
+  claim_expires: null | number
+  worker_pid: null | number
+  max_runtime_seconds: null | number
+  last_heartbeat_at: null | number
+  started_at: number
+  ended_at: null | number
+  outcome: null | string
+  summary: null | string
+  metadata: null | Record<string, unknown>
+  error: null | string
+}
+
+export interface KanbanLinks {
+  parents: string[]
+  children: string[]
+}
+
+export interface KanbanTaskDetail {
+  task: KanbanTask
+  comments: KanbanComment[]
+  events: KanbanEvent[]
+  attachments: KanbanAttachment[]
+  links: KanbanLinks
+  runs: KanbanRun[]
+}
+
+export interface KanbanBoardInfo {
+  slug: string
+  name: string
+  description: string
+  icon: string
+  color: string
+  default_workdir?: null | string
+  created_at?: null | number
+  archived?: boolean
+  is_current?: boolean
+  counts?: Record<string, number>
+  total?: number
+}
+
+export interface KanbanBoardsResponse {
+  boards: KanbanBoardInfo[]
+  current: string
+}
+
+export interface KanbanAssignee {
+  name: string
+  on_disk: boolean
+  counts: Record<string, number>
+}
+
+export interface KanbanCreateTaskPayload {
+  title: string
+  body?: string
+  assignee?: string
+  tenant?: string
+  priority?: number
+  parents?: string[]
+  triage?: boolean
+}
+
+export interface KanbanCreateTaskResponse {
+  task: KanbanTask | null
+  /** Dispatcher-presence warning (ready+assigned task with no dispatcher running). */
+  warning?: string
+}
+
+export interface KanbanUpdateTaskPayload {
+  status?: string
+  assignee?: string
+  priority?: number
+  title?: string
+  body?: string
+  result?: string
+  block_reason?: string
+  summary?: string
+}
+
+export interface KanbanUpdateTaskResponse {
+  task: KanbanTask | null
+}
+
+export interface KanbanDispatchResult {
+  reclaimed?: number
+  promoted?: number
+  spawned?: [string, string, string][]
+  skipped_unassigned?: string[]
+  auto_assigned_default?: string[]
+}
+
+export interface KanbanTaskLog {
+  task_id: string
+  path: string
+  exists: boolean
+  size_bytes: number
+  content: string
+  truncated: boolean
+}

From 8f87ee25e344cd30ad701c3cb6785ea972428318 Mon Sep 17 00:00:00 2001
From: Rod-fernandez <rodrigo@nxtlevelsaas.com>
Date: Sat, 4 Jul 2026 01:35:44 -0400
Subject: [PATCH 2/6] fix(desktop): boot retry, reconnect reconciliation,
 refresh coalescing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- resolveGatewayWsUrl maps mint failures to reauth only when auth-shaped
  (401/403/needsOauthLogin); transport errors stay retryable.
- Failed initial boot retries on 5s/15s/30s/60s jittered backoff and on
  wake/online/visibility nudges; genuine auth failures latch with the
  sign-in overlay instead of thrashing.
- After a socket reconnect (primary or secondary), reconcile cached busy
  sessions against session.active_list — clears composers stuck on
  'Thinking…' when message.complete died with the socket.
- Coalesce refreshSessions (1.5s trailing + single-flight, ancillary
  cron/messaging fan-out throttled to 30s) and debounce session.info
  config refetches (5s, gated to config-bearing events).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/src/app/desktop-controller.tsx   |  19 +-
 .../gateway/hooks/use-gateway-boot.test.tsx   | 121 ++++++++++++-
 .../src/app/gateway/hooks/use-gateway-boot.ts | 115 +++++++++++-
 .../use-reconnect-reconciliation.test.tsx     | 164 ++++++++++++++++++
 .../hooks/use-reconnect-reconciliation.ts     | 127 ++++++++++++++
 .../session/hooks/refresh-coalescer.test.ts   |  96 ++++++++++
 .../app/session/hooks/refresh-coalescer.ts    |  68 ++++++++
 .../config-refresh.test.tsx                   | 114 ++++++++++++
 .../hooks/use-message-stream/gateway-event.ts |  47 ++++-
 .../session/hooks/use-message-stream/index.ts |  11 +-
 .../use-message-stream/todo-cleanup.test.tsx  |   2 +-
 .../hooks/use-session-list-actions.test.tsx   |  99 +++++++++++
 .../session/hooks/use-session-list-actions.ts |  58 ++++++-
 apps/desktop/src/lib/gateway-ws-url.test.ts   |  73 +++++++-
 apps/desktop/src/store/gateway.ts             |   4 +
 apps/shared/src/index.ts                      |   1 +
 apps/shared/src/websocket-url.ts              |  48 ++++-
 17 files changed, 1139 insertions(+), 28 deletions(-)
 create mode 100644 apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.test.tsx
 create mode 100644 apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.ts
 create mode 100644 apps/desktop/src/app/session/hooks/refresh-coalescer.test.ts
 create mode 100644 apps/desktop/src/app/session/hooks/refresh-coalescer.ts
 create mode 100644 apps/desktop/src/app/session/hooks/use-message-stream/config-refresh.test.tsx
 create mode 100644 apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx

diff --git a/apps/desktop/src/app/desktop-controller.tsx b/apps/desktop/src/app/desktop-controller.tsx
index 0695a15638dc1..559559e32ce0c 100644
--- a/apps/desktop/src/app/desktop-controller.tsx
+++ b/apps/desktop/src/app/desktop-controller.tsx
@@ -90,6 +90,7 @@ import { ChatSidebar } from './chat/sidebar'
 import { CommandPalette } from './command-palette'
 import { useGatewayBoot } from './gateway/hooks/use-gateway-boot'
 import { useGatewayRequest } from './gateway/hooks/use-gateway-request'
+import { useReconnectReconciliation } from './gateway/hooks/use-reconnect-reconciliation'
 import { useKeybinds } from './hooks/use-keybinds'
 import { SIDEBAR_COLLAPSE_MEDIA_QUERY } from './layout-constants'
 import { ModelPickerOverlay } from './model-picker-overlay'
@@ -399,19 +400,21 @@ export function DesktopController() {
     loadMoreSessionsForProfile,
     refreshCronJobs,
     refreshMessagingSessions,
-    refreshSessions
+    refreshSessions,
+    scheduleSessionsRefresh
   } = useSessionListActions({ profileScope })
 
   // Another window mutated the shared session list (e.g. a chat started in the
   // pop-out). Re-pull so the sidebar reflects it. Pop-outs have no sidebar, so
-  // only real windows bother.
+  // only real windows bother. Coalesced: a burst of completions in another
+  // window collapses to one refresh here.
   useEffect(() => {
     if (isSecondaryWindow()) {
       return
     }
 
-    return onSessionsChanged(() => void refreshSessions().catch(() => undefined))
-  }, [refreshSessions])
+    return onSessionsChanged(() => scheduleSessionsRefresh())
+  }, [scheduleSessionsRefresh])
 
   const toggleSelectedPin = useCallback(() => {
     const sessionId = $selectedStoredSessionId.get()
@@ -588,7 +591,7 @@ export function DesktopController() {
     hydrateFromStoredSession,
     queryClient,
     refreshHermesConfig,
-    refreshSessions,
+    scheduleSessionsRefresh,
     sessionStateByRuntimeIdRef,
     updateSessionState
   })
@@ -878,6 +881,11 @@ export function DesktopController() {
     return $attentionSessionIds.listen(sync)
   }, [])
 
+  const reconcileBusySessions = useReconnectReconciliation({
+    sessionStateByRuntimeIdRef,
+    updateSessionState
+  })
+
   useGatewayBoot({
     handleGatewayEvent: handleDesktopGatewayEvent,
     onConnectionReady: c => {
@@ -886,6 +894,7 @@ export function DesktopController() {
     onGatewayReady: g => {
       gatewayRef.current = g
     },
+    reconcileBusySessions,
     refreshHermesConfig,
     refreshSessions
   })
diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.test.tsx b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.test.tsx
index eb893c3675a0e..9aa95e5c2f946 100644
--- a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.test.tsx
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.test.tsx
@@ -104,11 +104,16 @@ function fakeDesktop() {
   }
 }
 
-function Harness() {
+function Harness({
+  reconcileBusySessions
+}: {
+  reconcileBusySessions?: (gateway: unknown, profile: string) => Promise<void>
+} = {}) {
   useGatewayBoot({
     handleGatewayEvent: () => undefined,
     onConnectionReady: () => undefined,
     onGatewayReady: () => undefined,
+    reconcileBusySessions,
     refreshHermesConfig: async () => undefined,
     refreshSessions: async () => undefined
   })
@@ -266,4 +271,118 @@ describe('useGatewayBoot remote reconnect loop (real hook, fake socket)', () =>
     expect($gatewayState.get()).toBe('open')
     expect($desktopBoot.get().error).toBeNull()
   })
+
+  it('runs the busy-state reconciliation after a successful reconnect', async () => {
+    const reconcile = vi.fn(async (_gateway: unknown, _profile: string) => undefined)
+    render(<Harness reconcileBusySessions={reconcile} />)
+    await flushAsync()
+    expect($gatewayState.get()).toBe('open')
+    // The initial boot is not a reconnect — nothing to reconcile yet.
+    expect(reconcile).not.toHaveBeenCalled()
+
+    act(() => FakeWebSocket.instances[0].drop())
+    await flushAsync()
+    await advanceBackoff()
+
+    expect($gatewayState.get()).toBe('open')
+    expect(reconcile).toHaveBeenCalledTimes(1)
+    expect(reconcile.mock.calls[0][1]).toBe('default')
+  })
+})
+
+describe('useGatewayBoot dead-at-launch boot retry (B2)', () => {
+  it('retries a transport-failed boot on backoff until the backend comes back', async () => {
+    // Backend unreachable at launch: getConnection rejects with the
+    // waitForHermes timeout twice, then the tunnel comes up.
+    const desktop = fakeDesktop()
+    const realGetConnection = desktop.getConnection
+    let failures = 2
+    desktop.getConnection = vi.fn(async () => {
+      if (failures > 0) {
+        failures -= 1
+        throw new Error('Hermes backend did not become ready: Timed out connecting to Hermes backend after 15000ms')
+      }
+
+      return realGetConnection()
+    })
+    ;(window as { hermesDesktop?: unknown }).hermesDesktop = desktop
+
+    render(<Harness />)
+    await flushAsync()
+
+    // First boot failed → failure overlay up, retry scheduled.
+    expect($desktopBoot.get().error).toBeTruthy()
+    expect(desktop.getConnection).toHaveBeenCalledTimes(1)
+
+    // First retry (~5s + jitter) also fails.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(7_000)
+    })
+    expect(desktop.getConnection).toHaveBeenCalledTimes(2)
+    expect($desktopBoot.get().error).toBeTruthy()
+
+    // Second retry (~15s + jitter) succeeds → boot completes, error clears.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(20_000)
+    })
+    expect(desktop.getConnection.mock.calls.length).toBeGreaterThanOrEqual(3)
+    expect($gatewayState.get()).toBe('open')
+    expect($desktopBoot.get().error).toBeNull()
+  })
+
+  it('latches a genuine auth failure: no automatic retry, sign-in stays required', async () => {
+    const desktop = fakeDesktop()
+    desktop.getConnection = vi.fn(async () => {
+      throw new Error('Your remote gateway session has expired. Open Settings → Gateway and click "Sign in" again.')
+    })
+    ;(window as { hermesDesktop?: unknown }).hermesDesktop = desktop
+
+    render(<Harness />)
+    await flushAsync()
+
+    expect($desktopBoot.get().error).toBeTruthy()
+    expect(desktop.getConnection).toHaveBeenCalledTimes(1)
+
+    // Minutes pass: a transport failure would have retried many times by now.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5 * 60_000)
+    })
+    expect(desktop.getConnection).toHaveBeenCalledTimes(1)
+
+    // Wake/online nudges must not thrash the latched auth failure either.
+    await act(async () => {
+      window.dispatchEvent(new Event('online'))
+      await vi.advanceTimersByTimeAsync(0)
+    })
+    expect(desktop.getConnection).toHaveBeenCalledTimes(1)
+  })
+
+  it('a wake/online nudge retries a transport-failed boot immediately', async () => {
+    const desktop = fakeDesktop()
+    const realGetConnection = desktop.getConnection
+    let failures = 1
+    desktop.getConnection = vi.fn(async () => {
+      if (failures > 0) {
+        failures -= 1
+        throw new Error('Timed out connecting to Hermes backend after 15000ms')
+      }
+
+      return realGetConnection()
+    })
+    ;(window as { hermesDesktop?: unknown }).hermesDesktop = desktop
+
+    render(<Harness />)
+    await flushAsync()
+    expect($desktopBoot.get().error).toBeTruthy()
+
+    // Network comes back well before the 5s backoff timer would fire.
+    await act(async () => {
+      window.dispatchEvent(new Event('online'))
+      await vi.advanceTimersByTimeAsync(0)
+    })
+    await flushAsync()
+
+    expect($gatewayState.get()).toBe('open')
+    expect($desktopBoot.get().error).toBeNull()
+  })
 })
diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
index 26a4e2ce7c8e4..e8d73afa8926f 100644
--- a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
@@ -1,4 +1,4 @@
-import { isGatewayReauthRequired, resolveGatewayWsUrl } from '@hermes/shared'
+import { isGatewayAuthShapedError, isGatewayReauthRequired, resolveGatewayWsUrl } from '@hermes/shared'
 import { useEffect, useRef } from 'react'
 
 import type { HermesConnection } from '@/global'
@@ -47,12 +47,29 @@ import type { RpcEvent } from '@/types/hermes'
 // dead end. The next successful reconnect clears it.
 const RECONNECT_ESCALATE_AFTER = 6
 
+// Backoff for re-attempting a FAILED initial boot (backend dead at launch —
+// e.g. the Tailscale tunnel isn't up yet when the app starts). Without this the
+// failure overlay sat there forever waiting for a manual Retry click even
+// though the backend came back seconds later. Capped at the last entry; ±20%
+// jitter so a fleet of windows doesn't stampede the backend in lockstep.
+const BOOT_RETRY_DELAYS_MS = [5_000, 15_000, 30_000, 60_000]
+
+const bootRetryDelay = (attempt: number): number => {
+  const base = BOOT_RETRY_DELAYS_MS[Math.min(attempt, BOOT_RETRY_DELAYS_MS.length - 1)]
+
+  return Math.round(base * (0.8 + Math.random() * 0.4))
+}
+
 interface GatewayBootOptions {
   handleGatewayEvent: (event: RpcEvent) => void
   onConnectionReady: (
     connection: Awaited<ReturnType<NonNullable<typeof window.hermesDesktop>['getConnection']>> | null
   ) => void
   onGatewayReady: (gateway: HermesGateway | null) => void
+  /** Clear stale per-session busy state after a socket reconnect (the turns
+   *  whose message.complete died with the dropped socket). Optional so
+   *  lightweight harnesses (tests, pop-outs) can omit it. */
+  reconcileBusySessions?: (gateway: HermesGateway, profile: string) => Promise<void>
   refreshHermesConfig: () => Promise<void>
   refreshSessions: () => Promise<void>
 }
@@ -61,6 +78,7 @@ export function useGatewayBoot({
   handleGatewayEvent,
   onConnectionReady,
   onGatewayReady,
+  reconcileBusySessions,
   refreshHermesConfig,
   refreshSessions
 }: GatewayBootOptions) {
@@ -68,6 +86,7 @@ export function useGatewayBoot({
     handleGatewayEvent,
     onConnectionReady,
     onGatewayReady,
+    reconcileBusySessions,
     refreshHermesConfig,
     refreshSessions
   })
@@ -76,6 +95,7 @@ export function useGatewayBoot({
     handleGatewayEvent,
     onConnectionReady,
     onGatewayReady,
+    reconcileBusySessions,
     refreshHermesConfig,
     refreshSessions
   }
@@ -105,6 +125,18 @@ export function useGatewayBoot({
     // signals that fire around wake (power resume, network online, the window
     // becoming visible).
     let bootCompleted = false
+    // Failed-boot recovery (dead backend at launch): while the boot overlay
+    // shows a failure we keep re-attempting boot() on a bounded backoff — and
+    // on the wake/online/visibility nudges — instead of waiting for a manual
+    // Retry click. A genuine auth failure latches instead: no retry can
+    // succeed until the user signs in, and auto-resetting just thrashed the
+    // failure loop (the "session has expired" reset churn in the logs).
+    let bootFailed = false
+    let bootAuthLatched = false
+    let bootInProgress = false
+    let bootFailureNotified = false
+    let bootRetryTimer: ReturnType<typeof setTimeout> | null = null
+    let bootRetryAttempt = 0
     let reconnecting = false
     let reconnectTimer: ReturnType<typeof setTimeout> | null = null
     let reconnectAttempt = 0
@@ -129,6 +161,26 @@ export function useGatewayBoot({
       }
     }
 
+    const clearBootRetryTimer = () => {
+      if (bootRetryTimer !== null) {
+        clearTimeout(bootRetryTimer)
+        bootRetryTimer = null
+      }
+    }
+
+    function scheduleBootRetry() {
+      if (cancelled || bootRetryTimer !== null || bootAuthLatched) {
+        return
+      }
+
+      const delay = bootRetryDelay(bootRetryAttempt)
+      bootRetryAttempt += 1
+      bootRetryTimer = setTimeout(() => {
+        bootRetryTimer = null
+        void boot()
+      }, delay)
+    }
+
     const attemptReconnect = async () => {
       if (cancelled || reconnecting || gatewayOpen()) {
         return
@@ -169,6 +221,12 @@ export function useGatewayBoot({
         // Resync state that may have moved on the backend while we were asleep.
         await callbacksRef.current.refreshHermesConfig().catch(() => undefined)
         await callbacksRef.current.refreshSessions().catch(() => undefined)
+        // The drop may have swallowed message.complete events for in-flight
+        // turns, leaving sessions latched busy ("Thinking…") forever. Ask the
+        // rebuilt gateway what is genuinely still running and clear the rest.
+        await callbacksRef.current
+          .reconcileBusySessions?.(gateway, normalizeProfileKey($activeGatewayProfile.get()))
+          .catch(() => undefined)
       } catch (err) {
         // OAuth session expired mid-reconnect: surface the actionable "sign in
         // again" message once instead of silently looping the backoff against a
@@ -207,7 +265,22 @@ export function useGatewayBoot({
     }
 
     const reconnectNow = () => {
-      if (cancelled || !bootCompleted) {
+      if (cancelled) {
+        return
+      }
+
+      if (!bootCompleted) {
+        // Boot never succeeded. If it FAILED on a transport error, a wake /
+        // network-online / focus signal is exactly when a retry is likely to
+        // succeed — re-drive boot() immediately (it no-ops while one is in
+        // flight). An auth-latched failure stays latched: only the sign-in
+        // flow can fix it. A boot still in progress is left alone.
+        if (bootFailed && !bootAuthLatched) {
+          clearBootRetryTimer()
+          bootRetryAttempt = 0
+          void boot()
+        }
+
         return
       }
 
@@ -237,7 +310,13 @@ export function useGatewayBoot({
     callbacksRef.current.onGatewayReady(gateway)
     setPrimaryGateway(gateway, normalizeProfileKey($activeGatewayProfile.get()))
     // Secondary (background-profile) sockets funnel into the same handler.
-    configureGatewayRegistry({ onEvent: event => callbacksRef.current.handleGatewayEvent(event) })
+    // Their reconnects run the same stale-busy reconciliation as the primary,
+    // scoped to the reconnected profile's sessions.
+    configureGatewayRegistry({
+      onEvent: event => callbacksRef.current.handleGatewayEvent(event),
+      onReconnected: (profile, secondary) =>
+        void callbacksRef.current.reconcileBusySessions?.(secondary, profile).catch(() => undefined)
+    })
 
     const offState = gateway.onState(st => {
       // Mirror to the composer only while the primary is the active profile —
@@ -332,6 +411,12 @@ export function useGatewayBoot({
     })
 
     async function boot() {
+      if (cancelled || bootInProgress || bootCompleted) {
+        return
+      }
+
+      bootInProgress = true
+
       try {
         const conn = await desktop.getConnection()
 
@@ -397,13 +482,34 @@ export function useGatewayBoot({
         await callbacksRef.current.refreshSessions()
         completeDesktopBoot()
         bootCompleted = true
+        bootFailed = false
+        bootAuthLatched = false
+        bootFailureNotified = false
+        bootRetryAttempt = 0
+        clearBootRetryTimer()
       } catch (err) {
         if (!cancelled) {
+          bootFailed = true
+          bootAuthLatched = isGatewayAuthShapedError(err)
           const message = err instanceof Error ? err.message : String(err)
           failDesktopBoot(message)
-          notifyError(err, translateNow('boot.errors.desktopBootFailed'))
+
+          // Toast once per failure episode, not on every backoff retry —
+          // identical error toasts (and their haptics) would otherwise stack
+          // every few seconds while the backend is down.
+          if (!bootFailureNotified) {
+            bootFailureNotified = true
+            notifyError(err, translateNow('boot.errors.desktopBootFailed'))
+          }
+
           setSessionsLoading(false)
+
+          if (!bootAuthLatched) {
+            scheduleBootRetry()
+          }
         }
+      } finally {
+        bootInProgress = false
       }
     }
 
@@ -412,6 +518,7 @@ export function useGatewayBoot({
     return () => {
       cancelled = true
       clearReconnectTimer()
+      clearBootRetryTimer()
       clearInterval(keepaliveTimer)
       offWorking()
       offAttention()
diff --git a/apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.test.tsx b/apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.test.tsx
new file mode 100644
index 0000000000000..14af29dafc800
--- /dev/null
+++ b/apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.test.tsx
@@ -0,0 +1,164 @@
+import { cleanup, render, waitFor } from '@testing-library/react'
+import { useRef } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ClientSessionState } from '@/app/types'
+import type { HermesGateway } from '@/hermes'
+import { createClientSessionState } from '@/lib/chat-runtime'
+import { $sessions } from '@/store/session'
+import type { SessionInfo } from '@/types/hermes'
+
+import { useReconnectReconciliation } from './use-reconnect-reconciliation'
+
+// The B3 fix: after a socket drop + reconnect, per-session busy latches whose
+// message.complete died with the old socket must be cleared from the fresh
+// gateway's live-session snapshot — while genuinely running turns stay busy.
+
+type Reconcile = (gateway: HermesGateway, profile: string) => Promise<void>
+
+const sessionRow = (id: string, profile?: string): SessionInfo => ({ id, profile }) as unknown as SessionInfo
+
+const busyState = (storedSessionId: string | null): ClientSessionState => ({
+  ...createClientSessionState(storedSessionId),
+  busy: true,
+  awaitingResponse: true,
+  streamId: 'assistant-stream-1',
+  turnStartedAt: Date.now()
+})
+
+function makeHarness(initial: Record<string, ClientSessionState>) {
+  const cache = new Map<string, ClientSessionState>(Object.entries(initial))
+  let reconcile: Reconcile = async () => undefined
+
+  function Harness() {
+    const sessionStateByRuntimeIdRef = useRef(cache)
+
+    reconcile = useReconnectReconciliation({
+      sessionStateByRuntimeIdRef,
+      updateSessionState: (sessionId, updater) => {
+        const current = cache.get(sessionId) ?? createClientSessionState()
+        const next = updater(current)
+        cache.set(sessionId, next)
+
+        return next
+      }
+    })
+
+    return null
+  }
+
+  render(<Harness />)
+
+  return { cache, reconcile: (gateway: HermesGateway, profile: string) => reconcile(gateway, profile) }
+}
+
+const gatewayWith = (rows: unknown[] | Error): HermesGateway =>
+  ({
+    request: vi.fn(async (method: string) => {
+      expect(method).toBe('session.active_list')
+
+      if (rows instanceof Error) {
+        throw rows
+      }
+
+      return { sessions: rows }
+    })
+  }) as unknown as HermesGateway
+
+describe('useReconnectReconciliation', () => {
+  beforeEach(() => {
+    $sessions.set([])
+  })
+
+  afterEach(() => {
+    cleanup()
+    $sessions.set([])
+  })
+
+  it('clears busy state for a session the gateway no longer knows (turn died with the socket)', async () => {
+    const { cache, reconcile } = makeHarness({ 'rt-1': busyState('stored-1') })
+
+    await reconcile(gatewayWith([]), 'default')
+
+    await waitFor(() => {
+      const state = cache.get('rt-1')!
+      expect(state.busy).toBe(false)
+      expect(state.awaitingResponse).toBe(false)
+      expect(state.streamId).toBeNull()
+      expect(state.turnStartedAt).toBeNull()
+    })
+  })
+
+  it('clears busy state when the live session reports idle', async () => {
+    const { cache, reconcile } = makeHarness({ 'rt-1': busyState('stored-1') })
+
+    await reconcile(gatewayWith([{ id: 'rt-1', session_key: 'stored-1', status: 'idle' }]), 'default')
+
+    expect(cache.get('rt-1')!.busy).toBe(false)
+  })
+
+  it('keeps a genuinely running turn busy (running:true stays busy)', async () => {
+    const { cache, reconcile } = makeHarness({ 'rt-1': busyState('stored-1') })
+
+    await reconcile(gatewayWith([{ id: 'rt-1', session_key: 'stored-1', status: 'working' }]), 'default')
+
+    expect(cache.get('rt-1')!.busy).toBe(true)
+    expect(cache.get('rt-1')!.awaitingResponse).toBe(true)
+  })
+
+  it('keeps a turn blocked on a user prompt (waiting) busy with its needsInput intact', async () => {
+    const { cache, reconcile } = makeHarness({
+      'rt-1': { ...busyState('stored-1'), needsInput: true }
+    })
+
+    await reconcile(gatewayWith([{ id: 'rt-1', status: 'waiting' }]), 'default')
+
+    expect(cache.get('rt-1')!.busy).toBe(true)
+    expect(cache.get('rt-1')!.needsInput).toBe(true)
+  })
+
+  it('matches live rows by stored session key when the runtime id rotated', async () => {
+    const { cache, reconcile } = makeHarness({ 'rt-old': busyState('stored-1') })
+
+    await reconcile(gatewayWith([{ id: 'rt-new', session_key: 'stored-1', status: 'working' }]), 'default')
+
+    expect(cache.get('rt-old')!.busy).toBe(true)
+  })
+
+  it("leaves another profile's sessions to that profile's own reconnect", async () => {
+    $sessions.set([sessionRow('stored-james', 'pm-james')])
+    const { cache, reconcile } = makeHarness({ 'rt-james': busyState('stored-james') })
+
+    await reconcile(gatewayWith([]), 'default')
+
+    expect(cache.get('rt-james')!.busy).toBe(true)
+  })
+
+  it('reconciles a session whose profile matches the reconnected gateway', async () => {
+    $sessions.set([sessionRow('stored-james', 'pm-james')])
+    const { cache, reconcile } = makeHarness({ 'rt-james': busyState('stored-james') })
+
+    await reconcile(gatewayWith([]), 'pm-james')
+
+    expect(cache.get('rt-james')!.busy).toBe(false)
+  })
+
+  it('keeps every latch when the live-session probe fails (half-open socket)', async () => {
+    const { cache, reconcile } = makeHarness({ 'rt-1': busyState('stored-1') })
+
+    await reconcile(gatewayWith(new Error('request timed out: session.active_list')), 'default')
+
+    expect(cache.get('rt-1')!.busy).toBe(true)
+  })
+
+  it('does not touch idle sessions and skips the probe entirely when nothing is busy', async () => {
+    const idle = createClientSessionState('stored-1')
+    const { cache, reconcile } = makeHarness({ 'rt-1': idle })
+    const gateway = gatewayWith([])
+
+    await reconcile(gateway, 'default')
+
+    expect(cache.get('rt-1')).toBe(idle)
+    expect((gateway as unknown as { request: ReturnType<typeof vi.fn> }).request).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.ts b/apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.ts
new file mode 100644
index 0000000000000..079726d72eea2
--- /dev/null
+++ b/apps/desktop/src/app/gateway/hooks/use-reconnect-reconciliation.ts
@@ -0,0 +1,127 @@
+import { type MutableRefObject, useCallback } from 'react'
+
+import type { HermesGateway } from '@/hermes'
+import { normalizeProfileKey } from '@/store/profile'
+import { $sessions } from '@/store/session'
+
+import type { ClientSessionState } from '../../types'
+
+// A dropped socket swallows the terminal events (message.complete / error) of
+// any in-flight turn, leaving its ClientSessionState latched busy — the
+// "composer stuck on Thinking… until manual Stop" bug. After a successful
+// reconnect we ask the gateway which runtime sessions are GENUINELY still
+// occupied (session.active_list reports live status per in-memory session) and
+// clear the stale busy/awaitingResponse latches for everything else. Turns the
+// backend kept running through the drop stay busy — their next events stream
+// in over the fresh socket.
+
+// Live statuses that keep the client-side busy latch: the turn is still
+// running ('working'), the agent is still building ('starting'), or the turn
+// is blocked on a user prompt ('waiting'). Anything else — including a session
+// the gateway no longer knows (grace-reaped or backend restarted) — means the
+// turn's completion can never arrive, so busy must be cleared.
+const LIVE_BUSY_STATUSES = new Set(['starting', 'waiting', 'working'])
+
+interface LiveSessionRow {
+  id?: string
+  session_key?: string
+  status?: string
+}
+
+interface ReconnectReconciliationOptions {
+  sessionStateByRuntimeIdRef: MutableRefObject<Map<string, ClientSessionState>>
+  updateSessionState: (
+    sessionId: string,
+    updater: (state: ClientSessionState) => ClientSessionState,
+    storedSessionId?: string | null
+  ) => ClientSessionState
+}
+
+/** Profile that owns a cached session, resolved through the sidebar list (the
+ *  runtime cache doesn't record it). Null when the row isn't loaded — treated
+ *  as belonging to the reconciling gateway, since sessions started in this
+ *  window always ride the profile socket that created them. */
+function cachedSessionProfile(storedSessionId: string | null): null | string {
+  if (!storedSessionId) {
+    return null
+  }
+
+  const row = $sessions.get().find(s => s.id === storedSessionId || s._lineage_root_id === storedSessionId)
+
+  return row ? normalizeProfileKey(row.profile) : null
+}
+
+export function useReconnectReconciliation({
+  sessionStateByRuntimeIdRef,
+  updateSessionState
+}: ReconnectReconciliationOptions) {
+  return useCallback(
+    async (gateway: HermesGateway, profile: string) => {
+      const profileKey = normalizeProfileKey(profile)
+
+      const stuck = [...sessionStateByRuntimeIdRef.current.entries()].filter(
+        ([, state]) => state.busy || state.awaitingResponse
+      )
+
+      if (stuck.length === 0) {
+        return
+      }
+
+      // If the probe itself fails we keep every latch: better a lingering
+      // spinner (the next reconnect retries) than clearing a genuinely
+      // running turn on a half-open socket.
+      let rows: LiveSessionRow[]
+
+      try {
+        const result = await gateway.request<{ sessions?: LiveSessionRow[] }>('session.active_list', {})
+        rows = Array.isArray(result?.sessions) ? result.sessions : []
+      } catch {
+        return
+      }
+
+      const statusByRuntimeId = new Map<string, string>()
+      const statusByStoredKey = new Map<string, string>()
+
+      for (const row of rows) {
+        const status = typeof row.status === 'string' ? row.status : ''
+
+        if (row.id) {
+          statusByRuntimeId.set(row.id, status)
+        }
+
+        if (row.session_key) {
+          statusByStoredKey.set(row.session_key, status)
+        }
+      }
+
+      for (const [runtimeId, state] of stuck) {
+        // Sessions owned by another profile's socket are that socket's problem
+        // — its own reconnect runs this reconciliation with its profile key.
+        const owner = cachedSessionProfile(state.storedSessionId)
+
+        if (owner !== null && owner !== profileKey) {
+          continue
+        }
+
+        const status =
+          statusByRuntimeId.get(runtimeId) ??
+          (state.storedSessionId ? statusByStoredKey.get(state.storedSessionId) : undefined)
+
+        if (status && LIVE_BUSY_STATUSES.has(status)) {
+          continue
+        }
+
+        updateSessionState(runtimeId, current => ({
+          ...current,
+          awaitingResponse: false,
+          busy: false,
+          needsInput: false,
+          pendingBranchGroup: null,
+          streamId: null,
+          turnStartedAt: null
+        }))
+      }
+    },
+    [sessionStateByRuntimeIdRef, updateSessionState]
+  )
+}
diff --git a/apps/desktop/src/app/session/hooks/refresh-coalescer.test.ts b/apps/desktop/src/app/session/hooks/refresh-coalescer.test.ts
new file mode 100644
index 0000000000000..45668afe7aa19
--- /dev/null
+++ b/apps/desktop/src/app/session/hooks/refresh-coalescer.test.ts
@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { createTrailingCoalescer } from './refresh-coalescer'
+
+describe('createTrailingCoalescer', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('collapses a burst of schedule() calls into one trailing run', async () => {
+    const run = vi.fn(async () => undefined)
+    const coalescer = createTrailingCoalescer(run, 1_500)
+
+    coalescer.schedule()
+    coalescer.schedule()
+    coalescer.schedule()
+
+    expect(run).not.toHaveBeenCalled()
+
+    await vi.advanceTimersByTimeAsync(1_500)
+
+    expect(run).toHaveBeenCalledTimes(1)
+  })
+
+  it('runs again after the window for schedules in a later burst', async () => {
+    const run = vi.fn(async () => undefined)
+    const coalescer = createTrailingCoalescer(run, 1_500)
+
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(1_500)
+    expect(run).toHaveBeenCalledTimes(1)
+
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(1_500)
+    expect(run).toHaveBeenCalledTimes(2)
+  })
+
+  it('queues at most one follow-up while a run is in flight (single-flight)', async () => {
+    let release: () => void = () => undefined
+
+    const run = vi.fn(
+      () =>
+        new Promise<void>(resolve => {
+          release = resolve
+        })
+    )
+
+    const coalescer = createTrailingCoalescer(run, 100)
+
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(100)
+    expect(run).toHaveBeenCalledTimes(1)
+
+    // Three more bursts land while the first run is still awaiting its fetch.
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(100)
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(100)
+
+    expect(run).toHaveBeenCalledTimes(1)
+
+    release()
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Exactly one chained follow-up, not one per burst.
+    expect(run).toHaveBeenCalledTimes(2)
+  })
+
+  it('swallows run() rejections and keeps working', async () => {
+    const run = vi.fn().mockRejectedValueOnce(new Error('boom')).mockResolvedValue(undefined)
+    const coalescer = createTrailingCoalescer(run, 100)
+
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(100)
+    expect(run).toHaveBeenCalledTimes(1)
+
+    coalescer.schedule()
+    await vi.advanceTimersByTimeAsync(100)
+    expect(run).toHaveBeenCalledTimes(2)
+  })
+
+  it('cancel() drops the pending timer and queued follow-up', async () => {
+    const run = vi.fn(async () => undefined)
+    const coalescer = createTrailingCoalescer(run, 100)
+
+    coalescer.schedule()
+    coalescer.cancel()
+    await vi.advanceTimersByTimeAsync(1_000)
+
+    expect(run).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/app/session/hooks/refresh-coalescer.ts b/apps/desktop/src/app/session/hooks/refresh-coalescer.ts
new file mode 100644
index 0000000000000..7e0a68c924058
--- /dev/null
+++ b/apps/desktop/src/app/session/hooks/refresh-coalescer.ts
@@ -0,0 +1,68 @@
+// Trailing coalescer for gateway-event-driven refreshes. At swarm scale every
+// session heartbeat / turn completion wants to re-fetch some REST surface;
+// firing them 1:1 turns N busy sessions into an O(N) request storm against the
+// (possibly remote, Tailscale'd) backend. schedule() arms a single trailing
+// timer — repeat calls inside the window coalesce into one run — and the run
+// itself is single-flight: calls arriving while a run is in flight queue at
+// most ONE follow-up run after it settles, so results can't interleave.
+
+export interface TrailingCoalescer {
+  /** Ask for a run. Coalesces with any already-pending request. */
+  schedule: () => void
+  /** Drop the pending timer + queued follow-up (unmount cleanup). */
+  cancel: () => void
+}
+
+export function createTrailingCoalescer(run: () => Promise<unknown> | unknown, delayMs: number): TrailingCoalescer {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let inFlight = false
+  let rerunQueued = false
+  let cancelled = false
+
+  const execute = (): void => {
+    if (cancelled) {
+      return
+    }
+
+    if (inFlight) {
+      rerunQueued = true
+
+      return
+    }
+
+    inFlight = true
+    void Promise.resolve()
+      .then(run)
+      .catch(() => undefined)
+      .then(() => {
+        inFlight = false
+
+        if (rerunQueued && !cancelled) {
+          rerunQueued = false
+          execute()
+        }
+      })
+  }
+
+  return {
+    schedule() {
+      if (cancelled || timer !== null) {
+        return
+      }
+
+      timer = setTimeout(() => {
+        timer = null
+        execute()
+      }, delayMs)
+    },
+    cancel() {
+      cancelled = true
+      rerunQueued = false
+
+      if (timer !== null) {
+        clearTimeout(timer)
+        timer = null
+      }
+    }
+  }
+}
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/config-refresh.test.tsx b/apps/desktop/src/app/session/hooks/use-message-stream/config-refresh.test.tsx
new file mode 100644
index 0000000000000..e6cb62b281f4c
--- /dev/null
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/config-refresh.test.tsx
@@ -0,0 +1,114 @@
+import { QueryClient } from '@tanstack/react-query'
+import { act, cleanup, render } from '@testing-library/react'
+import { useEffect, useRef } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ClientSessionState } from '@/app/types'
+import { createClientSessionState } from '@/lib/chat-runtime'
+import type { RpcEvent } from '@/types/hermes'
+
+import { useMessageStream } from './index'
+
+// B4(a): session.info used to trigger an immediate, unconditional
+// refreshHermesConfig() (= /api/config + /api/config/defaults) per event.
+// The handler must now debounce the refetch and skip events that can't have
+// changed config-derived state (background session, no personality/cwd field).
+
+const ACTIVE_SID = 'session-active'
+
+let handleEvent: ((event: RpcEvent) => void) | null = null
+let refreshHermesConfig: ReturnType<typeof vi.fn>
+
+function Harness() {
+  const activeSessionIdRef = useRef<string | null>(ACTIVE_SID)
+  const sessionStateByRuntimeIdRef = useRef(new Map<string, ClientSessionState>())
+  const queryClientRef = useRef(new QueryClient())
+
+  const stream = useMessageStream({
+    activeSessionIdRef,
+    hydrateFromStoredSession: vi.fn(async () => undefined),
+    queryClient: queryClientRef.current,
+    refreshHermesConfig: refreshHermesConfig as unknown as () => Promise<void>,
+    scheduleSessionsRefresh: vi.fn(),
+    sessionStateByRuntimeIdRef,
+    updateSessionState: (sessionId, updater) => {
+      const current = sessionStateByRuntimeIdRef.current.get(sessionId) ?? createClientSessionState()
+      const next = updater(current)
+      sessionStateByRuntimeIdRef.current.set(sessionId, next)
+
+      return next
+    }
+  })
+
+  useEffect(() => {
+    handleEvent = stream.handleGatewayEvent
+  }, [stream.handleGatewayEvent])
+
+  return null
+}
+
+const sessionInfo = (sessionId: string, payload: Record<string, unknown> = {}) =>
+  act(() => handleEvent!({ payload, session_id: sessionId, type: 'session.info' }))
+
+describe('session.info config-refresh damping', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    handleEvent = null
+    refreshHermesConfig = vi.fn(async () => undefined)
+    render(<Harness />)
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+  })
+
+  it('debounces a burst of active-session heartbeats into one trailing refetch', async () => {
+    sessionInfo(ACTIVE_SID, { running: true })
+    sessionInfo(ACTIVE_SID, { running: true })
+    sessionInfo(ACTIVE_SID, { running: false })
+
+    expect(refreshHermesConfig).not.toHaveBeenCalled()
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000)
+    })
+
+    expect(refreshHermesConfig).toHaveBeenCalledTimes(1)
+  })
+
+  it('skips background-session events that carry no config-backed fields', async () => {
+    sessionInfo('session-background', { running: false })
+    sessionInfo('session-background', { usage: { total: 1 } })
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(30_000)
+    })
+
+    expect(refreshHermesConfig).not.toHaveBeenCalled()
+  })
+
+  it('still refetches when a background event carries a config-backed field (personality)', async () => {
+    sessionInfo('session-background', { personality: 'hacker' })
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000)
+    })
+
+    expect(refreshHermesConfig).toHaveBeenCalledTimes(1)
+  })
+
+  it('refetches again for events after the debounce window', async () => {
+    sessionInfo(ACTIVE_SID, { running: true })
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000)
+    })
+    expect(refreshHermesConfig).toHaveBeenCalledTimes(1)
+
+    sessionInfo(ACTIVE_SID, { running: false })
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000)
+    })
+    expect(refreshHermesConfig).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
index f36d74ad73e01..994dbc191a85a 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
@@ -1,5 +1,5 @@
 import type { QueryClient } from '@tanstack/react-query'
-import { type MutableRefObject, useCallback } from 'react'
+import { type MutableRefObject, useCallback, useEffect, useRef } from 'react'
 
 import { writeAgentTerminalChunk } from '@/app/right-sidebar/terminal/agent-terminal-stream'
 import { readActiveTerminal } from '@/app/right-sidebar/terminal/buffer'
@@ -46,6 +46,16 @@ import type { ClientSessionState } from '../../../types'
 
 import { hasSessionInfoStatePatch, sessionInfoStatePatch, SUBAGENT_EVENT_TYPES, toTodoPayload } from './utils'
 
+// Trailing-debounce window for session.info-driven config refetches. Every
+// session.info used to fire an immediate /api/config + /api/config/defaults
+// pair; with many concurrent sessions (each emitting session.info at turn
+// boundaries and settings changes, across every profile socket) that's a
+// steady 2-requests-per-event drip against the shared backend. One trailing
+// refetch per window keeps config-derived state fresh enough — the fields the
+// composer needs immediately (model/provider/personality/cwd) are applied
+// straight from the event payload above, not from the refetch.
+const CONFIG_REFRESH_DEBOUNCE_MS = 5_000
+
 interface GatewayEventDeps {
   activeSessionIdRef: MutableRefObject<string | null>
   compactedTurnRef: MutableRefObject<Set<string>>
@@ -91,6 +101,31 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
     upsertToolCall
   } = deps
 
+  const configRefreshTimerRef = useRef<null | ReturnType<typeof setTimeout>>(null)
+  const refreshHermesConfigRef = useRef(refreshHermesConfig)
+  refreshHermesConfigRef.current = refreshHermesConfig
+
+  const scheduleConfigRefresh = useCallback(() => {
+    if (configRefreshTimerRef.current !== null) {
+      return
+    }
+
+    configRefreshTimerRef.current = setTimeout(() => {
+      configRefreshTimerRef.current = null
+      void refreshHermesConfigRef.current()
+    }, CONFIG_REFRESH_DEBOUNCE_MS)
+  }, [])
+
+  useEffect(
+    () => () => {
+      if (configRefreshTimerRef.current !== null) {
+        clearTimeout(configRefreshTimerRef.current)
+        configRefreshTimerRef.current = null
+      }
+    },
+    []
+  )
+
   return useCallback(
     (event: RpcEvent) => {
       const payload = event.payload as GatewayEventPayload | undefined
@@ -216,7 +251,13 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
           requestDesktopOnboarding(payload.credential_warning)
         }
 
-        void refreshHermesConfig()
+        // Refetch config only when this event can actually change
+        // config-derived state: it carries a config-backed field
+        // (personality / cwd) or it targets the session on screen. A
+        // background profile's turn-boundary heartbeat changes neither.
+        if (isActiveEvent || typeof payload?.personality === 'string' || typeof payload?.cwd === 'string') {
+          scheduleConfigRefresh()
+        }
 
         if (modelChanged || providerChanged) {
           void queryClient.invalidateQueries({
@@ -646,7 +687,7 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
       lastCwdInfoSessionRef,
       nativeSubagentSessionsRef,
       queryClient,
-      refreshHermesConfig,
+      scheduleConfigRefresh,
       sessionInterrupted,
       updateSessionState,
       upsertToolCall
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/index.ts b/apps/desktop/src/app/session/hooks/use-message-stream/index.ts
index 65a203a215ebc..3d2a3a322c3e9 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/index.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/index.ts
@@ -39,7 +39,10 @@ interface MessageStreamOptions {
   ) => Promise<void>
   queryClient: QueryClient
   refreshHermesConfig: () => Promise<void>
-  refreshSessions: () => Promise<void>
+  /** Coalesced sidebar refresh — every message.complete asks for one, so the
+   *  callback must debounce/single-flight internally (scheduleSessionsRefresh),
+   *  not fire a full 4-fetch fan-out per completed turn. */
+  scheduleSessionsRefresh: () => void
   sessionStateByRuntimeIdRef: MutableRefObject<Map<string, ClientSessionState>>
   updateSessionState: (
     sessionId: string,
@@ -58,7 +61,7 @@ export function useMessageStream({
   hydrateFromStoredSession,
   queryClient,
   refreshHermesConfig,
-  refreshSessions,
+  scheduleSessionsRefresh,
   sessionStateByRuntimeIdRef,
   updateSessionState
 }: MessageStreamOptions) {
@@ -444,7 +447,7 @@ export function useMessageStream({
         }
       })
 
-      void refreshSessions().catch(() => undefined)
+      scheduleSessionsRefresh()
       // Sync the freshly-titled row to other windows (e.g. main, when the turn
       // ran in the pop-out).
       broadcastSessionsChanged()
@@ -464,7 +467,7 @@ export function useMessageStream({
         title: translateNow('notifications.native.turnDoneTitle')
       })
     },
-    [hydrateFromStoredSession, refreshSessions, updateSessionState]
+    [hydrateFromStoredSession, scheduleSessionsRefresh, updateSessionState]
   )
 
   const failAssistantMessage = useCallback(
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/todo-cleanup.test.tsx b/apps/desktop/src/app/session/hooks/use-message-stream/todo-cleanup.test.tsx
index 6b676976e5d15..00ec9bf71c75e 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/todo-cleanup.test.tsx
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/todo-cleanup.test.tsx
@@ -26,7 +26,7 @@ function Harness() {
     hydrateFromStoredSession: vi.fn(async () => undefined),
     queryClient: queryClientRef.current,
     refreshHermesConfig: vi.fn(async () => undefined),
-    refreshSessions: vi.fn(async () => undefined),
+    scheduleSessionsRefresh: vi.fn(),
     sessionStateByRuntimeIdRef,
     updateSessionState: (sessionId, updater) => {
       const current = sessionStateByRuntimeIdRef.current.get(sessionId) ?? createClientSessionState()
diff --git a/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx b/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx
new file mode 100644
index 0000000000000..d56df193ab665
--- /dev/null
+++ b/apps/desktop/src/app/session/hooks/use-session-list-actions.test.tsx
@@ -0,0 +1,99 @@
+import { act, cleanup, render } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useSessionListActions } from './use-session-list-actions'
+
+// B4(b): every message.complete used to fire a full 4-request sidebar refresh
+// (recents + cron sessions + cron jobs + messaging). scheduleSessionsRefresh
+// must coalesce bursts into one trailing refresh, and the ancillary fan-out
+// must be bounded to its own longer interval.
+
+vi.mock('@/hermes', async importOriginal => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  getCronJobs: vi.fn(async () => []),
+  listAllProfileSessions: vi.fn(async () => ({ sessions: [], total: 0, profile_totals: {} }))
+}))
+
+const { getCronJobs, listAllProfileSessions } = await import('@/hermes')
+
+type Actions = ReturnType<typeof useSessionListActions>
+
+let actions: Actions | null = null
+
+function Harness() {
+  actions = useSessionListActions({ profileScope: 'default' })
+
+  return null
+}
+
+describe('useSessionListActions refresh coalescing', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.mocked(listAllProfileSessions).mockClear()
+    vi.mocked(getCronJobs).mockClear()
+    actions = null
+    render(<Harness />)
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+  })
+
+  it('collapses a burst of scheduleSessionsRefresh calls into one trailing refresh', async () => {
+    await act(async () => {
+      actions!.scheduleSessionsRefresh()
+      actions!.scheduleSessionsRefresh()
+      actions!.scheduleSessionsRefresh()
+      await vi.advanceTimersByTimeAsync(0)
+    })
+
+    expect(listAllProfileSessions).not.toHaveBeenCalled()
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1_500)
+    })
+
+    // One recents fetch + the first ancillary fan-out (cron sessions +
+    // messaging slice), NOT one fetch per scheduled call.
+    expect(vi.mocked(listAllProfileSessions).mock.calls).toHaveLength(3)
+    expect(getCronJobs).toHaveBeenCalledTimes(1)
+  })
+
+  it('skips the ancillary fan-out for refreshes inside the throttle window', async () => {
+    await act(async () => {
+      actions!.scheduleSessionsRefresh()
+      await vi.advanceTimersByTimeAsync(1_500)
+    })
+
+    expect(getCronJobs).toHaveBeenCalledTimes(1)
+    const callsAfterFirst = vi.mocked(listAllProfileSessions).mock.calls.length
+
+    // A second completed turn 5s later: recents refresh only.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000)
+      actions!.scheduleSessionsRefresh()
+      await vi.advanceTimersByTimeAsync(1_500)
+    })
+
+    expect(vi.mocked(listAllProfileSessions).mock.calls).toHaveLength(callsAfterFirst + 1)
+    expect(getCronJobs).toHaveBeenCalledTimes(1)
+  })
+
+  it('re-runs the ancillary fan-out once the throttle interval has elapsed', async () => {
+    await act(async () => {
+      actions!.scheduleSessionsRefresh()
+      await vi.advanceTimersByTimeAsync(1_500)
+    })
+
+    expect(getCronJobs).toHaveBeenCalledTimes(1)
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(31_000)
+      actions!.scheduleSessionsRefresh()
+      await vi.advanceTimersByTimeAsync(1_500)
+    })
+
+    expect(getCronJobs).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/apps/desktop/src/app/session/hooks/use-session-list-actions.ts b/apps/desktop/src/app/session/hooks/use-session-list-actions.ts
index 6f971c3165be3..d0c992dfe413a 100644
--- a/apps/desktop/src/app/session/hooks/use-session-list-actions.ts
+++ b/apps/desktop/src/app/session/hooks/use-session-list-actions.ts
@@ -1,4 +1,4 @@
-import { useCallback, useRef } from 'react'
+import { useCallback, useEffect, useRef } from 'react'
 
 import { getCronJobs, listAllProfileSessions, type SessionInfo } from '@/hermes'
 import {
@@ -31,6 +31,8 @@ import {
 
 import { sameCronSignature } from '../../desktop-controller-utils'
 
+import { createTrailingCoalescer, type TrailingCoalescer } from './refresh-coalescer'
+
 // The recents list is local-only: cron rows have their own section, and each
 // messaging platform (telegram, discord, …) is fetched separately into its own
 // self-managed sidebar section (refreshMessagingSessions). Excluding both here
@@ -41,6 +43,19 @@ const SIDEBAR_EXCLUDED_SOURCES = ['cron', 'subagent', 'tool', ...MESSAGING_SESSI
 // external-platform conversations remain, then split per platform in the UI.
 const MESSAGING_EXCLUDED_SOURCES = ['cron', ...LOCAL_SESSION_SOURCE_IDS]
 
+// Trailing window for coalescing event-driven refreshes (message.complete,
+// cross-window sessions-changed). With a swarm of concurrent sessions each
+// completed turn fired its own full refresh; one refresh per window of
+// completions is plenty for a sidebar.
+const SESSIONS_REFRESH_DEBOUNCE_MS = 1_500
+
+// The ancillary sections (cron runs/jobs + messaging slices) change far more
+// slowly than local recents, and cron jobs additionally ride their own poll
+// (CRON_POLL_INTERVAL_MS). Re-fetching all three on every refreshSessions
+// turned each completed turn into a 4-request fan-out — bound them to at most
+// once per interval instead.
+const ANCILLARY_REFRESH_MIN_INTERVAL_MS = 30_000
+
 // Rows a session refresh must preserve even if the aggregator omits them:
 // in-flight first turns (message_count 0), pinned rows aged off the page, the
 // actively-viewed chat (its "working" flag clears a beat before the aggregator
@@ -76,6 +91,7 @@ interface UseSessionListActionsArgs {
  *  wires into the sidebar and refresh effects. */
 export function useSessionListActions({ profileScope }: UseSessionListActionsArgs) {
   const refreshSessionsRequestRef = useRef(0)
+  const lastAncillaryRefreshAtRef = useRef(0)
 
   // Cron-job sessions as their own list (latest N). Independent of the recents
   // page so the two never compete for slots. Cheap + bounded. Kept (even though
@@ -188,11 +204,42 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg
       }
     }
 
-    void refreshCronSessions()
-    void refreshCronJobs()
-    void refreshMessagingSessions()
+    const now = Date.now()
+
+    if (now - lastAncillaryRefreshAtRef.current >= ANCILLARY_REFRESH_MIN_INTERVAL_MS) {
+      lastAncillaryRefreshAtRef.current = now
+      void refreshCronSessions()
+      void refreshCronJobs()
+      void refreshMessagingSessions()
+    }
   }, [profileScope, refreshCronSessions, refreshCronJobs, refreshMessagingSessions])
 
+  // Event-driven refreshes (every message.complete, every cross-window
+  // sessions-changed broadcast) go through this coalesced entry point instead
+  // of calling refreshSessions directly: one trailing run per burst, single
+  // flight so concurrent responses can't race. Deliberate user actions (boot,
+  // paging, profile switch) keep the immediate awaited refreshSessions().
+  const refreshSessionsLatestRef = useRef<() => Promise<void>>(refreshSessions)
+  refreshSessionsLatestRef.current = refreshSessions
+
+  const coalescerRef = useRef<TrailingCoalescer | null>(null)
+
+  useEffect(
+    () => () => {
+      coalescerRef.current?.cancel()
+      coalescerRef.current = null
+    },
+    []
+  )
+
+  const scheduleSessionsRefresh = useCallback(() => {
+    coalescerRef.current ??= createTrailingCoalescer(
+      () => refreshSessionsLatestRef.current(),
+      SESSIONS_REFRESH_DEBOUNCE_MS
+    )
+    coalescerRef.current.schedule()
+  }, [])
+
   const loadMoreSessions = useCallback(async () => {
     bumpSessionsLimit()
     await refreshSessions()
@@ -226,6 +273,7 @@ export function useSessionListActions({ profileScope }: UseSessionListActionsArg
     loadMoreSessionsForProfile,
     refreshCronJobs,
     refreshMessagingSessions,
-    refreshSessions
+    refreshSessions,
+    scheduleSessionsRefresh
   }
 }
diff --git a/apps/desktop/src/lib/gateway-ws-url.test.ts b/apps/desktop/src/lib/gateway-ws-url.test.ts
index e8b09765923f0..2e58cd54513a2 100644
--- a/apps/desktop/src/lib/gateway-ws-url.test.ts
+++ b/apps/desktop/src/lib/gateway-ws-url.test.ts
@@ -1,4 +1,9 @@
-import { GatewayReauthRequiredError, isGatewayReauthRequired, resolveGatewayWsUrl } from '@hermes/shared'
+import {
+  GatewayReauthRequiredError,
+  isGatewayAuthShapedError,
+  isGatewayReauthRequired,
+  resolveGatewayWsUrl
+} from '@hermes/shared'
 import { describe, expect, it, vi } from 'vitest'
 
 const oauthConn = { authMode: 'oauth' as const, wsUrl: 'ws://host/api/ws?ticket=stale' }
@@ -37,6 +42,47 @@ describe('resolveGatewayWsUrl', () => {
       expect(result).toBe('threw')
       expect(result).not.toBe(oauthConn.wsUrl)
     })
+
+    it('rethrows a transport timeout as-is instead of misreporting an expired session', async () => {
+      const cause = new Error('Timed out connecting to Hermes backend after 8000ms')
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(cause)
+      const error = await resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn).catch(e => e)
+      expect(error).toBe(cause)
+      expect(isGatewayReauthRequired(error)).toBe(false)
+    })
+
+    it('rethrows connection-refused / unreachable-host mint failures as retryable', async () => {
+      const cause = new Error('net::ERR_CONNECTION_REFUSED')
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(cause)
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn)).rejects.toBe(cause)
+    })
+
+    it('maps a 401-status mint failure to a reauth error', async () => {
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(new Error('401: {"detail":"session cookie expired"}'))
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn)).rejects.toBeInstanceOf(
+        GatewayReauthRequiredError
+      )
+    })
+
+    it('maps an error carrying statusCode 403 to a reauth error', async () => {
+      const cause = Object.assign(new Error('Forbidden'), { statusCode: 403 })
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(cause)
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn)).rejects.toBeInstanceOf(
+        GatewayReauthRequiredError
+      )
+    })
+
+    it('maps an IPC-flattened main-process reauth message to a reauth error', async () => {
+      const cause = new Error(
+        "Error invoking remote method 'hermes:gateway:ws-url': Error: " +
+          'Your remote gateway session has expired. Open Settings → Gateway and click "Sign in" again.'
+      )
+
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(cause)
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn)).rejects.toBeInstanceOf(
+        GatewayReauthRequiredError
+      )
+    })
   })
 
   describe('token / local mode', () => {
@@ -75,3 +121,28 @@ describe('isGatewayReauthRequired', () => {
     expect(isGatewayReauthRequired('string')).toBe(false)
   })
 })
+
+describe('isGatewayAuthShapedError', () => {
+  it('accepts explicit reauth markers, auth status codes, and canonical reauth phrasings', () => {
+    expect(isGatewayAuthShapedError(new GatewayReauthRequiredError('x'))).toBe(true)
+    expect(isGatewayAuthShapedError({ needsOauthLogin: true })).toBe(true)
+    expect(isGatewayAuthShapedError(Object.assign(new Error('nope'), { statusCode: 401 }))).toBe(true)
+    expect(isGatewayAuthShapedError(new Error('403: forbidden'))).toBe(true)
+    expect(isGatewayAuthShapedError(new Error('Your remote gateway session has expired. Sign in again.'))).toBe(true)
+    expect(isGatewayAuthShapedError(new Error('Remote Hermes gateway uses OAuth, but you are not signed in.'))).toBe(
+      true
+    )
+  })
+
+  it('rejects transport failures', () => {
+    expect(isGatewayAuthShapedError(new Error('Timed out connecting to Hermes backend after 15000ms'))).toBe(false)
+    expect(isGatewayAuthShapedError(new Error('net::ERR_CONNECTION_REFUSED'))).toBe(false)
+    expect(isGatewayAuthShapedError(new Error('Could not connect to Hermes gateway'))).toBe(false)
+    expect(isGatewayAuthShapedError(null)).toBe(false)
+  })
+
+  it('does not false-positive on incidental digit runs containing 401/403', () => {
+    expect(isGatewayAuthShapedError(new Error('backend pid 84012 exited'))).toBe(false)
+    expect(isGatewayAuthShapedError(new Error('http://host:64013 unreachable'))).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/store/gateway.ts b/apps/desktop/src/store/gateway.ts
index ee51119dd7866..9d920717a4795 100644
--- a/apps/desktop/src/store/gateway.ts
+++ b/apps/desktop/src/store/gateway.ts
@@ -27,6 +27,9 @@ export const $gateway = atom<HermesGateway | null>(null)
 
 interface RegistryConfig {
   onEvent: (event: GatewayEvent) => void
+  /** A secondary's socket came back after a drop. Lets the owner reconcile
+   *  per-session busy state whose terminal events died with the old socket. */
+  onReconnected?: (profile: string, gateway: HermesGateway) => void
 }
 
 let config: RegistryConfig | null = null
@@ -139,6 +142,7 @@ async function reconnectSecondary(entry: Secondary): Promise<void> {
   try {
     await openSecondary(entry)
     entry.reconnectAttempt = 0
+    config?.onReconnected?.(entry.profile, entry.gateway)
   } catch {
     // Transport failure → fall through to the backoff below.
   } finally {
diff --git a/apps/shared/src/index.ts b/apps/shared/src/index.ts
index 50f9936bfb3f0..920c4fd2c5af3 100644
--- a/apps/shared/src/index.ts
+++ b/apps/shared/src/index.ts
@@ -11,6 +11,7 @@ export {
 export {
   GatewayReauthRequiredError,
   buildHermesWebSocketUrl,
+  isGatewayAuthShapedError,
   isGatewayReauthRequired,
   resolveGatewayWsUrl,
   type GatewayAuthMode,
diff --git a/apps/shared/src/websocket-url.ts b/apps/shared/src/websocket-url.ts
index 78562b55df03d..67f23f583f4b2 100644
--- a/apps/shared/src/websocket-url.ts
+++ b/apps/shared/src/websocket-url.ts
@@ -31,6 +31,37 @@ export function isGatewayReauthRequired(error: unknown): error is GatewayReauthR
   )
 }
 
+// HTTP auth statuses embedded in gateway/main-process error messages, e.g.
+// "401: {...}" from fetchJson or "status 403" from the HTML guard. Errors that
+// cross Electron's IPC bridge keep only their message (statusCode and
+// needsOauthLogin are stripped), so message inspection is the only renderer-side
+// signal. Word-boundary anchored so ports/ids containing "401" don't match.
+const AUTH_STATUS_PATTERN = /(?:^|[^0-9])(?:401|403)(?:[^0-9]|$)/
+// Canonical reauth phrasings the main process throws only for genuine
+// sign-in-required failures (buildRemoteConnection / mintGatewayWsTicket).
+const AUTH_MESSAGE_PATTERN = /session has expired|not signed in|sign in/i
+
+/** True when an error (possibly IPC-flattened to just a message) indicates the
+ *  gateway rejected our credentials — as opposed to a transport failure
+ *  (timeout, unreachable host) that a retry can recover from. */
+export function isGatewayAuthShapedError(error: unknown): boolean {
+  if (isGatewayReauthRequired(error)) {
+    return true
+  }
+
+  if (typeof error === 'object' && error !== null) {
+    const statusCode = (error as { statusCode?: unknown }).statusCode
+
+    if (statusCode === 401 || statusCode === 403) {
+      return true
+    }
+  }
+
+  const message = error instanceof Error ? error.message : typeof error === 'string' ? error : ''
+
+  return AUTH_STATUS_PATTERN.test(message) || AUTH_MESSAGE_PATTERN.test(message)
+}
+
 export async function resolveGatewayWsUrl(deps: ResolveGatewayWsUrlDeps, conn: GatewayWsConnection): Promise<string> {
   const mint = deps.getGatewayWsUrl
   const profile = conn.profile ?? null
@@ -45,10 +76,19 @@ export async function resolveGatewayWsUrl(deps: ResolveGatewayWsUrlDeps, conn: G
     try {
       return await mint(profile)
     } catch (error) {
-      throw new GatewayReauthRequiredError(
-        'Your remote gateway session has expired. Open Settings -> Gateway and click "Sign in" again.',
-        { cause: error }
-      )
+      // Only a credential rejection means the OAuth session is dead. A
+      // transport failure (Tailscale blip, sleep/wake race, backend restart)
+      // must stay a plain retryable error — wrapping it as reauth here sent
+      // users to a needless re-sign-in while the backoff loop would have
+      // recovered on its own.
+      if (isGatewayAuthShapedError(error)) {
+        throw new GatewayReauthRequiredError(
+          'Your remote gateway session has expired. Open Settings -> Gateway and click "Sign in" again.',
+          { cause: error }
+        )
+      }
+
+      throw error
     }
   }
 

From 95e1e8d48b95f9265f0fdcd7bfb192e7e3e4ef65 Mon Sep 17 00:00:00 2001
From: Rod-fernandez <rodrigo@nxtlevelsaas.com>
Date: Sat, 4 Jul 2026 03:11:08 -0400
Subject: [PATCH 3/6] feat(desktop): multi-profile session restore, rail
 activity badges, cross-profile overview, scoped query caches
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Per-profile last-session memo: switching profiles restores each
  profile's last open session (existence-checked, probe fallback,
  token-guarded against races; deleted/archived sessions evicted).
- Profile rail badges: working spinner dot + amber needs-input count per
  profile with session tooltips; click opens the neediest session in
  that profile. dnd-kit sortable behavior preserved.
- Command center gains an 'Overview' landing section: per-profile
  working/attention/total/last-activity rows with quick-switch, plus a
  kanban summary strip (per-status counts + hot review/blocked cards)
  that degrades gracefully when the backend lacks the kanban plugin.
- react-query keys are profile-scoped (config, config-schema, skills,
  toolsets, hub sources/search, model-options); the blanket
  invalidateQueries() on profile change is gone — profile hopping hits
  warm caches with no cross-profile bleed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/src/app/chat/index.tsx           |   9 +-
 .../src/app/chat/sidebar/profile-switcher.tsx | 386 ++++++++++++------
 apps/desktop/src/app/command-center/index.tsx |  62 ++-
 .../app/command-center/overview-data.test.ts  | 209 ++++++++++
 .../src/app/command-center/overview-data.ts   | 145 +++++++
 .../src/app/command-center/overview.test.tsx  | 261 ++++++++++++
 .../src/app/command-center/overview.tsx       | 259 ++++++++++++
 .../desktop/src/app/command-palette/index.tsx |   7 +-
 .../src/app/desktop-controller-utils.test.ts  |  68 ++-
 .../src/app/desktop-controller-utils.ts       |  15 +
 apps/desktop/src/app/desktop-controller.tsx   | 100 ++++-
 .../src/app/hooks/use-config-record.test.ts   |  62 +++
 .../src/app/hooks/use-config-record.ts        |  26 +-
 .../hooks/use-message-stream/gateway-event.ts |   6 +-
 .../session/hooks/use-model-controls.test.tsx |   7 +
 .../app/session/hooks/use-model-controls.ts   |  12 +-
 .../src/app/settings/config-settings.tsx      |   6 +-
 .../src/app/settings/model-settings.test.tsx  |  31 +-
 .../app/settings/providers-settings.test.tsx  |   9 +-
 .../src/app/shell/model-menu-panel.test.tsx   |   9 +-
 .../src/app/shell/model-menu-panel.tsx        |  11 +-
 apps/desktop/src/app/skills/hub.tsx           |  16 +-
 apps/desktop/src/app/skills/index.tsx         |  45 +-
 apps/desktop/src/components/model-picker.tsx  |   7 +-
 .../components/model-visibility-dialog.tsx    |   6 +-
 apps/desktop/src/i18n/en.ts                   |  20 +-
 apps/desktop/src/i18n/types.ts                |  21 +
 apps/desktop/src/i18n/zh.ts                   |  20 +-
 apps/desktop/src/store/profile.test.ts        | 213 +++++++++-
 apps/desktop/src/store/profile.ts             | 215 +++++++++-
 30 files changed, 2057 insertions(+), 206 deletions(-)
 create mode 100644 apps/desktop/src/app/command-center/overview-data.test.ts
 create mode 100644 apps/desktop/src/app/command-center/overview-data.ts
 create mode 100644 apps/desktop/src/app/command-center/overview.test.tsx
 create mode 100644 apps/desktop/src/app/command-center/overview.tsx
 create mode 100644 apps/desktop/src/app/hooks/use-config-record.test.ts

diff --git a/apps/desktop/src/app/chat/index.tsx b/apps/desktop/src/app/chat/index.tsx
index a5216210a7996..57ecb2c0389ab 100644
--- a/apps/desktop/src/app/chat/index.tsx
+++ b/apps/desktop/src/app/chat/index.tsx
@@ -24,7 +24,7 @@ import { useIncrementalExternalStoreRuntime } from '@/lib/incremental-external-s
 import { cn } from '@/lib/utils'
 import type { ComposerAttachment } from '@/store/composer'
 import { $pinnedSessionIds } from '@/store/layout'
-import { $gatewaySwapTarget } from '@/store/profile'
+import { $activeGatewayProfile, $gatewaySwapTarget, normalizeProfileKey } from '@/store/profile'
 import {
   $activeSessionId,
   $awaitingResponse,
@@ -347,8 +347,13 @@ export function ChatView({
   const showChatBar = !loadingSession && !resumeExhausted && !isWatchWindow()
   const threadKey = selectedSessionId || activeSessionId || (isRoutedSessionView ? location.pathname : 'new')
 
+  // Keyed by the live gateway profile: the catalog is served per backend, so
+  // profile A's models never paint under profile B and a hop back hits A's
+  // warm cache (no blanket invalidation on switch anymore).
+  const modelOptionsProfile = normalizeProfileKey(useStore($activeGatewayProfile))
+
   const modelOptionsQuery = useQuery<ModelOptionsResponse>({
-    queryKey: ['model-options', activeSessionId || 'global'],
+    queryKey: ['model-options', modelOptionsProfile, activeSessionId || 'global'],
     queryFn: () => {
       if (!activeSessionId) {
         return getGlobalModelOptions()
diff --git a/apps/desktop/src/app/chat/sidebar/profile-switcher.tsx b/apps/desktop/src/app/chat/sidebar/profile-switcher.tsx
index c3016ec67c83f..0909da1248376 100644
--- a/apps/desktop/src/app/chat/sidebar/profile-switcher.tsx
+++ b/apps/desktop/src/app/chat/sidebar/profile-switcher.tsx
@@ -39,15 +39,19 @@ import { cn } from '@/lib/utils'
 import { notify, notifyError } from '@/store/notifications'
 import {
   $activeGatewayProfile,
+  $profileActivity,
   $profileColors,
   $profileCreateRequest,
   $profileOrder,
   $profiles,
   $profileScope,
   ALL_PROFILES,
+  neediestSessionId,
   normalizeProfileKey,
+  type ProfileActivity,
   refreshActiveProfile,
   selectProfile,
+  selectProfileSession,
   setProfileColor,
   setProfileOrder,
   setShowAllProfiles,
@@ -105,6 +109,7 @@ export function ProfileRail() {
   const gatewayProfile = useStore($activeGatewayProfile)
   const order = useStore($profileOrder)
   const colors = useStore($profileColors)
+  const activityByProfile = useStore($profileActivity)
   const navigate = useNavigate()
 
   const [createOpen, setCreateOpen] = useState(false)
@@ -148,6 +153,25 @@ export function ProfileRail() {
   const defaultProfile = profiles.find(profile => profile.is_default)
   const onDefault = !isAll && activeKey === 'default'
 
+  // Default rows are keyed "default" by the aggregator/derivation whatever the
+  // profile's directory name; named rows key by their (normalized) name.
+  const defaultActivity = defaultProfile
+    ? (activityByProfile[normalizeProfileKey(defaultProfile.name)] ?? activityByProfile.default)
+    : undefined
+
+  // Badge click: jump into the profile AND straight to the session that needs
+  // you (attention first, else the most recent working one) — composing with
+  // the per-profile last-session restore for plain square clicks.
+  const openNeediest = (name: string, activity: ProfileActivity | undefined) => {
+    const target = neediestSessionId(activity)
+
+    if (target) {
+      selectProfileSession(name, target)
+    } else {
+      selectProfile(name)
+    }
+  }
+
   const named = sortByProfileOrder(
     profiles.filter(profile => !profile.is_default),
     order
@@ -224,12 +248,22 @@ export function ProfileRail() {
         (defaultProfile ? (
           // On default → toggle to all. Anywhere else (all view or a named
           // profile) → return to default. So leaving a profile never lands on all.
-          <ProfilePill
-            active={isAll || onDefault}
-            glyph={isAll ? 'layers' : 'home'}
-            label={onDefault ? p.showAllProfiles : p.switchToProfile(defaultProfile.name)}
-            onSelect={() => (onDefault ? setShowAllProfiles(true) : selectProfile(defaultProfile.name))}
-          />
+          // While away from default, its activity badge rides the pill's corner.
+          <span className="relative shrink-0">
+            <ProfilePill
+              active={isAll || onDefault}
+              glyph={isAll ? 'layers' : 'home'}
+              label={onDefault ? p.showAllProfiles : p.switchToProfile(defaultProfile.name)}
+              onSelect={() => (onDefault ? setShowAllProfiles(true) : selectProfile(defaultProfile.name))}
+            />
+            {!onDefault && defaultActivity && (
+              <ActivityBadge
+                activity={defaultActivity}
+                label={defaultProfile.name}
+                onOpen={() => openNeediest(defaultProfile.name, defaultActivity)}
+              />
+            )}
+          </span>
         ) : (
           <ProfilePill active={isAll} glyph="layers" label={p.allProfiles} onSelect={() => setShowAllProfiles(true)} />
         ))}
@@ -251,6 +285,7 @@ export function ProfileRail() {
         <div className="flex min-w-0 flex-1 items-center gap-1">
           <ProfileDropdown
             activeKey={isAll ? null : activeKey}
+            activityByProfile={activityByProfile}
             colors={colors}
             onSelect={selectProfile}
             profiles={named}
@@ -278,11 +313,15 @@ export function ProfileRail() {
                   {named.map(profile => (
                     <ProfileSquare
                       active={!isAll && normalizeProfileKey(profile.name) === activeKey}
+                      activity={activityByProfile[normalizeProfileKey(profile.name)]}
                       color={resolveProfileColor(profile.name, colors)}
                       key={profile.name}
                       label={profile.name}
                       onDelete={() => setPendingDelete(profile)}
                       onEditSoul={() => setPendingSoul(profile.name)}
+                      onOpenActivity={() =>
+                        openNeediest(profile.name, activityByProfile[normalizeProfileKey(profile.name)])
+                      }
                       onRecolor={color => setProfileColor(profile.name, color)}
                       onRename={() => setPendingRename(profile)}
                       onSelect={() => selectProfile(profile.name)}
@@ -432,11 +471,13 @@ function AddProfileButton({ label, onClick }: { label: string; onClick: () => vo
 // falls back to the placeholder since the left toggle pill carries that state.
 function ProfileDropdown({
   activeKey,
+  activityByProfile,
   colors,
   onSelect,
   profiles
 }: {
   activeKey: null | string
+  activityByProfile: Record<string, ProfileActivity>
   colors: Record<string, string>
   onSelect: (name: string) => void
   profiles: ProfileInfo[]
@@ -455,6 +496,9 @@ function ProfileDropdown({
         {profiles.map(profile => {
           const color = resolveProfileColor(profile.name, colors)
           const hue = color ?? 'var(--ui-text-quaternary)'
+          const activity = activityByProfile[normalizeProfileKey(profile.name)]
+          const attention = activity ? activity.attention.length : 0
+          const working = activity ? activity.working.length : 0
 
           return (
             <SelectItem key={profile.name} value={profile.name}>
@@ -467,6 +511,17 @@ function ProfileDropdown({
                   {profile.name.replace(/[^a-z0-9]/gi, '').charAt(0) || '?'}
                 </span>
                 <span className="truncate">{profile.name}</span>
+                {/* Condensed rail: a plain dot stands in for the corner badge
+                    (amber = needs input beats accent = working). */}
+                {(attention > 0 || working > 0) && (
+                  <span
+                    aria-hidden="true"
+                    className={cn(
+                      'ml-auto size-1.5 shrink-0 rounded-full',
+                      attention > 0 ? 'bg-amber-500' : 'bg-(--ui-accent)'
+                    )}
+                  />
+                )}
               </span>
             </SelectItem>
           )
@@ -476,6 +531,78 @@ function ProfileDropdown({
   )
 }
 
+// How many activity rows a rail tooltip lists before truncating — the badge
+// count still carries the full number.
+const ACTIVITY_TOOLTIP_LIMIT = 6
+
+// Working/attention badge pinned to a rail square's (or the default pill's)
+// corner. Amber + count = sessions blocked on you; accent ping = a turn is
+// running somewhere in that profile ("needs input" wins, like the sidebar row
+// dot). A separate sibling button — a <button> can't nest one — that stops
+// pointer-down so a badge click never arms a drag or selects the square under
+// it; clicking jumps straight to the neediest session via onOpen.
+function ActivityBadge({ activity, label, onOpen }: { activity: ProfileActivity; label: string; onOpen: () => void }) {
+  const { t } = useI18n()
+  const p = t.profiles
+  const attention = activity.attention.length
+  const working = activity.working.length
+
+  if (attention === 0 && working === 0) {
+    return null
+  }
+
+  const description = attention > 0 ? p.attentionBadge(attention) : p.workingBadge(working)
+
+  return (
+    <button
+      aria-label={`${label}: ${description}`}
+      className={cn(
+        'absolute -right-1 -top-1 z-10 grid place-items-center rounded-full leading-none',
+        attention > 0
+          ? 'h-3 min-w-3 bg-amber-500 px-[0.1875rem] text-[0.5rem] font-semibold text-black'
+          : "size-2 bg-(--ui-accent) before:absolute before:inset-0 before:animate-ping before:rounded-full before:bg-(--ui-accent) before:opacity-70 before:content-['']"
+      )}
+      onClick={event => {
+        event.stopPropagation()
+        onOpen()
+      }}
+      onPointerDown={event => event.stopPropagation()}
+      title={description}
+      type="button"
+    >
+      {attention > 0 ? (attention > 9 ? '9+' : attention) : null}
+    </button>
+  )
+}
+
+// Square tooltip body: the plain profile name, or — when the profile has live
+// activity — the name plus each active session's title and state.
+function ActivityTooltip({ activity, label }: { activity: ProfileActivity | undefined; label: string }) {
+  const { t } = useI18n()
+  const r = t.sidebar.row
+  const rows = activity ? [...activity.attention, ...activity.working].slice(0, ACTIVITY_TOOLTIP_LIMIT) : []
+
+  if (rows.length === 0) {
+    return <>{label}</>
+  }
+
+  return (
+    <div className="flex max-w-64 flex-col gap-1">
+      <span className="font-semibold">{label}</span>
+      {rows.map(row => (
+        <span className="flex items-center gap-1.5" key={row.id}>
+          <span
+            aria-hidden="true"
+            className={cn('size-1.5 shrink-0 rounded-full', row.needsInput ? 'bg-amber-500' : 'bg-(--ui-accent)')}
+          />
+          <span className="min-w-0 flex-1 truncate">{row.title?.trim() || r.untitledPlaceholder}</span>
+          <span className="shrink-0 text-(--ui-text-tertiary)">{row.needsInput ? r.needsInput : r.sessionRunning}</span>
+        </span>
+      ))}
+    </div>
+  )
+}
+
 interface ProfilePillProps {
   active: boolean
   // home / All / Manage are glyph action buttons (navigation, not identity).
@@ -507,9 +634,11 @@ function ProfilePill({ active, glyph, label, onSelect }: ProfilePillProps) {
 
 interface ProfileSquareProps {
   active: boolean
+  activity?: ProfileActivity
   color: null | string
   label: string
   onSelect: () => void
+  onOpenActivity: () => void
   onRecolor: (color: null | string) => void
   onRename: () => void
   onEditSoul: () => void
@@ -529,10 +658,12 @@ const LONG_PRESS_MS = 450
 // dnd listeners, hover tip, and right-click menu.
 function ProfileSquare({
   active,
+  activity,
   color,
   label,
   onDelete,
   onEditSoul,
+  onOpenActivity,
   onRecolor,
   onRename,
   onSelect
@@ -576,123 +707,136 @@ function ProfileSquare({
   }
 
   return (
-    <Popover onOpenChange={setPickerOpen} open={pickerOpen}>
-      <ContextMenu>
-        <TooltipProvider delayDuration={0}>
-          <Tooltip>
-            <PopoverAnchor asChild>
-              <ContextMenuTrigger asChild>
-                <TooltipTrigger asChild>
-                  <button
-                    className={cn(
-                      'grid size-5 shrink-0 cursor-grab touch-none select-none place-items-center rounded-[3px] text-[0.5625rem] font-semibold uppercase leading-none transition-opacity hover:opacity-100',
-                      active ? 'opacity-100' : 'opacity-55',
-                      isDragging && 'z-10 cursor-grabbing opacity-100'
-                    )}
-                    ref={setNodeRef}
-                    style={{
-                      backgroundColor: profileColorSoft(hue, active ? 30 : 22),
-                      boxShadow: [ring, lift].filter(Boolean).join(', ') || undefined,
-                      color: color ?? undefined,
-                      // Glide the dragged square between snapped cells with a little
-                      // overshoot (no scale — the overflow-x strip would clip it).
-                      transform: base,
-                      transition: isDragging ? DRAG_TRANSITION : transition
-                    }}
-                    type="button"
-                    {...attributes}
-                    {...listeners}
-                    aria-label={label}
-                    aria-pressed={active}
-                    // Hold-to-recolor rides alongside the dnd pointer listener (call
-                    // it first so drag tracking still arms), then a timer opens the
-                    // picker and flags the trailing click so it doesn't also select.
-                    onClick={() => {
-                      if (suppressClick.current) {
-                        suppressClick.current = false
-
-                        return
-                      }
-
-                      onSelect()
-                    }}
-                    onPointerCancel={clearPress}
-                    onPointerDown={event => {
-                      listeners?.onPointerDown?.(event)
+    // The sortable node is this wrapper (not the button) so the corner
+    // activity badge — a sibling button; buttons can't nest — rides along with
+    // drags. The drag listeners stay on the square itself.
+    <div
+      className={cn('relative shrink-0', isDragging && 'z-10')}
+      ref={setNodeRef}
+      style={{
+        // Glide the dragged square between snapped cells with a little
+        // overshoot (no scale — the overflow-x strip would clip it).
+        transform: base,
+        transition: isDragging ? DRAG_TRANSITION : transition
+      }}
+    >
+      <Popover onOpenChange={setPickerOpen} open={pickerOpen}>
+        <ContextMenu>
+          <TooltipProvider delayDuration={0}>
+            <Tooltip>
+              <PopoverAnchor asChild>
+                <ContextMenuTrigger asChild>
+                  <TooltipTrigger asChild>
+                    <button
+                      className={cn(
+                        'grid size-5 shrink-0 cursor-grab touch-none select-none place-items-center rounded-[3px] text-[0.5625rem] font-semibold uppercase leading-none transition-opacity hover:opacity-100',
+                        active ? 'opacity-100' : 'opacity-55',
+                        isDragging && 'cursor-grabbing opacity-100'
+                      )}
+                      style={{
+                        backgroundColor: profileColorSoft(hue, active ? 30 : 22),
+                        boxShadow: [ring, lift].filter(Boolean).join(', ') || undefined,
+                        color: color ?? undefined
+                      }}
+                      type="button"
+                      {...attributes}
+                      {...listeners}
+                      aria-label={label}
+                      aria-pressed={active}
+                      // Hold-to-recolor rides alongside the dnd pointer listener (call
+                      // it first so drag tracking still arms), then a timer opens the
+                      // picker and flags the trailing click so it doesn't also select.
+                      onClick={() => {
+                        if (suppressClick.current) {
+                          suppressClick.current = false
+
+                          return
+                        }
+
+                        onSelect()
+                      }}
+                      onPointerCancel={clearPress}
+                      onPointerDown={event => {
+                        listeners?.onPointerDown?.(event)
+
+                        if (event.button !== 0) {
+                          return
+                        }
 
-                      if (event.button !== 0) {
-                        return
-                      }
-
-                      suppressClick.current = false
-                      clearPress()
-                      pressTimer.current = window.setTimeout(() => {
-                        suppressClick.current = true
-                        triggerHaptic('success')
-                        setPickerOpen(true)
-                      }, LONG_PRESS_MS)
-                    }}
-                    onPointerLeave={clearPress}
-                    onPointerUp={clearPress}
-                  >
-                    {label.replace(/[^a-z0-9]/gi, '').charAt(0) || '?'}
-                  </button>
-                </TooltipTrigger>
-              </ContextMenuTrigger>
-            </PopoverAnchor>
-            <TooltipContent>{label}</TooltipContent>
-          </Tooltip>
-        </TooltipProvider>
-
-        {/* The rail sits at the very bottom, so pad off the chrome (esp. the
-            statusbar) — Radix then flips the menu up instead of squishing it. */}
-        <ContextMenuContent
-          aria-label={p.actionsFor(label)}
-          className="w-40"
+                        suppressClick.current = false
+                        clearPress()
+                        pressTimer.current = window.setTimeout(() => {
+                          suppressClick.current = true
+                          triggerHaptic('success')
+                          setPickerOpen(true)
+                        }, LONG_PRESS_MS)
+                      }}
+                      onPointerLeave={clearPress}
+                      onPointerUp={clearPress}
+                    >
+                      {label.replace(/[^a-z0-9]/gi, '').charAt(0) || '?'}
+                    </button>
+                  </TooltipTrigger>
+                </ContextMenuTrigger>
+              </PopoverAnchor>
+              <TooltipContent>
+                <ActivityTooltip activity={activity} label={label} />
+              </TooltipContent>
+            </Tooltip>
+          </TooltipProvider>
+
+          {/* The rail sits at the very bottom, so pad off the chrome (esp. the
+              statusbar) — Radix then flips the menu up instead of squishing it. */}
+          <ContextMenuContent
+            aria-label={p.actionsFor(label)}
+            className="w-40"
+            collisionPadding={{ bottom: 44, left: 8, right: 8, top: 8 }}
+            // Menu close refocuses the trigger — which doubles as the popover
+            // anchor — so the picker reads it as focus-outside and dies on open.
+            // Suppress the refocus and the picker survives.
+            onCloseAutoFocus={event => event.preventDefault()}
+          >
+            <ContextMenuItem onSelect={() => setPickerOpen(true)}>
+              <Codicon name="symbol-color" size="0.875rem" />
+              <span>{p.color}</span>
+            </ContextMenuItem>
+            <ContextMenuItem onSelect={onRename}>
+              <Codicon name="text-size" size="0.875rem" />
+              <span>{p.renameMenu}</span>
+            </ContextMenuItem>
+            <ContextMenuItem onSelect={onEditSoul}>
+              <Codicon name="edit" size="0.875rem" />
+              <span>{p.editSoul}</span>
+            </ContextMenuItem>
+            <ContextMenuItem
+              className="text-destructive focus:text-destructive"
+              onSelect={onDelete}
+              variant="destructive"
+            >
+              <Codicon name="trash" size="0.875rem" />
+              <span>{t.common.delete}</span>
+            </ContextMenuItem>
+          </ContextMenuContent>
+        </ContextMenu>
+
+        <PopoverContent
+          aria-label={p.colorFor(label)}
+          className="w-auto p-2"
           collisionPadding={{ bottom: 44, left: 8, right: 8, top: 8 }}
-          // Menu close refocuses the trigger — which doubles as the popover
-          // anchor — so the picker reads it as focus-outside and dies on open.
-          // Suppress the refocus and the picker survives.
-          onCloseAutoFocus={event => event.preventDefault()}
+          side="top"
         >
-          <ContextMenuItem onSelect={() => setPickerOpen(true)}>
-            <Codicon name="symbol-color" size="0.875rem" />
-            <span>{p.color}</span>
-          </ContextMenuItem>
-          <ContextMenuItem onSelect={onRename}>
-            <Codicon name="text-size" size="0.875rem" />
-            <span>{p.renameMenu}</span>
-          </ContextMenuItem>
-          <ContextMenuItem onSelect={onEditSoul}>
-            <Codicon name="edit" size="0.875rem" />
-            <span>{p.editSoul}</span>
-          </ContextMenuItem>
-          <ContextMenuItem
-            className="text-destructive focus:text-destructive"
-            onSelect={onDelete}
-            variant="destructive"
-          >
-            <Codicon name="trash" size="0.875rem" />
-            <span>{t.common.delete}</span>
-          </ContextMenuItem>
-        </ContextMenuContent>
-      </ContextMenu>
-
-      <PopoverContent
-        aria-label={p.colorFor(label)}
-        className="w-auto p-2"
-        collisionPadding={{ bottom: 44, left: 8, right: 8, top: 8 }}
-        side="top"
-      >
-        <ColorSwatches
-          clearIcon="sync"
-          clearLabel={p.autoColor}
-          onChange={pickColor}
-          swatches={PROFILE_SWATCHES}
-          swatchLabel={p.setColor}
-          value={color}
-        />
-      </PopoverContent>
-    </Popover>
+          <ColorSwatches
+            clearIcon="sync"
+            clearLabel={p.autoColor}
+            onChange={pickColor}
+            swatches={PROFILE_SWATCHES}
+            swatchLabel={p.setColor}
+            value={color}
+          />
+        </PopoverContent>
+      </Popover>
+
+      {activity && !isDragging && <ActivityBadge activity={activity} label={label} onOpen={onOpenActivity} />}
+    </div>
   )
 }
diff --git a/apps/desktop/src/app/command-center/index.tsx b/apps/desktop/src/app/command-center/index.tsx
index 5eb2cf8a5b992..df99a9a99eb51 100644
--- a/apps/desktop/src/app/command-center/index.tsx
+++ b/apps/desktop/src/app/command-center/index.tsx
@@ -21,6 +21,7 @@ import {
   Download,
   MessageCircle,
   Trash2,
+  Users,
   Wrench
 } from '@/lib/icons'
 import { exportSession } from '@/lib/session-export'
@@ -36,10 +37,19 @@ import { OverlayMain, OverlayNav, OverlaySplitLayout } from '../overlays/overlay
 import { OverlayView } from '../overlays/overlay-view'
 
 import { MaintenancePanel } from './maintenance'
+import { OverviewPanel } from './overview'
 
-export type CommandCenterSection = 'maintenance' | 'sessions' | 'system' | 'usage'
+export type CommandCenterSection = 'maintenance' | 'overview' | 'sessions' | 'system' | 'usage'
 
-const SECTIONS = ['sessions', 'system', 'usage', 'maintenance'] as const satisfies readonly CommandCenterSection[]
+// 'overview' leads: it is the default landing when the panel opens without an
+// explicit ?section (the global hotkey path).
+const SECTIONS = [
+  'overview',
+  'sessions',
+  'system',
+  'usage',
+  'maintenance'
+] as const satisfies readonly CommandCenterSection[]
 
 const LOG_FILES = ['agent', 'errors', 'gateway', 'desktop'] as const
 const LOG_LEVELS = ['ALL', 'INFO', 'WARNING', 'ERROR'] as const
@@ -51,7 +61,8 @@ interface CommandCenterViewProps {
   initialSection?: CommandCenterSection
   onClose: () => void
   onDeleteSession: (sessionId: string) => Promise<void>
-  // Accepted for call-site parity; navigation lives in the global Cmd+K palette.
+  // Used by the overview's kanban chips (open the board view); broader
+  // navigation lives in the global Cmd+K palette.
   onNavigateRoute?: (path: string) => void
   onOpenSession: (sessionId: string) => void
 }
@@ -124,13 +135,28 @@ function EmptyPanel({ action, description, title }: { action?: ReactNode; descri
   )
 }
 
-export function CommandCenterView({ initialSection, onClose, onDeleteSession, onOpenSession }: CommandCenterViewProps) {
+export function CommandCenterView({
+  initialSection,
+  onClose,
+  onDeleteSession,
+  onNavigateRoute,
+  onOpenSession
+}: CommandCenterViewProps) {
   const { t } = useI18n()
   const cc = t.commandCenter
+  const ov = t.commandCenterOverview
   const sessions = useStore($sessions)
   const pinnedSessionIds = useStore($pinnedSessionIds)
 
-  const [section, setSection] = useRouteEnumParam('section', SECTIONS, initialSection ?? 'sessions')
+  const [section, setSection] = useRouteEnumParam('section', SECTIONS, initialSection ?? 'overview')
+
+  // 'overview' is typed outside cc.sections/sectionDescriptions (its copy lives
+  // in the appended commandCenterOverview block), so label lookups branch here.
+  const sectionLabel = (value: CommandCenterSection): string =>
+    value === 'overview' ? ov.sectionLabel : cc.sections[value]
+
+  const sectionDescription = (value: CommandCenterSection): string =>
+    value === 'overview' ? ov.sectionDescription : cc.sectionDescriptions[value]
 
   const [query, setQuery] = useState('')
   const [status, setStatus] = useState<StatusResponse | null>(null)
@@ -299,15 +325,17 @@ export function CommandCenterView({ initialSection, onClose, onDeleteSession, on
           groups={SECTIONS.map(value => ({
             active: section === value,
             icon:
-              value === 'sessions'
-                ? MessageCircle
-                : value === 'system'
-                  ? Activity
-                  : value === 'maintenance'
-                    ? Wrench
-                    : BarChart3,
+              value === 'overview'
+                ? Users
+                : value === 'sessions'
+                  ? MessageCircle
+                  : value === 'system'
+                    ? Activity
+                    : value === 'maintenance'
+                      ? Wrench
+                      : BarChart3,
             id: value,
-            label: cc.sections[value],
+            label: sectionLabel(value),
             onSelect: () => setSection(value)
           }))}
         />
@@ -317,10 +345,10 @@ export function CommandCenterView({ initialSection, onClose, onDeleteSession, on
             {/* Redundant on narrow — the nav dropdown already names the section. */}
             <div className="min-w-0 max-[47.5rem]:hidden">
               <h2 className="text-[length:var(--conversation-text-font-size)] font-semibold text-foreground">
-                {cc.sections[section]}
+                {sectionLabel(section)}
               </h2>
               <p className="mt-0.5 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
-                {cc.sectionDescriptions[section]}
+                {sectionDescription(section)}
               </p>
             </div>
             <div className="flex shrink-0 items-center gap-2">
@@ -342,7 +370,9 @@ export function CommandCenterView({ initialSection, onClose, onDeleteSession, on
             </div>
           </header>
 
-          {section === 'sessions' ? (
+          {section === 'overview' ? (
+            <OverviewPanel onClose={onClose} onNavigateRoute={onNavigateRoute} />
+          ) : section === 'sessions' ? (
             <div className="min-h-0 flex-1 overflow-y-auto">
               {!sessionListHasResults ? (
                 <EmptyPanel description={debouncedQuery ? cc.noResults : cc.noSessions} />
diff --git a/apps/desktop/src/app/command-center/overview-data.test.ts b/apps/desktop/src/app/command-center/overview-data.test.ts
new file mode 100644
index 0000000000000..27796df3a2334
--- /dev/null
+++ b/apps/desktop/src/app/command-center/overview-data.test.ts
@@ -0,0 +1,209 @@
+// @vitest-environment jsdom
+import { describe, expect, it, vi } from 'vitest'
+
+import type { ProfileInfo, SessionInfo } from '@/types/hermes'
+import type { KanbanBoardPayload, KanbanCard } from '@/types/kanban'
+
+// Keep store/profile's side-effecting imports inert (same pattern as
+// store/profile.test.ts): the gateway socket layer and the REST query client
+// must not run for real in a unit test.
+vi.mock('@/store/gateway', () => ({
+  $gateway: { get: () => null },
+  ensureGatewayForProfile: vi.fn(async () => undefined)
+}))
+vi.mock('@/hermes', () => ({
+  getProfiles: vi.fn(async () => ({ profiles: [] })),
+  setApiRequestProfile: vi.fn()
+}))
+vi.mock('@/lib/query-client', () => ({ queryClient: { invalidateQueries: vi.fn() } }))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
+const { buildProfileOverviewRows, summarizeKanbanBoard } = await import('./overview-data')
+const { KANBAN_COLUMNS } = await import('@/store/kanban')
+
+function session(id: string, profile: string | undefined, extra: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    ended_at: null,
+    id,
+    input_tokens: 0,
+    is_active: true,
+    last_active: 100,
+    message_count: 1,
+    model: null,
+    output_tokens: 0,
+    preview: null,
+    profile,
+    source: null,
+    started_at: 50,
+    title: null,
+    tool_call_count: 0,
+    ...extra
+  }
+}
+
+function profile(name: string, isDefault = false): ProfileInfo {
+  return {
+    has_env: false,
+    is_default: isDefault,
+    model: null,
+    name,
+    path: `/tmp/hermes/${name}`,
+    provider: null,
+    skill_count: 0
+  }
+}
+
+function card(id: string, status: string, extra: Partial<KanbanCard> = {}): KanbanCard {
+  return {
+    id,
+    title: `Task ${id}`,
+    body: null,
+    assignee: null,
+    status,
+    priority: 0,
+    created_by: null,
+    created_at: 1,
+    started_at: null,
+    completed_at: null,
+    workspace_kind: 'scratch',
+    workspace_path: null,
+    claim_lock: null,
+    claim_expires: null,
+    tenant: null,
+    ...extra
+  }
+}
+
+function board(tasksByColumn: Record<string, KanbanCard[]>): KanbanBoardPayload {
+  return {
+    columns: KANBAN_COLUMNS.map(name => ({ name, tasks: tasksByColumn[name] ?? [] })),
+    tenants: [],
+    assignees: [],
+    latest_event_id: 1,
+    now: 1000
+  }
+}
+
+describe('buildProfileOverviewRows', () => {
+  it('aggregates working/attention/last-activity per profile in rail order', () => {
+    const rows = buildProfileOverviewRows({
+      sessions: [
+        session('s1', undefined, { last_active: 300 }),
+        session('s2', 'default', { last_active: 100 }),
+        session('s3', 'coder', { last_active: 900 }),
+        session('s4', 'coder', { last_active: 500 }),
+        session('s5', 'writer', { last_active: 0, started_at: 40 })
+      ],
+      profiles: [profile('default', true), profile('writer'), profile('coder'), profile('idle-one')],
+      profileOrder: ['coder', 'writer'],
+      workingIds: ['s3', 's4', 's1'],
+      attentionIds: ['s4', 's5'],
+      profileTotals: {}
+    })
+
+    expect(rows.map(row => row.key)).toEqual(['default', 'coder', 'writer', 'idle-one'])
+
+    const [def, coder, writer, idle] = rows
+
+    expect(def).toMatchObject({ isDefault: true, workingCount: 1, attentionCount: 0, sessionCount: 2 })
+    expect(def.lastActive).toBe(300)
+
+    // s4 sits in BOTH sets (turn running while blocked on input): needs-input
+    // wins, same precedence as deriveProfileActivity / the rail badge — so it
+    // counts once, under attention, never inflating working.
+    expect(coder).toMatchObject({ isDefault: false, workingCount: 1, attentionCount: 1, sessionCount: 2 })
+    expect(coder.lastActive).toBe(900)
+
+    // last_active 0 falls back to started_at.
+    expect(writer).toMatchObject({ workingCount: 0, attentionCount: 1, sessionCount: 1, lastActive: 40 })
+
+    // A profile with no sessions still gets a (zeroed) row.
+    expect(idle).toMatchObject({ workingCount: 0, attentionCount: 0, sessionCount: 0, lastActive: null })
+  })
+
+  it('prefers aggregator profile totals over the loaded count', () => {
+    const rows = buildProfileOverviewRows({
+      sessions: [session('s1', 'coder')],
+      profiles: [profile('default', true), profile('coder')],
+      profileOrder: [],
+      workingIds: [],
+      attentionIds: [],
+      profileTotals: { coder: 42, default: 7 }
+    })
+
+    expect(rows.find(row => row.key === 'coder')?.sessionCount).toBe(42)
+    expect(rows.find(row => row.key === 'default')?.sessionCount).toBe(7)
+  })
+
+  it('appends session-only profiles the profile list does not know yet', () => {
+    const rows = buildProfileOverviewRows({
+      sessions: [session('s1', 'zeta'), session('s2', 'alpha')],
+      profiles: [profile('default', true)],
+      profileOrder: [],
+      workingIds: ['s1'],
+      attentionIds: [],
+      profileTotals: {}
+    })
+
+    expect(rows.map(row => row.key)).toEqual(['default', 'alpha', 'zeta'])
+    expect(rows.find(row => row.key === 'zeta')?.workingCount).toBe(1)
+  })
+
+  it('always yields a default row even with an empty profile list', () => {
+    const rows = buildProfileOverviewRows({
+      sessions: [],
+      profiles: [],
+      profileOrder: [],
+      workingIds: [],
+      attentionIds: [],
+      profileTotals: {}
+    })
+
+    expect(rows).toEqual([
+      {
+        key: 'default',
+        isDefault: true,
+        workingCount: 0,
+        attentionCount: 0,
+        sessionCount: 0,
+        lastActive: null
+      }
+    ])
+  })
+})
+
+describe('summarizeKanbanBoard', () => {
+  it('zero-fills per-status counts in canonical column order', () => {
+    const summary = summarizeKanbanBoard(
+      board({ todo: [card('a', 'todo'), card('b', 'todo')], done: [card('c', 'done')] })
+    )
+
+    expect(summary.counts.map(entry => entry.name)).toEqual([...KANBAN_COLUMNS])
+    expect(summary.counts.find(entry => entry.name === 'todo')?.count).toBe(2)
+    expect(summary.counts.find(entry => entry.name === 'triage')?.count).toBe(0)
+    expect(summary.total).toBe(3)
+  })
+
+  it('ranks hot cards review-first, then priority desc, then oldest, capped', () => {
+    const summary = summarizeKanbanBoard(
+      board({
+        review: [
+          card('r_low', 'review', { priority: 0, created_at: 5 }),
+          card('r_high', 'review', { priority: 2, created_at: 9 })
+        ],
+        blocked: [
+          card('b_old', 'blocked', { priority: 1, created_at: 1 }),
+          card('b_new', 'blocked', { priority: 1, created_at: 8 }),
+          card('b_zero', 'blocked', { priority: 0, created_at: 2 })
+        ]
+      }),
+      4
+    )
+
+    expect(summary.hotCards.map(entry => entry.id)).toEqual(['r_high', 'r_low', 'b_old', 'b_new'])
+  })
+
+  it('returns no hot cards for an empty board', () => {
+    expect(summarizeKanbanBoard(board({})).hotCards).toEqual([])
+  })
+})
diff --git a/apps/desktop/src/app/command-center/overview-data.ts b/apps/desktop/src/app/command-center/overview-data.ts
new file mode 100644
index 0000000000000..f5b27eb59425d
--- /dev/null
+++ b/apps/desktop/src/app/command-center/overview-data.ts
@@ -0,0 +1,145 @@
+// Pure derivations for the command center's cross-profile "All profiles"
+// overview. Everything here folds ALREADY-FETCHED store state ($sessions +
+// working/attention sets + the kanban board atom) into render-ready rows —
+// no fetching, no sockets, so the overview stays REST-only by construction.
+
+import { KANBAN_COLUMNS, type KanbanColumnName } from '@/store/kanban'
+import { normalizeProfileKey, sortByProfileOrder } from '@/store/profile'
+import type { ProfileInfo, SessionInfo } from '@/types/hermes'
+import type { KanbanBoardPayload, KanbanCard } from '@/types/kanban'
+
+export interface ProfileOverviewRow {
+  /** Normalized profile key (see {@link normalizeProfileKey}). */
+  key: string
+  isDefault: boolean
+  /** Sessions of this profile currently streaming a turn. */
+  workingCount: number
+  /** Sessions of this profile blocked on user input. */
+  attentionCount: number
+  /** Listable conversation total when the aggregator reported one, else the
+   *  loaded in-memory count (same fallback the sidebar uses). */
+  sessionCount: number
+  /** Most recent activity across the profile's loaded sessions (epoch secs). */
+  lastActive: null | number
+}
+
+export interface ProfileOverviewInput {
+  sessions: SessionInfo[]
+  profiles: ProfileInfo[]
+  /** Rail drag order — rows mirror the rail so the overview reads spatially. */
+  profileOrder: string[]
+  workingIds: readonly string[]
+  attentionIds: readonly string[]
+  /** Per-profile totals from /api/profiles/sessions (may be empty). */
+  profileTotals: Record<string, number>
+}
+
+interface Bucket {
+  attention: number
+  count: number
+  lastActive: number
+  working: number
+}
+
+/** One row per profile, in rail order (default first, then named profiles in
+ *  the user's drag order). Profiles that only appear on session rows (e.g. the
+ *  profile list hasn't refreshed yet) still get a row, appended alphabetically,
+ *  so activity is never silently dropped. */
+export function buildProfileOverviewRows(input: ProfileOverviewInput): ProfileOverviewRow[] {
+  const workingSet = new Set(input.workingIds)
+  const attentionSet = new Set(input.attentionIds)
+
+  const buckets = new Map<string, Bucket>()
+
+  const ensure = (key: string): Bucket => {
+    let bucket = buckets.get(key)
+
+    if (!bucket) {
+      bucket = { attention: 0, count: 0, lastActive: 0, working: 0 }
+      buckets.set(key, bucket)
+    }
+
+    return bucket
+  }
+
+  for (const session of input.sessions) {
+    const bucket = ensure(normalizeProfileKey(session.profile))
+
+    bucket.count += 1
+
+    // Same id semantics as the sidebar row indicators: working/attention sets
+    // hold live stored ids, which is what the aggregated list surfaces. A
+    // session can be in BOTH sets (turn running AND blocked on input) — mirror
+    // deriveProfileActivity's precedence so the rail badge and this overview
+    // never disagree: needs-input wins, the session counts in one bucket only.
+    if (attentionSet.has(session.id)) {
+      bucket.attention += 1
+    } else if (workingSet.has(session.id)) {
+      bucket.working += 1
+    }
+
+    const timestamp = session.last_active || session.started_at || 0
+
+    if (timestamp > bucket.lastActive) {
+      bucket.lastActive = timestamp
+    }
+  }
+
+  const defaultProfile = input.profiles.find(profile => profile.is_default)
+  const defaultKey = defaultProfile ? normalizeProfileKey(defaultProfile.name) : 'default'
+
+  const namedKeys = sortByProfileOrder(
+    input.profiles.filter(profile => !profile.is_default),
+    input.profileOrder
+  ).map(profile => normalizeProfileKey(profile.name))
+
+  const orderedKeys = [defaultKey, ...namedKeys.filter(key => key !== defaultKey)]
+  const known = new Set(orderedKeys)
+
+  // Session-only profiles (aggregator knows them, the profile list doesn't yet).
+  const extras = [...buckets.keys()].filter(key => !known.has(key)).sort((a, b) => a.localeCompare(b))
+
+  return [...orderedKeys, ...extras].map(key => {
+    const bucket = buckets.get(key)
+
+    return {
+      key,
+      isDefault: key === defaultKey,
+      workingCount: bucket?.working ?? 0,
+      attentionCount: bucket?.attention ?? 0,
+      sessionCount: input.profileTotals[key] ?? bucket?.count ?? 0,
+      lastActive: bucket?.lastActive ? bucket.lastActive : null
+    }
+  })
+}
+
+export interface KanbanBoardSummary {
+  /** Per-status counts in canonical column order (zero-filled). */
+  counts: Array<{ count: number; name: KanbanColumnName }>
+  total: number
+  /** Cards waiting on a human — review first, then blocked, highest priority
+   *  first, oldest first within a priority. Capped for chip rendering. */
+  hotCards: KanbanCard[]
+}
+
+const HOT_STATUS_RANK: Record<string, number> = { review: 0, blocked: 1 }
+
+export function summarizeKanbanBoard(board: KanbanBoardPayload, maxHotCards = 5): KanbanBoardSummary {
+  const tasksByColumn = new Map(board.columns.map(column => [column.name, column.tasks]))
+
+  const counts = KANBAN_COLUMNS.map(name => ({
+    count: tasksByColumn.get(name)?.length ?? 0,
+    name
+  }))
+
+  const total = board.columns.reduce((acc, column) => acc + column.tasks.length, 0)
+
+  const hotCards = [...(tasksByColumn.get('review') ?? []), ...(tasksByColumn.get('blocked') ?? [])].sort(
+    (a, b) =>
+      (HOT_STATUS_RANK[a.status] ?? 2) - (HOT_STATUS_RANK[b.status] ?? 2) ||
+      b.priority - a.priority ||
+      a.created_at - b.created_at
+  )
+
+  return { counts, total, hotCards: hotCards.slice(0, maxHotCards) }
+}
diff --git a/apps/desktop/src/app/command-center/overview.test.tsx b/apps/desktop/src/app/command-center/overview.test.tsx
new file mode 100644
index 0000000000000..a372959f24c21
--- /dev/null
+++ b/apps/desktop/src/app/command-center/overview.test.tsx
@@ -0,0 +1,261 @@
+// @vitest-environment jsdom
+import { cleanup, render, screen, waitFor } from '@testing-library/react'
+import { atom } from 'nanostores'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ProfileInfo, SessionInfo } from '@/types/hermes'
+import type { KanbanBoardPayload, KanbanCard } from '@/types/kanban'
+
+// Keep store/profile's side-effecting imports inert: the gateway socket layer
+// and the REST query client must not run for real (same idiom as
+// store/profile.test.ts).
+const ensureGatewayForProfile = vi.fn(async () => undefined)
+const $gateway = atom<unknown>({ id: 'live-socket' })
+
+vi.mock('@/store/gateway', () => ({ $gateway, ensureGatewayForProfile }))
+vi.mock('@/hermes', () => ({
+  getProfiles: vi.fn(async () => ({
+    profiles: [
+      {
+        has_env: false,
+        is_default: true,
+        model: null,
+        name: 'default',
+        path: '/tmp/h/default',
+        provider: null,
+        skill_count: 0
+      },
+      {
+        has_env: false,
+        is_default: false,
+        model: null,
+        name: 'coder',
+        path: '/tmp/h/coder',
+        provider: null,
+        skill_count: 0
+      }
+    ]
+  })),
+  setApiRequestProfile: vi.fn()
+}))
+vi.mock('@/lib/query-client', () => ({ queryClient: { invalidateQueries: vi.fn() } }))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
+const { OverviewPanel } = await import('./overview')
+
+const {
+  $kanbanActiveBoard,
+  $kanbanBoard,
+  $kanbanBoardError,
+  $kanbanRefreshing,
+  $kanbanSelectedTaskId,
+  KANBAN_COLUMNS
+} = await import('@/store/kanban')
+
+const { $activeGatewayProfile, $newChatProfile, $profileOrder, $profiles, $showAllProfiles } =
+  await import('@/store/profile')
+
+const { $attentionSessionIds, $sessionProfileTotals, $sessions, $workingSessionIds } = await import('@/store/session')
+
+function session(id: string, profile: string | undefined, extra: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    ended_at: null,
+    id,
+    input_tokens: 0,
+    is_active: true,
+    last_active: Math.floor(Date.now() / 1000),
+    message_count: 1,
+    model: null,
+    output_tokens: 0,
+    preview: null,
+    profile,
+    source: null,
+    started_at: 50,
+    title: null,
+    tool_call_count: 0,
+    ...extra
+  }
+}
+
+function card(id: string, title: string, status: string, extra: Partial<KanbanCard> = {}): KanbanCard {
+  return {
+    id,
+    title,
+    body: null,
+    assignee: null,
+    status,
+    priority: 0,
+    created_by: null,
+    created_at: 1,
+    started_at: null,
+    completed_at: null,
+    workspace_kind: 'scratch',
+    workspace_path: null,
+    claim_lock: null,
+    claim_expires: null,
+    tenant: null,
+    ...extra
+  }
+}
+
+const boardPayload: KanbanBoardPayload = {
+  columns: KANBAN_COLUMNS.map(name => ({
+    name,
+    tasks:
+      name === 'review'
+        ? [card('t_rev', 'Ship the login fix', 'review')]
+        : name === 'todo'
+          ? [card('t_todo', 'Backlog item', 'todo')]
+          : []
+  })),
+  tenants: [],
+  assignees: [],
+  latest_event_id: 7,
+  now: 1000
+}
+
+const profiles: ProfileInfo[] = [
+  {
+    has_env: false,
+    is_default: true,
+    model: null,
+    name: 'default',
+    path: '/tmp/h/default',
+    provider: null,
+    skill_count: 0
+  },
+  {
+    has_env: false,
+    is_default: false,
+    model: null,
+    name: 'coder',
+    path: '/tmp/h/coder',
+    provider: null,
+    skill_count: 0
+  }
+]
+
+describe('OverviewPanel', () => {
+  let api: ReturnType<typeof vi.fn>
+  let boardFails: boolean
+
+  beforeEach(() => {
+    boardFails = false
+    api = vi.fn(async (request: { path: string }) => {
+      if (request.path.startsWith('/api/plugins/kanban/boards')) {
+        if (boardFails) {
+          throw new Error('404: {"detail":"Not Found"}')
+        }
+
+        return {
+          boards: [{ slug: 'default', name: 'Default', description: '', icon: '', color: '', is_current: true }]
+        }
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/board')) {
+        if (boardFails) {
+          throw new Error('404: {"detail":"Not Found"}')
+        }
+
+        return boardPayload
+      }
+
+      throw new Error(`unexpected path ${request.path}`)
+    })
+    Object.defineProperty(window, 'hermesDesktop', { configurable: true, value: { api } })
+    window.localStorage.clear()
+
+    $sessions.set([
+      session('s_def', 'default'),
+      session('s_work', 'coder'),
+      session('s_ask', 'coder', { last_active: Math.floor(Date.now() / 1000) - 60 })
+    ])
+    $workingSessionIds.set(['s_work'])
+    $attentionSessionIds.set(['s_ask'])
+    $sessionProfileTotals.set({ coder: 12, default: 3 })
+    $profiles.set(profiles)
+    $profileOrder.set([])
+    $activeGatewayProfile.set('default')
+    $showAllProfiles.set(false)
+    $newChatProfile.set(null)
+
+    $kanbanActiveBoard.set(null)
+    $kanbanBoard.set(null)
+    $kanbanBoardError.set(null)
+    $kanbanRefreshing.set(false)
+    $kanbanSelectedTaskId.set(null)
+
+    ensureGatewayForProfile.mockClear()
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+    Reflect.deleteProperty(window, 'hermesDesktop')
+  })
+
+  it('renders one activity row per profile with working/attention badges', async () => {
+    render(<OverviewPanel onClose={() => undefined} />)
+
+    expect(await screen.findByText('default')).toBeTruthy()
+    expect(screen.getByText('coder')).toBeTruthy()
+
+    // coder: one working, one needing input; default: idle.
+    expect(screen.getByText('1 working')).toBeTruthy()
+    expect(screen.getByText('1 needs input')).toBeTruthy()
+    expect(screen.getByText('Idle')).toBeTruthy()
+
+    // Aggregator totals win over the loaded count.
+    expect(screen.getByText(/12 sessions/)).toBeTruthy()
+    expect(screen.getByText(/3 sessions/)).toBeTruthy()
+
+    // The active profile is badged and has no switch button.
+    expect(screen.getByText('Current')).toBeTruthy()
+    expect(screen.getAllByRole('button', { name: 'Switch to coder' })).toHaveLength(1)
+    expect(screen.queryByRole('button', { name: 'Switch to default' })).toBeNull()
+  })
+
+  it('quick-switches profiles via selectProfile and closes the panel', async () => {
+    const onClose = vi.fn()
+
+    render(<OverviewPanel onClose={onClose} />)
+
+    const switchButton = await screen.findByRole('button', { name: 'Switch to coder' })
+
+    switchButton.click()
+
+    expect(onClose).toHaveBeenCalledTimes(1)
+    expect($newChatProfile.get()).toBe('coder')
+    await waitFor(() => expect(ensureGatewayForProfile).toHaveBeenCalledWith('coder'))
+  })
+
+  it('shows the kanban summary strip and opens a hot card on the board', async () => {
+    const onNavigateRoute = vi.fn()
+
+    render(<OverviewPanel onClose={() => undefined} onNavigateRoute={onNavigateRoute} />)
+
+    const chip = await screen.findByRole('button', { name: 'Open "Ship the login fix" on the kanban board' })
+
+    // Column counts from the mocked payload (1 todo; 'Review' also appears on
+    // the chip's status label, hence getAllByText).
+    expect(screen.getByText('Todo')).toBeTruthy()
+    expect(screen.getAllByText('Review').length).toBeGreaterThanOrEqual(1)
+
+    chip.click()
+
+    expect($kanbanSelectedTaskId.get()).toBe('t_rev')
+    expect(onNavigateRoute).toHaveBeenCalledWith('/kanban')
+  })
+
+  it('falls back gracefully when the kanban API is unavailable', async () => {
+    boardFails = true
+
+    render(<OverviewPanel onClose={() => undefined} />)
+
+    expect(await screen.findByText('Kanban is not available on this backend.')).toBeTruthy()
+
+    // Profile rows still render — the overview degrades, it does not error out.
+    expect(screen.getByText('coder')).toBeTruthy()
+    expect(screen.queryByText('Open board')).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/app/command-center/overview.tsx b/apps/desktop/src/app/command-center/overview.tsx
new file mode 100644
index 0000000000000..426c992e865f0
--- /dev/null
+++ b/apps/desktop/src/app/command-center/overview.tsx
@@ -0,0 +1,259 @@
+import { useStore } from '@nanostores/react'
+import { useEffect, useMemo } from 'react'
+
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { useI18n } from '@/i18n'
+import { Kanban, Loader2, MessageQuestion } from '@/lib/icons'
+import { profileColorSoft, resolveProfileColor } from '@/lib/profile-color'
+import { relativeTime } from '@/lib/time'
+import { cn } from '@/lib/utils'
+import {
+  $kanbanBoard,
+  $kanbanBoardError,
+  refreshKanbanBoard,
+  refreshKanbanBoards,
+  setKanbanSelectedTaskId
+} from '@/store/kanban'
+import {
+  $activeGatewayProfile,
+  $profileColors,
+  $profileOrder,
+  $profiles,
+  normalizeProfileKey,
+  refreshProfiles,
+  selectProfile
+} from '@/store/profile'
+import { $attentionSessionIds, $sessionProfileTotals, $sessions, $workingSessionIds } from '@/store/session'
+
+import { useRefreshHotkey } from '../hooks/use-refresh-hotkey'
+import { KANBAN_ROUTE } from '../routes'
+
+import { buildProfileOverviewRows, summarizeKanbanBoard } from './overview-data'
+
+interface OverviewPanelProps {
+  onClose: () => void
+  onNavigateRoute?: (path: string) => void
+}
+
+// Chip tones ride the ui-kit Badge variants (destructive/warn) so they stay in
+// sync with every other status badge; only the hover shade is local.
+const HOT_CHIP: Record<string, { hover: string; variant: 'destructive' | 'warn' }> = {
+  blocked: { hover: 'hover:bg-destructive/20', variant: 'destructive' },
+  review: { hover: 'hover:bg-amber-500/20', variant: 'warn' }
+}
+
+/** Cross-profile landing section: one activity row per profile (working /
+ *  needs-input counts, last activity, quick switch) plus a summary strip for
+ *  the shared kanban board. All session data folds from the already-fetched
+ *  cross-profile aggregation — no extra sockets, kanban via its REST poller. */
+export function OverviewPanel({ onClose, onNavigateRoute }: OverviewPanelProps) {
+  const { t } = useI18n()
+  const ov = t.commandCenterOverview
+  const k = t.kanban
+
+  const sessions = useStore($sessions)
+  const profiles = useStore($profiles)
+  const profileOrder = useStore($profileOrder)
+  const profileColors = useStore($profileColors)
+  const workingIds = useStore($workingSessionIds)
+  const attentionIds = useStore($attentionSessionIds)
+  const profileTotals = useStore($sessionProfileTotals)
+  const activeGatewayProfile = useStore($activeGatewayProfile)
+
+  const board = useStore($kanbanBoard)
+  const boardError = useStore($kanbanBoardError)
+
+  const refresh = () => {
+    void refreshProfiles().catch(() => undefined)
+    void refreshKanbanBoards()
+    void refreshKanbanBoard()
+  }
+
+  // Refresh on mount: the session aggregation is already live in the stores,
+  // so only the profile list and the kanban board need a poke.
+  useEffect(refresh, [])
+
+  useRefreshHotkey(refresh)
+
+  const rows = useMemo(
+    () =>
+      buildProfileOverviewRows({
+        sessions,
+        profiles,
+        profileOrder,
+        workingIds,
+        attentionIds,
+        profileTotals
+      }),
+    [attentionIds, profileOrder, profileTotals, profiles, sessions, workingIds]
+  )
+
+  const summary = useMemo(() => (board ? summarizeKanbanBoard(board) : null), [board])
+
+  const activeKey = normalizeProfileKey(activeGatewayProfile)
+
+  // Older backends without the kanban plugin 404 the board route; the overview
+  // stays useful as a profiles-only view instead of erroring the whole panel.
+  const kanbanUnavailable = !board && Boolean(boardError)
+
+  const switchToProfile = (key: string) => {
+    selectProfile(key)
+    onClose()
+  }
+
+  const openKanban = (taskId?: string) => {
+    setKanbanSelectedTaskId(taskId ?? null)
+    onNavigateRoute?.(KANBAN_ROUTE)
+  }
+
+  return (
+    <div className="flex min-h-0 flex-1 flex-col gap-6 overflow-y-auto pb-2">
+      <section>
+        <div className="mb-1.5 text-[0.625rem] font-medium uppercase tracking-[0.08em] text-(--ui-text-tertiary)">
+          {ov.sectionLabel}
+        </div>
+        <ul>
+          {rows.map(row => {
+            const color = resolveProfileColor(row.isDefault ? null : row.key, profileColors)
+            const active = row.key === activeKey
+            const busy = row.workingCount > 0 || row.attentionCount > 0
+
+            return (
+              <li className="flex items-center gap-3 border-b border-(--ui-stroke-tertiary)/50 py-2.5" key={row.key}>
+                <span
+                  aria-hidden
+                  className="size-2.5 shrink-0 rounded-full"
+                  style={{
+                    backgroundColor: color ?? 'var(--ui-text-tertiary)',
+                    boxShadow: color ? `0 0 0 3px ${profileColorSoft(color, 18)}` : undefined
+                  }}
+                />
+                <div className="min-w-0 flex-1">
+                  <div className="flex items-center gap-2">
+                    <span className="truncate text-[length:var(--conversation-text-font-size)] font-medium text-foreground">
+                      {row.key}
+                    </span>
+                    {active && (
+                      <span className="shrink-0 rounded bg-(--chrome-action-hover) px-1.5 py-px text-[0.6rem] font-medium uppercase tracking-[0.08em] text-(--ui-text-tertiary)">
+                        {ov.currentBadge}
+                      </span>
+                    )}
+                  </div>
+                  <div className="truncate text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+                    {ov.sessions(row.sessionCount)}
+                    {' · '}
+                    {row.lastActive ? relativeTime(row.lastActive * 1000) : ov.noActivity}
+                  </div>
+                </div>
+
+                <div className="flex shrink-0 items-center gap-3 text-[length:var(--conversation-caption-font-size)]">
+                  {row.workingCount > 0 && (
+                    <span className="inline-flex items-center gap-1 text-(--dt-primary)">
+                      <Loader2 aria-hidden className="size-3 animate-spin" />
+                      {ov.working(row.workingCount)}
+                    </span>
+                  )}
+                  {row.attentionCount > 0 && (
+                    <span className="inline-flex items-center gap-1 text-amber-600 dark:text-amber-300">
+                      <MessageQuestion aria-hidden className="size-3.5" />
+                      {ov.attention(row.attentionCount)}
+                    </span>
+                  )}
+                  {!busy && <span className="text-(--ui-text-tertiary)">{ov.idle}</span>}
+                </div>
+
+                {!active && (
+                  <Button
+                    aria-label={t.profiles.switchToProfile(row.key)}
+                    className="shrink-0"
+                    onClick={() => switchToProfile(row.key)}
+                    size="xs"
+                    title={t.profiles.switchToProfile(row.key)}
+                    type="button"
+                    variant="text"
+                  >
+                    {ov.switch}
+                  </Button>
+                )}
+              </li>
+            )
+          })}
+        </ul>
+      </section>
+
+      <section>
+        <div className="mb-1.5 flex items-center justify-between gap-3">
+          <span className="inline-flex items-center gap-1.5 text-[0.625rem] font-medium uppercase tracking-[0.08em] text-(--ui-text-tertiary)">
+            <Kanban aria-hidden className="size-3.5" />
+            {k.title}
+          </span>
+          {!kanbanUnavailable && (
+            <Button onClick={() => openKanban()} size="xs" type="button" variant="text">
+              {ov.openBoard}
+            </Button>
+          )}
+        </div>
+
+        {kanbanUnavailable ? (
+          <div className="text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+            {ov.kanbanUnavailable}
+          </div>
+        ) : !summary ? (
+          <div className="text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+            {k.loading}
+          </div>
+        ) : (
+          <>
+            <div className="flex flex-wrap gap-x-4 gap-y-1.5">
+              {summary.counts.map(entry => (
+                <span
+                  className={cn(
+                    'inline-flex items-baseline gap-1.5 text-[length:var(--conversation-caption-font-size)]',
+                    entry.count === 0 ? 'text-(--ui-text-tertiary)/60' : 'text-foreground'
+                  )}
+                  key={entry.name}
+                >
+                  <span className="font-semibold tabular-nums">{entry.count}</span>
+                  <span className="text-(--ui-text-tertiary)">{k.columnLabels[entry.name] ?? entry.name}</span>
+                </span>
+              ))}
+            </div>
+
+            <div className="mt-3 flex flex-wrap gap-1.5">
+              {summary.hotCards.length === 0 ? (
+                <span className="text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+                  {ov.noHotCards}
+                </span>
+              ) : (
+                summary.hotCards.map(card => {
+                  const tone = HOT_CHIP[card.status]
+
+                  return (
+                    <Badge asChild key={card.id} variant={tone?.variant}>
+                      <button
+                        aria-label={ov.openCard(card.title)}
+                        className={cn(
+                          'max-w-64 gap-1.5 rounded-full px-2.5 py-1 text-[length:var(--conversation-caption-font-size)] transition-colors',
+                          tone ? tone.hover : 'bg-(--chrome-action-hover) text-foreground'
+                        )}
+                        onClick={() => openKanban(card.id)}
+                        title={card.title}
+                        type="button"
+                      >
+                        <span className="shrink-0 text-[0.6rem] font-medium uppercase tracking-[0.06em]">
+                          {k.columnLabels[card.status] ?? card.status}
+                        </span>
+                        <span className="truncate">{card.title}</span>
+                      </button>
+                    </Badge>
+                  )
+                })
+              )}
+            </div>
+          </>
+        )}
+      </section>
+    </div>
+  )
+}
diff --git a/apps/desktop/src/app/command-palette/index.tsx b/apps/desktop/src/app/command-palette/index.tsx
index 859c3ae11d2c3..2d6496e514328 100644
--- a/apps/desktop/src/app/command-palette/index.tsx
+++ b/apps/desktop/src/app/command-palette/index.tsx
@@ -57,6 +57,7 @@ import {
 } from '@/store/command-palette'
 import { $bindings } from '@/store/keybinds'
 import { openPetGenerate } from '@/store/pet-generate'
+import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import { requestStartWorkSession } from '@/store/projects'
 import { runGatewayRestart } from '@/store/system-actions'
 import { applyBackendUpdate } from '@/store/updates'
@@ -303,8 +304,12 @@ export function CommandPalette() {
 
   // Server-backed sources for the type-to-search groups, fetched lazily while
   // the palette is open. react-query handles caching/dedup/staleness.
+  // Config is profile-scoped (the sessions/archived lists below are cross-
+  // profile aggregates, so they stay unscoped).
+  const paletteProfile = normalizeProfileKey(useStore($activeGatewayProfile))
+
   const configQuery = useQuery({
-    queryKey: ['command-palette', 'config'],
+    queryKey: ['command-palette', 'config', paletteProfile],
     queryFn: getHermesConfigRecord,
     enabled: open
   })
diff --git a/apps/desktop/src/app/desktop-controller-utils.test.ts b/apps/desktop/src/app/desktop-controller-utils.test.ts
index ac39395db09ec..851ce9da7055d 100644
--- a/apps/desktop/src/app/desktop-controller-utils.test.ts
+++ b/apps/desktop/src/app/desktop-controller-utils.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import type { SessionInfo } from '@/hermes'
 
-import { sameCronSignature } from './desktop-controller-utils'
+import { profileRestoreSuperseded, sameCronSignature } from './desktop-controller-utils'
 
 const session = (id: string, title: string | null): SessionInfo => ({ id, title }) as SessionInfo
 
@@ -29,3 +29,69 @@ describe('sameCronSignature', () => {
     expect(sameCronSignature(a, b)).toBe(false)
   })
 })
+
+describe('profileRestoreSuperseded', () => {
+  it('does NOT abort for the pre-switch leftover selection (switch away from an open session)', () => {
+    // Switching A → B while viewing one of A's sessions: A's id still sits in
+    // the selection when the probe starts AND when it resolves. The probe must
+    // proceed so B's unlisted/deleted memo gets restored or forgotten.
+    expect(
+      profileRestoreSuperseded({
+        currentToken: 3,
+        requestToken: 3,
+        selectedAtRequest: 'a-open-session',
+        selectedNow: 'a-open-session'
+      })
+    ).toBe(false)
+  })
+
+  it('proceeds when nothing was selected before or during the probe', () => {
+    expect(
+      profileRestoreSuperseded({ currentToken: 1, requestToken: 1, selectedAtRequest: null, selectedNow: null })
+    ).toBe(false)
+  })
+
+  it('aborts when the user opened a chat while probing', () => {
+    expect(
+      profileRestoreSuperseded({
+        currentToken: 3,
+        requestToken: 3,
+        selectedAtRequest: null,
+        selectedNow: 'user-opened-this'
+      })
+    ).toBe(true)
+  })
+
+  it('aborts when the selection changed to a different session while probing', () => {
+    expect(
+      profileRestoreSuperseded({
+        currentToken: 3,
+        requestToken: 3,
+        selectedAtRequest: 'a-open-session',
+        selectedNow: 'newer-session'
+      })
+    ).toBe(true)
+  })
+
+  it('aborts when the selection was cleared (fresh draft) while probing', () => {
+    expect(
+      profileRestoreSuperseded({
+        currentToken: 3,
+        requestToken: 3,
+        selectedAtRequest: 'a-open-session',
+        selectedNow: null
+      })
+    ).toBe(true)
+  })
+
+  it('aborts when a newer switch bumped the token', () => {
+    expect(
+      profileRestoreSuperseded({
+        currentToken: 4,
+        requestToken: 3,
+        selectedAtRequest: 'a-open-session',
+        selectedNow: 'a-open-session'
+      })
+    ).toBe(true)
+  })
+})
diff --git a/apps/desktop/src/app/desktop-controller-utils.ts b/apps/desktop/src/app/desktop-controller-utils.ts
index 5754d69ef81a6..53b15f701b0ca 100644
--- a/apps/desktop/src/app/desktop-controller-utils.ts
+++ b/apps/desktop/src/app/desktop-controller-utils.ts
@@ -1,5 +1,20 @@
 import type { SessionInfo } from '@/hermes'
 
+/** Whether an in-flight profile-restore probe has been superseded and must not
+ *  navigate. True when a newer switch bumped the token, or when the SELECTION
+ *  CHANGED while probing (the user actively opened a chat / started a resume).
+ *  The pre-switch profile's still-open session legitimately sits in
+ *  $selectedStoredSessionId when the switch fires, so an unchanged leftover
+ *  selection must NOT abort the restore — only a change does. */
+export function profileRestoreSuperseded(args: {
+  currentToken: number
+  requestToken: number
+  selectedAtRequest: null | string
+  selectedNow: null | string
+}): boolean {
+  return args.currentToken !== args.requestToken || args.selectedNow !== args.selectedAtRequest
+}
+
 // Cheap signature compare so a poll only swaps the atom (and re-renders the
 // sidebar) when the visible rows actually changed.
 export function sameCronSignature(a: SessionInfo[], b: SessionInfo[]): boolean {
diff --git a/apps/desktop/src/app/desktop-controller.tsx b/apps/desktop/src/app/desktop-controller.tsx
index 559559e32ce0c..0e7756b9d8078 100644
--- a/apps/desktop/src/app/desktop-controller.tsx
+++ b/apps/desktop/src/app/desktop-controller.tsx
@@ -46,7 +46,19 @@ import {
   setPetOverlaySubmitHandler
 } from '../store/pet-overlay'
 import { $filePreviewTarget, $previewTarget, closeActiveRightRailTab } from '../store/preview'
-import { $activeGatewayProfile, $freshSessionRequest, $profileScope, refreshActiveProfile } from '../store/profile'
+import {
+  $activeGatewayProfile,
+  $freshSessionRequest,
+  $profileRestoreRequest,
+  $profileScope,
+  activeProfileQueryKey,
+  forgetProfileSession,
+  forgetSessionMemo,
+  isSessionListed,
+  refreshActiveProfile,
+  rememberedProfileSession,
+  rememberProfileSession
+} from '../store/profile'
 import { $startWorkSessionRequest, followActiveSessionCwd, resolveNewSessionCwd } from '../store/projects'
 import { $reviewOpen, REVIEW_PANE_ID } from '../store/review'
 import {
@@ -88,6 +100,7 @@ import {
 } from './chat/right-rail'
 import { ChatSidebar } from './chat/sidebar'
 import { CommandPalette } from './command-palette'
+import { profileRestoreSuperseded } from './desktop-controller-utils'
 import { useGatewayBoot } from './gateway/hooks/use-gateway-boot'
 import { useGatewayRequest } from './gateway/hooks/use-gateway-request'
 import { useReconnectReconciliation } from './gateway/hooks/use-reconnect-reconciliation'
@@ -116,6 +129,7 @@ import { usePreviewRouting } from './session/hooks/use-preview-routing'
 import { usePromptActions } from './session/hooks/use-prompt-actions'
 import { useRouteResume } from './session/hooks/use-route-resume'
 import { useSessionActions } from './session/hooks/use-session-actions'
+import { resolveStoredSession } from './session/hooks/use-session-actions/utils'
 import { useSessionListActions } from './session/hooks/use-session-list-actions'
 import { useSessionStateCache } from './session/hooks/use-session-state-cache'
 import { AppShell } from './shell/app-shell'
@@ -273,10 +287,13 @@ export function DesktopController() {
     }
   }, [])
 
-  // Remember the open chat so a relaunch reopens it instead of an empty new-chat.
+  // Remember the open chat so a relaunch reopens it instead of an empty
+  // new-chat — globally (relaunch) AND per owning profile, so switching back
+  // to a profile restores the conversation you left it on.
   useEffect(() => {
     if (routedSessionId) {
       setRememberedSessionId(routedSessionId)
+      rememberProfileSession(routedSessionId)
     }
   }, [routedSessionId])
 
@@ -298,9 +315,17 @@ export function DesktopController() {
   }, [location.pathname, navigate])
 
   useEffect(() => {
-    if (resumeExhaustedSessionId && getRememberedSessionId() === resumeExhaustedSessionId) {
+    if (!resumeExhaustedSessionId) {
+      return
+    }
+
+    if (getRememberedSessionId() === resumeExhaustedSessionId) {
       setRememberedSessionId(null)
     }
+
+    // A terminally-unresumable session must not be re-attempted by the next
+    // profile switch either.
+    forgetSessionMemo(resumeExhaustedSessionId)
   }, [resumeExhaustedSessionId])
 
   // Notification click: the main process already focused the window; jump to its
@@ -655,6 +680,69 @@ export function DesktopController() {
     startFreshSessionDraft()
   }, [freshSessionRequest, startFreshSessionDraft])
 
+  // A profile switch restores that profile's remembered last session (or the
+  // explicit target of a rail-badge click) instead of always dropping to a
+  // blank draft — so hopping A → B → A lands back in each profile's context.
+  // Existence is checked against the already-fetched cross-profile list first;
+  // only an unlisted id pays for the by-id REST probe (resolveStoredSession).
+  // Deleted/archived memo → clear it and fall back to a fresh draft. The token
+  // ref makes a rapid second switch supersede an in-flight probe, so a stale
+  // restore can never navigate over a newer one.
+  const profileRestoreRequest = useStore($profileRestoreRequest)
+  const lastProfileRestoreTokenRef = useRef(0)
+
+  useEffect(() => {
+    const request = profileRestoreRequest
+
+    if (!request || request.token === lastProfileRestoreTokenRef.current) {
+      return
+    }
+
+    lastProfileRestoreTokenRef.current = request.token
+    const remembered = request.sessionId ?? rememberedProfileSession(request.profile)
+
+    if (!remembered) {
+      startFreshSessionDraft()
+
+      return
+    }
+
+    if (isSessionListed($sessions.get(), remembered)) {
+      navigate(sessionRoute(remembered))
+
+      return
+    }
+
+    // Snapshot the selection as of the switch — the pre-switch profile's open
+    // session legitimately still sits in $selectedStoredSessionId here, so only
+    // a CHANGE during the probe means the user actively opened something newer.
+    const selectedAtRequest = $selectedStoredSessionId.get()
+
+    void (async () => {
+      const row = await resolveStoredSession(remembered).catch(() => undefined)
+
+      // Superseded while probing (another switch, or the user opened a chat /
+      // started a resume themselves) → never restore over the newer context.
+      if (
+        profileRestoreSuperseded({
+          currentToken: lastProfileRestoreTokenRef.current,
+          requestToken: request.token,
+          selectedAtRequest,
+          selectedNow: $selectedStoredSessionId.get()
+        })
+      ) {
+        return
+      }
+
+      if (row && !row.archived) {
+        navigate(sessionRoute(remembered))
+      } else {
+        forgetProfileSession(request.profile)
+        startFreshSessionDraft()
+      }
+    })()
+  }, [navigate, profileRestoreRequest, startFreshSessionDraft])
+
   // Swapping the live gateway to another profile must re-pull that profile's
   // global model + active-profile pill. Both are nanostores, so the blanket
   // invalidateQueries() the profile store fires on swap doesn't touch them —
@@ -1064,7 +1152,7 @@ export function DesktopController() {
           onCompleted={() => {
             void refreshHermesConfig()
             void refreshCurrentModel()
-            void queryClient.invalidateQueries({ queryKey: ['model-options'] })
+            void queryClient.invalidateQueries({ queryKey: ['model-options', activeProfileQueryKey()] })
           }}
           requestGateway={requestGateway}
         />
@@ -1089,14 +1177,14 @@ export function DesktopController() {
             onConfigSaved={() => {
               void refreshHermesConfig()
               void refreshCurrentModel()
-              void queryClient.invalidateQueries({ queryKey: ['model-options'] })
+              void queryClient.invalidateQueries({ queryKey: ['model-options', activeProfileQueryKey()] })
             }}
             onMainModelChanged={(provider, model) => {
               setCurrentProvider(provider)
               setCurrentModel(model)
               updateModelOptionsCache(provider, model, true)
               void refreshCurrentModel()
-              void queryClient.invalidateQueries({ queryKey: ['model-options'] })
+              void queryClient.invalidateQueries({ queryKey: ['model-options', activeProfileQueryKey()] })
             }}
           />
         </Suspense>
diff --git a/apps/desktop/src/app/hooks/use-config-record.test.ts b/apps/desktop/src/app/hooks/use-config-record.test.ts
new file mode 100644
index 0000000000000..5326d1da1fdac
--- /dev/null
+++ b/apps/desktop/src/app/hooks/use-config-record.test.ts
@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+import { atom } from 'nanostores'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { HermesConfigRecord } from '@/types/hermes'
+
+// Keep the profile store's side-effecting imports inert (same pattern as
+// store/profile.test.ts): no real gateway socket, no real REST module.
+const ensureGatewayForProfile = vi.fn(async () => undefined)
+const $gateway = atom<unknown>({ id: 'live-socket' })
+
+vi.mock('@/store/gateway', () => ({ $gateway, ensureGatewayForProfile }))
+vi.mock('@/hermes', () => ({
+  getHermesConfigRecord: vi.fn(async () => ({})),
+  getProfiles: vi.fn(async () => ({ profiles: [] })),
+  setApiRequestProfile: vi.fn()
+}))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
+const { HERMES_CONFIG_KEY, hermesConfigKey, invalidateHermesConfig, setHermesConfigCache } =
+  await import('./use-config-record')
+
+const { $activeGatewayProfile } = await import('@/store/profile')
+const { queryClient } = await import('@/lib/query-client')
+
+describe('profile-scoped hermes-config query keys (F4)', () => {
+  beforeEach(() => {
+    queryClient.clear()
+    $activeGatewayProfile.set('default')
+  })
+
+  it('keys each profile into its own cache slot — no cross-profile bleed', () => {
+    $activeGatewayProfile.set('alpha')
+    setHermesConfigCache({ model: 'alpha-model' } as HermesConfigRecord)
+
+    $activeGatewayProfile.set('beta')
+    setHermesConfigCache({ model: 'beta-model' } as HermesConfigRecord)
+
+    // Beta's write must not have touched alpha's slot, and vice versa:
+    // hopping back to alpha serves alpha's warm cache untouched.
+    expect(queryClient.getQueryData(hermesConfigKey('alpha'))).toEqual({ model: 'alpha-model' })
+    expect(queryClient.getQueryData(hermesConfigKey('beta'))).toEqual({ model: 'beta-model' })
+  })
+
+  it('normalizes empty/unset profiles to the "default" segment', () => {
+    expect(hermesConfigKey('')).toEqual([...HERMES_CONFIG_KEY, 'default'])
+    expect(hermesConfigKey(null)).toEqual([...HERMES_CONFIG_KEY, 'default'])
+    expect(hermesConfigKey('  ')).toEqual([...HERMES_CONFIG_KEY, 'default'])
+    expect(hermesConfigKey('coder')).toEqual([...HERMES_CONFIG_KEY, 'coder'])
+  })
+
+  it('invalidateHermesConfig targets only the ACTIVE profile slot', async () => {
+    queryClient.setQueryData(hermesConfigKey('alpha'), { a: 1 })
+    queryClient.setQueryData(hermesConfigKey('beta'), { b: 2 })
+    $activeGatewayProfile.set('alpha')
+
+    await invalidateHermesConfig()
+
+    expect(queryClient.getQueryState(hermesConfigKey('alpha'))?.isInvalidated).toBe(true)
+    expect(queryClient.getQueryState(hermesConfigKey('beta'))?.isInvalidated).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/app/hooks/use-config-record.ts b/apps/desktop/src/app/hooks/use-config-record.ts
index ca4f00cb2a59a..3e67831bc694b 100644
--- a/apps/desktop/src/app/hooks/use-config-record.ts
+++ b/apps/desktop/src/app/hooks/use-config-record.ts
@@ -1,7 +1,9 @@
+import { useStore } from '@nanostores/react'
 import { useQuery } from '@tanstack/react-query'
 
 import { getHermesConfigRecord } from '@/hermes'
 import { queryClient, writeCache } from '@/lib/query-client'
+import { $activeGatewayProfile, activeProfileQueryKey, normalizeProfileKey } from '@/store/profile'
 import type { HermesConfigRecord } from '@/types/hermes'
 
 // One shared cache for the whole profile config record (`GET /api/config`).
@@ -9,14 +11,30 @@ import type { HermesConfigRecord } from '@/types/hermes'
 // so a save in one shows in the others, and revisiting a tab paints the cache
 // instead of blanking on a fresh fetch.
 //
+// The key carries the ACTIVE GATEWAY PROFILE segment: the record is
+// profile-scoped state served by whichever backend the gateway is on, so
+// per-profile keys guarantee profile A's config can never paint under profile
+// B, and hopping back to A serves A's warm cache instead of refetching.
+//
 // Distinct from session/hooks/use-hermes-config.ts, which is side-effecting —
 // it pushes personality/cwd/voice/… into the session stores for live chat.
 export const HERMES_CONFIG_KEY = ['hermes-config-record'] as const
 
+export const hermesConfigKey = (profile: null | string | undefined) =>
+  [...HERMES_CONFIG_KEY, normalizeProfileKey(profile)] as const
+
 // staleTime 0 → serve cache instantly, background-revalidate on every mount.
-export const useHermesConfigRecord = () =>
-  useQuery({ queryKey: HERMES_CONFIG_KEY, queryFn: getHermesConfigRecord, staleTime: 0 })
+export const useHermesConfigRecord = () => {
+  const profileKey = normalizeProfileKey(useStore($activeGatewayProfile))
+
+  return useQuery({ queryKey: hermesConfigKey(profileKey), queryFn: getHermesConfigRecord, staleTime: 0 })
+}
 
-export const setHermesConfigCache = writeCache<HermesConfigRecord>(HERMES_CONFIG_KEY)
+// Imperative cache write/invalidate target the profile the gateway is on NOW —
+// saves always go through the active backend, so that's the record they touched.
+export const setHermesConfigCache = (
+  next: HermesConfigRecord | undefined | ((prev: HermesConfigRecord | undefined) => HermesConfigRecord | undefined)
+): void => writeCache<HermesConfigRecord>(hermesConfigKey(activeProfileQueryKey()))(next)
 
-export const invalidateHermesConfig = () => queryClient.invalidateQueries({ queryKey: HERMES_CONFIG_KEY })
+export const invalidateHermesConfig = () =>
+  queryClient.invalidateQueries({ queryKey: hermesConfigKey(activeProfileQueryKey()) })
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
index 994dbc191a85a..ea5ee8772d642 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
@@ -260,8 +260,12 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
         }
 
         if (modelChanged || providerChanged) {
+          // Keys are ['model-options', <profile>, <sessionId|'global'>]. This
+          // event can arrive over a BACKGROUND profile's socket, so match by
+          // session id across every profile segment instead of guessing one.
           void queryClient.invalidateQueries({
-            queryKey: explicitSid && sessionId ? ['model-options', sessionId] : ['model-options']
+            predicate: query =>
+              query.queryKey[0] === 'model-options' && (!explicitSid || !sessionId || query.queryKey[2] === sessionId)
           })
         }
       } else if (event.type === 'message.start') {
diff --git a/apps/desktop/src/app/session/hooks/use-model-controls.test.tsx b/apps/desktop/src/app/session/hooks/use-model-controls.test.tsx
index 92888b4780dfc..a5351eb8f45c5 100644
--- a/apps/desktop/src/app/session/hooks/use-model-controls.test.tsx
+++ b/apps/desktop/src/app/session/hooks/use-model-controls.test.tsx
@@ -12,9 +12,16 @@ const notifyError = vi.fn()
 
 vi.mock('@/hermes', () => ({
   getGlobalModelInfo: vi.fn(),
+  // Pulled in transitively via @/store/profile (activeProfileQueryKey).
+  getProfiles: vi.fn(async () => ({ profiles: [] })),
+  setApiRequestProfile: vi.fn(),
   setGlobalModel: (...args: Parameters<typeof setGlobalModel>) => setGlobalModel(...args)
 }))
 
+// Keep the profile store's gateway/starmap side effects inert in this suite.
+vi.mock('@/store/gateway', () => ({ $gateway: { get: () => null }, ensureGatewayForProfile: vi.fn() }))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
 vi.mock('@/i18n', () => ({
   useI18n: () => ({
     t: {
diff --git a/apps/desktop/src/app/session/hooks/use-model-controls.ts b/apps/desktop/src/app/session/hooks/use-model-controls.ts
index dba30dd8d1401..9b6b060a67768 100644
--- a/apps/desktop/src/app/session/hooks/use-model-controls.ts
+++ b/apps/desktop/src/app/session/hooks/use-model-controls.ts
@@ -4,6 +4,7 @@ import { useCallback } from 'react'
 import { getGlobalModelInfo } from '@/hermes'
 import { useI18n } from '@/i18n'
 import { notifyError } from '@/store/notifications'
+import { activeProfileQueryKey } from '@/store/profile'
 import { $activeSessionId, $currentModel, $currentProvider, setCurrentModel, setCurrentProvider } from '@/store/session'
 import type { ModelOptionsResponse } from '@/types/hermes'
 
@@ -26,10 +27,15 @@ export function useModelControls({ activeSessionId, queryClient, requestGateway
     (provider: string, model: string, includeGlobal: boolean) => {
       const patch = (prev: ModelOptionsResponse | undefined) => ({ ...(prev ?? {}), provider, model })
 
-      queryClient.setQueryData<ModelOptionsResponse>(['model-options', activeSessionId || 'global'], patch)
+      // Keys carry the live gateway profile segment (see the model-options
+      // useQuery call sites) — writes land on the active profile's slot only.
+      queryClient.setQueryData<ModelOptionsResponse>(
+        ['model-options', activeProfileQueryKey(), activeSessionId || 'global'],
+        patch
+      )
 
       if (includeGlobal) {
-        queryClient.setQueryData<ModelOptionsResponse>(['model-options', 'global'], patch)
+        queryClient.setQueryData<ModelOptionsResponse>(['model-options', activeProfileQueryKey(), 'global'], patch)
       }
     },
     [activeSessionId, queryClient]
@@ -99,7 +105,7 @@ export function useModelControls({ activeSessionId, queryClient, requestGateway
           value: `${selection.model} --provider ${selection.provider}`
         })
 
-        void queryClient.invalidateQueries({ queryKey: ['model-options', activeSessionId] })
+        void queryClient.invalidateQueries({ queryKey: ['model-options', activeProfileQueryKey(), activeSessionId] })
 
         return true
       } catch (err) {
diff --git a/apps/desktop/src/app/settings/config-settings.tsx b/apps/desktop/src/app/settings/config-settings.tsx
index 6a87590b3cb19..756953a62dfee 100644
--- a/apps/desktop/src/app/settings/config-settings.tsx
+++ b/apps/desktop/src/app/settings/config-settings.tsx
@@ -1,3 +1,4 @@
+import { useStore } from '@nanostores/react'
 import { useQuery } from '@tanstack/react-query'
 import type { ChangeEvent, ReactNode } from 'react'
 import { useEffect, useMemo, useRef, useState } from 'react'
@@ -12,6 +13,7 @@ import { getElevenLabsVoices, getHermesConfigSchema, saveHermesConfig } from '@/
 import { useI18n } from '@/i18n'
 import { cn } from '@/lib/utils'
 import { notify, notifyError } from '@/store/notifications'
+import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import type { ConfigFieldSchema, HermesConfigRecord } from '@/types/hermes'
 
 import { setHermesConfigCache, useHermesConfigRecord } from '../hooks/use-config-record'
@@ -236,7 +238,9 @@ export function ConfigSettings({
     isError: schemaFailed,
     refetch: refetchSchema
   } = useQuery({
-    queryKey: ['hermes-config-schema'],
+    // Schema comes from the active profile's backend (versions can differ
+    // across pooled/remote backends), so key it per profile like the record.
+    queryKey: ['hermes-config-schema', normalizeProfileKey(useStore($activeGatewayProfile))],
     queryFn: getHermesConfigSchema,
     staleTime: 5 * 60 * 1000
   })
diff --git a/apps/desktop/src/app/settings/model-settings.test.tsx b/apps/desktop/src/app/settings/model-settings.test.tsx
index 405fb49cd727c..25f27bececadf 100644
--- a/apps/desktop/src/app/settings/model-settings.test.tsx
+++ b/apps/desktop/src/app/settings/model-settings.test.tsx
@@ -1,3 +1,4 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
@@ -24,13 +25,25 @@ vi.mock('@/hermes', () => ({
   getGlobalModelInfo: () => getGlobalModelInfo(),
   getGlobalModelOptions: () => getGlobalModelOptions(),
   getAuxiliaryModels: () => getAuxiliaryModels(),
+  // MoA catalog is optional (refresh() falls back to null) — but the export
+  // must exist or the whole Promise.all throws synchronously and the panel
+  // renders its error state instead of the provider list.
+  getMoaModels: vi.fn(async () => null),
+  saveMoaModels: vi.fn(async () => ({ ok: true })),
   setModelAssignment: (body: unknown) => setModelAssignment(body),
   getRecommendedDefaultModel: (slug: string) => getRecommendedDefaultModel(slug),
   setEnvVar: (key: string, value: string) => setEnvVar(key, value),
   getHermesConfigRecord: () => getHermesConfigRecord(),
+  // Pulled in transitively via @/store/profile (profile-scoped query keys).
+  getProfiles: vi.fn(async () => ({ profiles: [] })),
+  setApiRequestProfile: vi.fn(),
   saveHermesConfig: (config: unknown) => saveHermesConfig(config)
 }))
 
+// Keep the profile store's gateway/starmap side effects inert in this suite.
+vi.mock('@/store/gateway', () => ({ $gateway: { get: () => null }, ensureGatewayForProfile: vi.fn() }))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
 vi.mock('@/store/onboarding', () => ({
   startManualProviderOAuth: (slug: string) => startManualProviderOAuth(slug)
 }))
@@ -76,7 +89,16 @@ afterEach(() => {
 async function renderModelSettings() {
   const { ModelSettings } = await import('./model-settings')
 
-  return render(<ModelSettings />)
+  // ModelSettings reaches useHermesConfigRecord (react-query) via the fast
+  // switch, so it needs a provider — throwaway client per render keeps the
+  // per-profile config cache from leaking between tests.
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+
+  return render(
+    <QueryClientProvider client={client}>
+      <ModelSettings />
+    </QueryClientProvider>
+  )
 }
 
 describe('ModelSettings', () => {
@@ -91,11 +113,12 @@ describe('ModelSettings', () => {
     const triggers = await screen.findAllByRole('combobox')
     fireEvent.click(triggers[0])
 
-    // "Nous" shows in both the trigger and the open list; the unconfigured
-    // provider + its setup hint are the unique signal of the full universe.
+    // "Nous" shows in both the trigger and the open list; the unconfigured,
+    // model-less provider being listed at all is the unique signal of the
+    // full-universe payload (its setup affordance only renders once selected —
+    // covered by the next test).
     expect((await screen.findAllByText('Nous')).length).toBeGreaterThan(0)
     expect(await screen.findByText(/DeepSeek/)).toBeTruthy()
-    expect(await screen.findByText(/set up/)).toBeTruthy()
   })
 
   it('activates an unconfigured api_key provider inline by saving its key', async () => {
diff --git a/apps/desktop/src/app/settings/providers-settings.test.tsx b/apps/desktop/src/app/settings/providers-settings.test.tsx
index 8a894e27ab15f..6ac61ab05ddf2 100644
--- a/apps/desktop/src/app/settings/providers-settings.test.tsx
+++ b/apps/desktop/src/app/settings/providers-settings.test.tsx
@@ -13,9 +13,16 @@ const onboarding = atom({ manual: false })
 vi.mock('@/hermes', () => ({
   disconnectOAuthProvider: (providerId: string) => disconnectOAuthProvider(providerId),
   getEnvVars: () => getEnvVars(),
-  listOAuthProviders: () => listOAuthProviders()
+  // Pulled in transitively via @/store/profile (profile-scoped query keys).
+  getProfiles: vi.fn(async () => ({ profiles: [] })),
+  listOAuthProviders: () => listOAuthProviders(),
+  setApiRequestProfile: vi.fn()
 }))
 
+// Keep the profile store's gateway/starmap side effects inert in this suite.
+vi.mock('@/store/gateway', () => ({ $gateway: { get: () => null }, ensureGatewayForProfile: vi.fn() }))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
 vi.mock('@/store/onboarding', () => ({
   $desktopOnboarding: onboarding,
   startManualProviderOAuth: (providerId: string) => startManualProviderOAuth(providerId)
diff --git a/apps/desktop/src/app/shell/model-menu-panel.test.tsx b/apps/desktop/src/app/shell/model-menu-panel.test.tsx
index 57125de35da38..05aac9b85af46 100644
--- a/apps/desktop/src/app/shell/model-menu-panel.test.tsx
+++ b/apps/desktop/src/app/shell/model-menu-panel.test.tsx
@@ -17,9 +17,16 @@ beforeAll(() => {
 const getGlobalModelOptions = vi.fn()
 
 vi.mock('@/hermes', () => ({
-  getGlobalModelOptions: (...args: unknown[]) => getGlobalModelOptions(...args)
+  getGlobalModelOptions: (...args: unknown[]) => getGlobalModelOptions(...args),
+  // Pulled in transitively via @/store/profile (profile-scoped query keys).
+  getProfiles: vi.fn(async () => ({ profiles: [] })),
+  setApiRequestProfile: vi.fn()
 }))
 
+// Keep the profile store's gateway/starmap side effects inert in this suite.
+vi.mock('@/store/gateway', () => ({ $gateway: { get: () => null }, ensureGatewayForProfile: vi.fn() }))
+vi.mock('@/store/starmap', () => ({ resetStarmapGraph: vi.fn() }))
+
 // MoA presets now arrive as the catalog's virtual `moa` provider row (the same
 // payload a remote gateway's model.options returns), not the /api/model/moa
 // REST config.
diff --git a/apps/desktop/src/app/shell/model-menu-panel.tsx b/apps/desktop/src/app/shell/model-menu-panel.tsx
index f358a29ffabf0..7dbe7a39a4562 100644
--- a/apps/desktop/src/app/shell/model-menu-panel.tsx
+++ b/apps/desktop/src/app/shell/model-menu-panel.tsx
@@ -36,6 +36,7 @@ import {
   modelVisibilityKey,
   setModelVisibilityOpen
 } from '@/store/model-visibility'
+import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import {
   $activeSessionId,
   $currentFastMode,
@@ -81,8 +82,12 @@ export function ModelMenuPanel({ gateway, onSelectModel, requestGateway }: Model
   const modelPresets = useStore($modelPresets)
   const visibleModels = useStore($visibleModels)
 
+  // Profile-scoped key: the catalog comes from whichever backend the gateway
+  // is on, so hopping profiles re-keys (warm per-profile caches, no bleed).
+  const modelOptionsProfile = normalizeProfileKey(useStore($activeGatewayProfile))
+
   const modelOptions = useQuery({
-    queryKey: ['model-options', activeSessionId || 'global'],
+    queryKey: ['model-options', modelOptionsProfile, activeSessionId || 'global'],
     // Gateway-first even with no session yet: a connected (possibly remote)
     // gateway owns the model catalog, including virtual providers like `moa`
     // that the local REST fallback can't know about (#53817).
@@ -140,7 +145,7 @@ export function ModelMenuPanel({ gateway, onSelectModel, requestGateway }: Model
     setRefreshing(true)
 
     try {
-      const queryKey = ['model-options', activeSessionId || 'global']
+      const queryKey = ['model-options', modelOptionsProfile, activeSessionId || 'global']
 
       const next = await requestModelOptions({ gateway, refresh: true, sessionId: activeSessionId })
 
@@ -148,7 +153,7 @@ export function ModelMenuPanel({ gateway, onSelectModel, requestGateway }: Model
     } catch {
       // Network/backend hiccup — fall back to a plain invalidate so the next
       // open re-fetches (still cached, but no worse than before).
-      void queryClient.invalidateQueries({ queryKey: ['model-options'] })
+      void queryClient.invalidateQueries({ queryKey: ['model-options', modelOptionsProfile] })
     } finally {
       setRefreshing(false)
     }
diff --git a/apps/desktop/src/app/skills/hub.tsx b/apps/desktop/src/app/skills/hub.tsx
index a7ed3ca8fe5b3..5ad32b3f425d0 100644
--- a/apps/desktop/src/app/skills/hub.tsx
+++ b/apps/desktop/src/app/skills/hub.tsx
@@ -41,6 +41,7 @@ import {
   updateHubSkills
 } from '@/store/hub-actions'
 import { notify, notifyError } from '@/store/notifications'
+import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 
 // Dedup rank when the same skill surfaces from multiple sources — higher trust
 // wins. Mirrors the backend's unified_search `_TRUST_RANK`.
@@ -144,10 +145,17 @@ export function SkillsHub({ query }: SkillsHubProps) {
   const { t } = useI18n()
   const h = t.skills.hub
 
+  // Both hub queries below are answered by the active profile's backend (and
+  // carry its installed map), so their cache keys need the profile segment.
+  const hubProfile = normalizeProfileKey(useStore($activeGatewayProfile))
+
   // Sources + featured + the installed map — one cached fetch, revalidated on
   // mount and re-fetched (from the store) after an action lands.
+  // Sources carry the per-profile installed map, so key by the live gateway
+  // profile (store/hub-actions invalidates by the HUB_SOURCES_KEY prefix,
+  // which matches every profile segment).
   const sourcesQuery = useQuery({
-    queryKey: HUB_SOURCES_KEY,
+    queryKey: [...HUB_SOURCES_KEY, hubProfile],
     queryFn: getSkillHubSources,
     staleTime: 5 * 60_000
   })
@@ -168,7 +176,7 @@ export function SkillsHub({ query }: SkillsHubProps) {
 
   const sourceSearches = useQueries({
     queries: searchableSources.map(source => ({
-      queryKey: ['skill-hub-search', term, source.id],
+      queryKey: ['skill-hub-search', hubProfile, term, source.id],
       queryFn: () => searchSkillsHub(term, source.id),
       enabled: term.length > 0,
       staleTime: 60_000
@@ -323,7 +331,9 @@ export function SkillsHub({ query }: SkillsHubProps) {
         <div className="flex shrink-0 items-center justify-between gap-3 px-4 pb-1.5 text-[0.68rem] text-(--ui-text-tertiary)">
           <span className="min-w-0 truncate">
             {term.length > 0 ? h.resultCount(results.length, null) : h.featured}
-            {anyFetching && results.length > 0 && <span className="ml-2 text-(--ui-text-quaternary)">{h.searching}</span>}
+            {anyFetching && results.length > 0 && (
+              <span className="ml-2 text-(--ui-text-quaternary)">{h.searching}</span>
+            )}
           </span>
 
           {hasInstalled && (
diff --git a/apps/desktop/src/app/skills/index.tsx b/apps/desktop/src/app/skills/index.tsx
index 41620e2c1243b..32fd2c2f409f6 100644
--- a/apps/desktop/src/app/skills/index.tsx
+++ b/apps/desktop/src/app/skills/index.tsx
@@ -26,7 +26,7 @@ import { queryClient, writeCache } from '@/lib/query-client'
 import { normalize } from '@/lib/text'
 import { $gateway } from '@/store/gateway'
 import { notify, notifyError } from '@/store/notifications'
-import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
+import { $activeGatewayProfile, activeProfileQueryKey, normalizeProfileKey } from '@/store/profile'
 import type { SkillInfo, ToolsetInfo } from '@/types/hermes'
 
 import { useOnProfileSwitch } from '../hooks/use-on-profile-switch'
@@ -59,15 +59,25 @@ const SKILLS_MODES = ['skills', 'toolsets', 'mcp', 'hub'] as const
 
 // Skills + toolsets live in the RQ cache so switching tabs/pages paints the
 // cached lists instantly (no reload flash) and mount only fires a deduped
-// background refetch. A profile swap globally invalidates (see store/profile),
-// so these plain keys refetch against the new backend automatically.
+// background refetch. Keys carry the active gateway profile segment: a profile
+// swap re-keys the queries (per-profile warm caches, no cross-profile bleed)
+// instead of the old blanket invalidation in store/profile.
 const SKILLS_QUERY_KEY = ['skills-list'] as const
 const TOOLSETS_QUERY_KEY = ['toolsets-list'] as const
 
+const skillsKey = (profile: string) => [...SKILLS_QUERY_KEY, profile] as const
+const toolsetsKey = (profile: string) => [...TOOLSETS_QUERY_KEY, profile] as const
+
 // Optimistic write-through: toggles/bulk/archive repaint instantly; the next
-// background refetch reconciles with the backend.
-const setSkills = writeCache<SkillInfo[]>(SKILLS_QUERY_KEY)
-const setToolsets = writeCache<ToolsetInfo[]>(TOOLSETS_QUERY_KEY)
+// background refetch reconciles with the backend. Writes land on the ACTIVE
+// profile's slot — mutations always go through the active backend.
+const setSkills = (
+  next: SkillInfo[] | undefined | ((prev: SkillInfo[] | undefined) => SkillInfo[] | undefined)
+): void => writeCache<SkillInfo[]>(skillsKey(activeProfileQueryKey()))(next)
+
+const setToolsets = (
+  next: ToolsetInfo[] | undefined | ((prev: ToolsetInfo[] | undefined) => ToolsetInfo[] | undefined)
+): void => writeCache<ToolsetInfo[]>(toolsetsKey(activeProfileQueryKey()))(next)
 
 // Per-tool call counts come from a 365-day message scan — heavy, and purely
 // cosmetic (Toolsets usage badges). Cache the result module-wide with a TTL so
@@ -181,6 +191,9 @@ interface SkillsViewProps extends React.ComponentProps<'section'> {
 export function SkillsView({ setStatusbarItemGroup: _setStatusbarItemGroup, ...props }: SkillsViewProps) {
   const { t } = useI18n()
   const gateway = useStore($gateway) as HermesGateway | null
+  // Reactive profile segment: a gateway swap re-keys the queries below onto
+  // the new profile's cache slot.
+  const capabilitiesProfile = normalizeProfileKey(useStore($activeGatewayProfile))
   const [mode, setMode] = useRouteEnumParam('tab', SKILLS_MODES, 'skills')
 
   const [query, setQuery] = useState('')
@@ -190,13 +203,13 @@ export function SkillsView({ setStatusbarItemGroup: _setStatusbarItemGroup, ...p
     isError: skillsFailed,
     error: skillsError
   } = useQuery({
-    queryKey: SKILLS_QUERY_KEY,
+    queryKey: skillsKey(capabilitiesProfile),
     queryFn: getSkills,
     staleTime: 0
   })
 
   const { data: toolsets, isError: toolsetsFailed } = useQuery({
-    queryKey: TOOLSETS_QUERY_KEY,
+    queryKey: toolsetsKey(capabilitiesProfile),
     queryFn: getToolsets,
     staleTime: 0
   })
@@ -215,8 +228,8 @@ export function SkillsView({ setStatusbarItemGroup: _setStatusbarItemGroup, ...p
 
   const refreshCapabilities = useCallback(async () => {
     await Promise.all([
-      queryClient.invalidateQueries({ queryKey: SKILLS_QUERY_KEY }),
-      queryClient.invalidateQueries({ queryKey: TOOLSETS_QUERY_KEY })
+      queryClient.invalidateQueries({ queryKey: skillsKey(activeProfileQueryKey()) }),
+      queryClient.invalidateQueries({ queryKey: toolsetsKey(activeProfileQueryKey()) })
     ])
 
     // An explicit refresh is the one time we bypass the analytics TTL — but
@@ -233,7 +246,7 @@ export function SkillsView({ setStatusbarItemGroup: _setStatusbarItemGroup, ...p
   }, [])
 
   const refreshToolsets = useCallback(() => {
-    void queryClient.invalidateQueries({ queryKey: TOOLSETS_QUERY_KEY })
+    void queryClient.invalidateQueries({ queryKey: toolsetsKey(activeProfileQueryKey()) })
   }, [])
 
   useRefreshHotkey(refreshCapabilities)
@@ -492,7 +505,11 @@ export function SkillsView({ setStatusbarItemGroup: _setStatusbarItemGroup, ...p
 
     try {
       await editLearningNode(skillEditor.name, skillDraft)
-      notify({ kind: 'success', title: t.skills.skillUpdated, message: t.skills.appliesToNewSessions(skillEditor.name) })
+      notify({
+        kind: 'success',
+        title: t.skills.skillUpdated,
+        message: t.skills.appliesToNewSessions(skillEditor.name)
+      })
       setSkillEditor(null)
       void refreshCapabilities()
     } catch (err) {
@@ -577,7 +594,9 @@ export function SkillsView({ setStatusbarItemGroup: _setStatusbarItemGroup, ...p
                   left={sortButton(skillsSortDesc, () => $skillsSortDesc.set(!$skillsSortDesc.get()))}
                   right={
                     <ListStripMenu
-                      items={[{ disabled: bulkBusy, label: t.skills.disableUnused, onSelect: () => void disableUnused() }]}
+                      items={[
+                        { disabled: bulkBusy, label: t.skills.disableUnused, onSelect: () => void disableUnused() }
+                      ]}
                       label={t.skills.tabSkills}
                       toggle={bulkSwitch(allSkillsEnabled)}
                     />
diff --git a/apps/desktop/src/components/model-picker.tsx b/apps/desktop/src/components/model-picker.tsx
index 37de510c6537a..bb0de542ba4f6 100644
--- a/apps/desktop/src/components/model-picker.tsx
+++ b/apps/desktop/src/components/model-picker.tsx
@@ -1,3 +1,4 @@
+import { useStore } from '@nanostores/react'
 import { useQuery } from '@tanstack/react-query'
 import { useState } from 'react'
 
@@ -10,6 +11,7 @@ import type { ModelOptionProvider, ModelPricing } from '@/types/hermes'
 import type { HermesGateway } from '../hermes'
 import { cn } from '../lib/utils'
 import { startManualOnboarding } from '../store/onboarding'
+import { $activeGatewayProfile, normalizeProfileKey } from '../store/profile'
 
 import { InlineNotice } from './notifications'
 import { Button } from './ui/button'
@@ -53,8 +55,11 @@ export function ModelPickerDialog({
   // the `hermes model` CLI picker, which shows the curated list verbatim.
   const [search, setSearch] = useState('')
 
+  // Profile segment keeps each backend's catalog in its own cache slot.
+  const modelOptionsProfile = normalizeProfileKey(useStore($activeGatewayProfile))
+
   const modelOptions = useQuery({
-    queryKey: ['model-options', sessionId || 'global'],
+    queryKey: ['model-options', modelOptionsProfile, sessionId || 'global'],
     queryFn: () => requestModelOptions({ gateway: gw, sessionId }),
     enabled: open
   })
diff --git a/apps/desktop/src/components/model-visibility-dialog.tsx b/apps/desktop/src/components/model-visibility-dialog.tsx
index 8f1aad94767f7..bf8d900fbf800 100644
--- a/apps/desktop/src/components/model-visibility-dialog.tsx
+++ b/apps/desktop/src/components/model-visibility-dialog.tsx
@@ -19,6 +19,7 @@ import {
   setVisibleModels,
   toggleModelVisibility
 } from '@/store/model-visibility'
+import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import type { ModelOptionProvider, ModelOptionsResponse } from '@/types/hermes'
 
 interface ModelVisibilityDialogProps {
@@ -41,8 +42,11 @@ export function ModelVisibilityDialog({
   const [search, setSearch] = useState('')
   const stored = useStore($visibleModels)
 
+  // Profile segment keeps each backend's catalog in its own cache slot.
+  const modelOptionsProfile = normalizeProfileKey(useStore($activeGatewayProfile))
+
   const modelOptions = useQuery({
-    queryKey: ['model-options', sessionId || 'global'],
+    queryKey: ['model-options', modelOptionsProfile, sessionId || 'global'],
     queryFn: (): Promise<ModelOptionsResponse> => {
       if (gw && sessionId) {
         return gw.request<ModelOptionsResponse>('model.options', { session_id: sessionId })
diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts
index 121af73717730..b086407e8c4c9 100644
--- a/apps/desktop/src/i18n/en.ts
+++ b/apps/desktop/src/i18n/en.ts
@@ -1324,7 +1324,9 @@ export const en: Translations = {
     failedLoadSoul: 'Failed to load SOUL.md',
     failedSaveSoul: 'Failed to save SOUL.md',
     failedCreate: 'Failed to create profile',
-    failedRename: 'Failed to rename profile'
+    failedRename: 'Failed to rename profile',
+    workingBadge: count => (count === 1 ? '1 session working' : `${count} sessions working`),
+    attentionBadge: count => (count === 1 ? '1 session needs your input' : `${count} sessions need your input`)
   },
 
   cron: {
@@ -2547,5 +2549,21 @@ export const en: Translations = {
       description: 'Displays the mobile sidebar.',
       toggle: 'Toggle Sidebar'
     }
+  },
+
+  commandCenterOverview: {
+    sectionLabel: 'All profiles',
+    sectionDescription: 'Activity across every profile, plus the shared kanban board',
+    working: count => `${count} working`,
+    attention: count => (count === 1 ? '1 needs input' : `${count} need input`),
+    sessions: count => `${count} ${count === 1 ? 'session' : 'sessions'}`,
+    idle: 'Idle',
+    noActivity: 'No activity yet',
+    currentBadge: 'Current',
+    switch: 'Switch',
+    openBoard: 'Open board',
+    kanbanUnavailable: 'Kanban is not available on this backend.',
+    noHotCards: 'Nothing in review or blocked',
+    openCard: title => `Open "${title}" on the kanban board`
   }
 }
diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts
index 94809f2ad4ee8..53b8bce084e15 100644
--- a/apps/desktop/src/i18n/types.ts
+++ b/apps/desktop/src/i18n/types.ts
@@ -1103,6 +1103,8 @@ export interface Translations {
     failedSaveSoul: string
     failedCreate: string
     failedRename: string
+    workingBadge: (count: number) => string
+    attentionBadge: (count: number) => string
   }
 
   cron: {
@@ -2132,4 +2134,23 @@ export interface Translations {
       toggle: string
     }
   }
+
+  // Cross-profile "All profiles" overview in the command center. Kept as its
+  // own top-level block (adjacent to commandCenter, appended at the end) so it
+  // composes with the existing section without touching its shape.
+  commandCenterOverview: {
+    sectionLabel: string
+    sectionDescription: string
+    working: (count: number) => string
+    attention: (count: number) => string
+    sessions: (count: number) => string
+    idle: string
+    noActivity: string
+    currentBadge: string
+    switch: string
+    openBoard: string
+    kanbanUnavailable: string
+    noHotCards: string
+    openCard: (title: string) => string
+  }
 }
diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts
index 0eb909a9f3215..5faac8af8dcc3 100644
--- a/apps/desktop/src/i18n/zh.ts
+++ b/apps/desktop/src/i18n/zh.ts
@@ -1503,7 +1503,9 @@ export const zh: Translations = {
     failedLoadSoul: '加载 SOUL.md 失败',
     failedSaveSoul: '保存 SOUL.md 失败',
     failedCreate: '创建配置档案失败',
-    failedRename: '重命名配置档案失败'
+    failedRename: '重命名配置档案失败',
+    workingBadge: count => `${count} 个会话运行中`,
+    attentionBadge: count => `${count} 个会话等待你的输入`
   },
 
   cron: {
@@ -2696,5 +2698,21 @@ export const zh: Translations = {
       description: '显示移动端侧边栏。',
       toggle: '切换侧边栏'
     }
+  },
+
+  commandCenterOverview: {
+    sectionLabel: '全部配置档案',
+    sectionDescription: '总览所有配置档案的活动，以及共享的看板',
+    working: count => `${count} 个进行中`,
+    attention: count => `${count} 个待输入`,
+    sessions: count => `${count} 个会话`,
+    idle: '空闲',
+    noActivity: '暂无活动',
+    currentBadge: '当前',
+    switch: '切换',
+    openBoard: '打开看板',
+    kanbanUnavailable: '此后端不支持看板。',
+    noHotCards: '没有待审查或被阻塞的卡片',
+    openCard: title => `在看板中打开「${title}」`
   }
 }
diff --git a/apps/desktop/src/store/profile.test.ts b/apps/desktop/src/store/profile.test.ts
index 1306139151f7b..52acdc49e7749 100644
--- a/apps/desktop/src/store/profile.test.ts
+++ b/apps/desktop/src/store/profile.test.ts
@@ -2,7 +2,7 @@ import { atom } from 'nanostores'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { HermesConnection } from '@/global'
-import type { ProfileInfo } from '@/types/hermes'
+import type { ProfileInfo, SessionInfo } from '@/types/hermes'
 
 // Keep profile.ts's side-effecting imports inert: the gateway socket layer and
 // the REST query client must not run for real in a unit test.
@@ -18,8 +18,26 @@ vi.mock('@/hermes', () => ({
 vi.mock('@/lib/query-client', () => ({ queryClient: { invalidateQueries: vi.fn() } }))
 vi.mock('@/store/starmap', () => ({ resetStarmapGraph }))
 
-const { $activeGatewayProfile, $profiles, ensureGatewayProfile, refreshProfiles } = await import('./profile')
-const { $connection } = await import('./session')
+const {
+  $activeGatewayProfile,
+  $profileLastSessions,
+  $profileRestoreRequest,
+  $profiles,
+  $showAllProfiles,
+  deriveProfileActivity,
+  ensureGatewayProfile,
+  forgetProfileSession,
+  forgetSessionMemo,
+  isSessionListed,
+  neediestSessionId,
+  refreshProfiles,
+  rememberedProfileSession,
+  rememberProfileSession,
+  selectProfile,
+  selectProfileSession
+} = await import('./profile')
+
+const { $connection, $sessions } = await import('./session')
 const { queryClient } = await import('@/lib/query-client')
 const { getProfiles } = await import('@/hermes')
 
@@ -33,6 +51,24 @@ const profile = (name: string, isDefault = false): ProfileInfo => ({
   skill_count: 0
 })
 
+const session = (id: string, profileName?: string, over: Partial<SessionInfo> = {}): SessionInfo => ({
+  ended_at: null,
+  id,
+  input_tokens: 0,
+  is_active: false,
+  last_active: 1000,
+  message_count: 1,
+  model: null,
+  output_tokens: 0,
+  preview: null,
+  ...(profileName ? { profile: profileName } : {}),
+  source: null,
+  started_at: 1000,
+  title: null,
+  tool_call_count: 0,
+  ...over
+})
+
 const remoteConn = (over: Partial<HermesConnection> = {}): HermesConnection =>
   ({ baseUrl: 'https://hermes-roy.tail.ts.net', mode: 'remote', profile: 'vps-remote', ...over }) as HermesConnection
 
@@ -48,6 +84,10 @@ beforeEach(() => {
   $activeGatewayProfile.set('default')
   $connection.set(localConn())
   $profiles.set([])
+  $sessions.set([])
+  $profileLastSessions.set({})
+  $profileRestoreRequest.set(null)
+  $showAllProfiles.set(false)
   vi.stubGlobal('window', { hermesDesktop: { getConnection } })
   vi.mocked(queryClient.invalidateQueries).mockClear()
   resetStarmapGraph.mockClear()
@@ -106,15 +146,176 @@ describe('ensureGatewayProfile → $connection sync (#46651)', () => {
   })
 })
 
-describe('profile-scoped cache invalidation', () => {
-  it('drops the memory graph cache when the active gateway profile changes', () => {
+describe('profile-scoped cache handling on gateway swap', () => {
+  it('resets the memory graph WITHOUT a blanket react-query invalidation (keys are profile-scoped)', () => {
     $activeGatewayProfile.set('coder')
 
-    expect(queryClient.invalidateQueries).toHaveBeenCalled()
+    // Profile-scoped query keys carry the profile segment, so a swap re-keys
+    // instead of nuking the cache: hopping back must hit warm caches.
+    expect(queryClient.invalidateQueries).not.toHaveBeenCalled()
     expect(resetStarmapGraph).toHaveBeenCalledTimes(1)
   })
 })
 
+describe('per-profile last-session memory (F1)', () => {
+  it('attributes the open session to its owning profile and restores each side of an A↔B hop', () => {
+    $sessions.set([session('s-default', 'default'), session('s-coder', 'coder')])
+
+    rememberProfileSession('s-default')
+    rememberProfileSession('s-coder')
+
+    expect(rememberedProfileSession('default')).toBe('s-default')
+    expect(rememberedProfileSession('coder')).toBe('s-coder')
+    // Remembering one side never clobbers the other.
+    rememberProfileSession('s-coder')
+    expect(rememberedProfileSession('default')).toBe('s-default')
+  })
+
+  it('falls back to the active gateway profile for a brand-new session the aggregator has not listed yet', () => {
+    $sessions.set([session('other', 'default')])
+    $activeGatewayProfile.set('coder')
+
+    rememberProfileSession('s-new')
+
+    expect(rememberedProfileSession('coder')).toBe('s-new')
+  })
+
+  it('never guess-attributes before the session list has loaded', () => {
+    $sessions.set([])
+    $activeGatewayProfile.set('coder')
+
+    rememberProfileSession('s-unknown')
+
+    expect($profileLastSessions.get()).toEqual({})
+  })
+
+  it('matches a compression-rotated session by lineage root', () => {
+    $sessions.set([session('tip', 'coder', { _lineage_root_id: 'root' })])
+
+    rememberProfileSession('root')
+
+    expect(rememberedProfileSession('coder')).toBe('root')
+  })
+
+  it('evicts a single profile memo and a dead id from every memo', () => {
+    $profileLastSessions.set({ coder: 'dead', default: 'dead', writer: 'alive' })
+
+    forgetProfileSession('coder')
+    expect(rememberedProfileSession('coder')).toBeNull()
+
+    forgetSessionMemo('dead')
+    expect($profileLastSessions.get()).toEqual({ writer: 'alive' })
+  })
+
+  it('isSessionListed sees live and lineage-rooted rows but never archived ones', () => {
+    const sessions = [
+      session('live', 'coder'),
+      session('tip', 'coder', { _lineage_root_id: 'rotated' }),
+      session('gone', 'coder', { archived: true })
+    ]
+
+    expect(isSessionListed(sessions, 'live')).toBe(true)
+    expect(isSessionListed(sessions, 'rotated')).toBe(true)
+    expect(isSessionListed(sessions, 'gone')).toBe(false)
+    expect(isSessionListed(sessions, 'missing')).toBe(false)
+  })
+})
+
+describe('profile switch → session restore request', () => {
+  it('fires a memo-driven restore request when switching to another profile', () => {
+    selectProfile('coder')
+
+    const request = $profileRestoreRequest.get()
+    expect(request?.profile).toBe('coder')
+    expect(request?.sessionId).toBeNull()
+    expect(ensureGatewayForProfile).toHaveBeenCalledWith('coder')
+  })
+
+  it('re-tapping the active profile leaves the open session alone', () => {
+    $activeGatewayProfile.set('coder')
+
+    selectProfile('coder')
+
+    expect($profileRestoreRequest.get()).toBeNull()
+  })
+
+  it('leaving the all-profiles view restores even for the same gateway profile', () => {
+    $activeGatewayProfile.set('coder')
+    $showAllProfiles.set(true)
+
+    selectProfile('coder')
+
+    expect($profileRestoreRequest.get()?.profile).toBe('coder')
+  })
+
+  it('selectProfileSession targets the explicit session (rail badge click)', () => {
+    selectProfileSession('coder', 's-urgent')
+
+    const request = $profileRestoreRequest.get()
+    expect(request?.profile).toBe('coder')
+    expect(request?.sessionId).toBe('s-urgent')
+    expect($showAllProfiles.get()).toBe(false)
+    expect(ensureGatewayForProfile).toHaveBeenCalledWith('coder')
+  })
+
+  it('mints a fresh token per switch so a rapid second switch supersedes the first', () => {
+    selectProfile('coder')
+    const first = $profileRestoreRequest.get()?.token
+    $activeGatewayProfile.set('coder')
+
+    selectProfile('writer')
+
+    expect($profileRestoreRequest.get()?.token).not.toBe(first)
+  })
+})
+
+describe('per-profile activity derivation (F2)', () => {
+  it('buckets working/attention sessions by owning profile, attention winning over working', () => {
+    const sessions = [
+      session('a1', 'coder', { last_active: 10, title: 'build' }),
+      session('a2', 'coder', { last_active: 30, title: 'blocked' }),
+      session('b1', 'writer', { last_active: 20, title: 'draft' }),
+      session('idle', 'coder', { last_active: 99 })
+    ]
+
+    const activity = deriveProfileActivity(sessions, ['a1', 'a2', 'b1'], ['a2'])
+
+    expect(activity.coder.working.map(row => row.id)).toEqual(['a1'])
+    expect(activity.coder.attention.map(row => row.id)).toEqual(['a2'])
+    expect(activity.writer.working.map(row => row.id)).toEqual(['b1'])
+    expect(activity.writer.attention).toEqual([])
+    // Idle sessions never produce a bucket entry.
+    expect(Object.values(activity).flatMap(entry => [...entry.working, ...entry.attention])).toHaveLength(3)
+  })
+
+  it('keys default-profile rows as "default" and sorts by recency', () => {
+    const sessions = [
+      session('old', 'main-home', { is_default_profile: true, last_active: 1 }),
+      session('new', 'main-home', { is_default_profile: true, last_active: 2 })
+    ]
+
+    const activity = deriveProfileActivity(sessions, ['old', 'new'], [])
+
+    expect(activity.default.working.map(row => row.id)).toEqual(['new', 'old'])
+  })
+
+  it('neediestSessionId prefers attention, then the most recent working session', () => {
+    const sessions = [
+      session('w-old', 'coder', { last_active: 1 }),
+      session('w-new', 'coder', { last_active: 5 }),
+      session('blocked', 'coder', { last_active: 2 })
+    ]
+
+    const withAttention = deriveProfileActivity(sessions, ['w-old', 'w-new', 'blocked'], ['blocked'])
+    expect(neediestSessionId(withAttention.coder)).toBe('blocked')
+
+    const workingOnly = deriveProfileActivity(sessions, ['w-old', 'w-new'], [])
+    expect(neediestSessionId(workingOnly.coder)).toBe('w-new')
+
+    expect(neediestSessionId(undefined)).toBeNull()
+  })
+})
+
 describe('refreshProfiles shared rail list (#49289)', () => {
   it('removes a deleted profile from the shared $profiles cache after Manage Profiles refreshes', async () => {
     $profiles.set([profile('default', true), profile('test1')])
diff --git a/apps/desktop/src/store/profile.ts b/apps/desktop/src/store/profile.ts
index 79a9c53013819..293fe7b7f6122 100644
--- a/apps/desktop/src/store/profile.ts
+++ b/apps/desktop/src/store/profile.ts
@@ -1,7 +1,6 @@
 import { atom, computed } from 'nanostores'
 
 import { getProfiles, setApiRequestProfile, STARTUP_REQUEST_TIMEOUT_MS } from '@/hermes'
-import { queryClient } from '@/lib/query-client'
 import {
   arraysEqual,
   persistBoolean,
@@ -12,9 +11,9 @@ import {
   storedStringRecord
 } from '@/lib/storage'
 import { $gateway, ensureGatewayForProfile } from '@/store/gateway'
-import { setConnection } from '@/store/session'
+import { $attentionSessionIds, $sessions, $workingSessionIds, setConnection } from '@/store/session'
 import { resetStarmapGraph } from '@/store/starmap'
-import type { ProfileInfo } from '@/types/hermes'
+import type { ProfileInfo, SessionInfo } from '@/types/hermes'
 
 // Canonical key for a profile: trimmed, empty → "default". Used everywhere we
 // compare a session's owning profile against the live gateway's profile.
@@ -155,20 +154,187 @@ export const $activeGatewayProfile = atom<string>('default')
 export const $newChatProfile = atom<string | null>(null)
 
 // Bumped whenever the open session should be dropped for a fresh new-session
-// draft: a profile switch/create (below), or deleting the project that owns the
-// currently-open session (store/projects). The chat controller subscribes and
-// resets to the intro draft, so we never strand the user in an orphaned view.
+// draft: a per-profile "+" (newSessionInProfile below), or deleting the project
+// that owns the currently-open session (store/projects). The chat controller
+// subscribes and resets to the intro draft, so we never strand the user in an
+// orphaned view. A plain profile SWITCH no longer routes through here — it
+// fires $profileRestoreRequest instead so the controller can resume that
+// profile's remembered session (falling back to a fresh draft).
 export const $freshSessionRequest = atom(0)
 
 export function requestFreshSession(): void {
   $freshSessionRequest.set($freshSessionRequest.get() + 1)
 }
 
+// ── Per-profile last-session memory ────────────────────────────────────────
+// Stored id of the last chat each profile had open, so hopping A → B → A lands
+// back in A's conversation instead of a blank draft every time. Same idiom as
+// the global lastSessionId relaunch memo (store/session), but keyed by profile.
+const PROFILE_LAST_SESSIONS_STORAGE_KEY = 'hermes.desktop.profileLastSessions'
+
+export const $profileLastSessions = atom<Record<string, string>>(storedStringRecord(PROFILE_LAST_SESSIONS_STORAGE_KEY))
+
+$profileLastSessions.subscribe(value => persistStringRecord(PROFILE_LAST_SESSIONS_STORAGE_KEY, value))
+
+// Which profile owns a stored session id, per the cross-profile aggregator's
+// tag. Falls back to the live gateway profile (a brand-new session created on
+// the active backend isn't in the list yet); returns null when the list hasn't
+// loaded and the id is unknown, so we never guess-attribute at cold start.
+export function profileKeyForSession(sessionId: string): null | string {
+  const sessions = $sessions.get()
+  const row = sessions.find(session => session.id === sessionId || session._lineage_root_id === sessionId)
+
+  if (row) {
+    return normalizeProfileKey(row.profile)
+  }
+
+  return sessions.length > 0 ? normalizeProfileKey($activeGatewayProfile.get()) : null
+}
+
+/** Memo the open session as its owning profile's "last session". No-ops when
+ *  the owner can't be attributed yet (session list not loaded). */
+export function rememberProfileSession(sessionId: string): void {
+  const key = profileKeyForSession(sessionId)
+
+  if (!key) {
+    return
+  }
+
+  const current = $profileLastSessions.get()
+
+  if (current[key] !== sessionId) {
+    $profileLastSessions.set({ ...current, [key]: sessionId })
+  }
+}
+
+export function rememberedProfileSession(profile: string): null | string {
+  return $profileLastSessions.get()[normalizeProfileKey(profile)] ?? null
+}
+
+/** Clear a profile's memo (its remembered session was deleted/archived). */
+export function forgetProfileSession(profile: string): void {
+  const key = normalizeProfileKey(profile)
+  const current = $profileLastSessions.get()
+
+  if (key in current) {
+    const next = { ...current }
+    delete next[key]
+    $profileLastSessions.set(next)
+  }
+}
+
+/** Drop a dead session id from EVERY profile memo (delete/archive/exhausted
+ *  resume) so no profile tries to restore it later. */
+export function forgetSessionMemo(sessionId: string): void {
+  const current = $profileLastSessions.get()
+  const survivors = Object.entries(current).filter(([, id]) => id !== sessionId)
+
+  if (survivors.length !== Object.keys(current).length) {
+    $profileLastSessions.set(Object.fromEntries(survivors))
+  }
+}
+
+/** True when `sessionId` is present, un-archived, in the loaded session list —
+ *  the cheap existence check before the by-id REST probe. */
+export function isSessionListed(sessions: SessionInfo[], sessionId: string): boolean {
+  return sessions.some(
+    session => !session.archived && (session.id === sessionId || session._lineage_root_id === sessionId)
+  )
+}
+
+// A profile switch asks the controller to restore that profile's last session
+// (or the explicit `sessionId`, for rail-badge clicks) instead of always
+// dropping to a blank draft. Token-guarded so a rapid second switch supersedes
+// a restore probe still in flight.
+export interface ProfileSessionRestoreRequest {
+  profile: string
+  /** Explicit target (rail badge click); null → use the per-profile memo. */
+  sessionId: null | string
+  token: number
+}
+
+export const $profileRestoreRequest = atom<null | ProfileSessionRestoreRequest>(null)
+
+let profileRestoreToken = 0
+
+function requestProfileSessionRestore(profile: string, sessionId: null | string): void {
+  $profileRestoreRequest.set({ profile, sessionId, token: ++profileRestoreToken })
+}
+
+// ── Per-profile activity (working / needs-input badges) ───────────────────
+// Sessions come pre-tagged with their owning profile by the cross-profile
+// aggregator; bucket the global working/attention sets by that tag so the
+// profile rail can badge each square without any extra fetching.
+
+export interface ProfileActivitySession {
+  id: string
+  lastActive: number
+  needsInput: boolean
+  title: null | string
+}
+
+export interface ProfileActivity {
+  /** Sessions blocked on the user (clarify/approval) — the amber badge. */
+  attention: ProfileActivitySession[]
+  /** Sessions with a turn running that are NOT waiting on the user. */
+  working: ProfileActivitySession[]
+}
+
+export function deriveProfileActivity(
+  sessions: SessionInfo[],
+  workingIds: string[],
+  attentionIds: string[]
+): Record<string, ProfileActivity> {
+  const working = new Set(workingIds)
+  const attention = new Set(attentionIds)
+  const result: Record<string, ProfileActivity> = {}
+
+  for (const session of sessions) {
+    const needsInput = attention.has(session.id)
+
+    if (!needsInput && !working.has(session.id)) {
+      continue
+    }
+
+    // The default profile keys as "default" everywhere in the rail (activeKey,
+    // hotkeys), whatever its directory name — mirror that here.
+    const key = session.is_default_profile ? 'default' : normalizeProfileKey(session.profile)
+    const entry = (result[key] ??= { attention: [], working: [] })
+
+    const row: ProfileActivitySession = {
+      id: session.id,
+      lastActive: session.last_active,
+      needsInput,
+      title: session.title
+    }
+
+    // "Needs input" wins over "working" (a clarify-blocked session is
+    // technically still running) — same precedence as the sidebar row dot.
+    ;(needsInput ? entry.attention : entry.working).push(row)
+  }
+
+  for (const entry of Object.values(result)) {
+    entry.attention.sort((a, b) => b.lastActive - a.lastActive)
+    entry.working.sort((a, b) => b.lastActive - a.lastActive)
+  }
+
+  return result
+}
+
+export const $profileActivity = computed([$sessions, $workingSessionIds, $attentionSessionIds], deriveProfileActivity)
+
+/** The session a badge click should open: blocked-on-you first, else the most
+ *  recently active working one. */
+export function neediestSessionId(activity: ProfileActivity | undefined): null | string {
+  return activity?.attention[0]?.id ?? activity?.working[0]?.id ?? null
+}
+
 // Route profile-scoped REST settings (config/env/skills/tools/model/…) to the
-// profile the live gateway is currently on, and drop cached settings from the
-// previous profile so pages refetch against the right backend. Fires once
-// immediately (no real change → no invalidation), so single-profile users just
-// get "default" (→ the primary backend) with no extra fetches.
+// profile the live gateway is currently on. Profile-scoped react-query keys
+// carry the profile segment (see activeProfileQueryKey), so a swap needs NO
+// cache invalidation: profile B's queries key differently than A's, A's cached
+// data can never render under B, and hopping back to A hits A's warm cache.
+// Only the starmap (a nanostore, not react-query) still resets by hand.
 let _lastRoutedProfile: string | null = null
 
 $activeGatewayProfile.subscribe(value => {
@@ -176,14 +342,20 @@ $activeGatewayProfile.subscribe(value => {
   setApiRequestProfile(key)
 
   if (_lastRoutedProfile !== null && _lastRoutedProfile !== key) {
-    // Profile-scoped settings + the unified session list are now stale.
-    void queryClient.invalidateQueries()
     resetStarmapGraph()
   }
 
   _lastRoutedProfile = key
 })
 
+/** Query-key segment for the profile the live gateway is on RIGHT NOW — for
+ *  imperative cache writes/invalidations. Reactive call sites should key off
+ *  `normalizeProfileKey(useStore($activeGatewayProfile))` instead so the query
+ *  re-keys when the gateway swaps. */
+export function activeProfileQueryKey(): string {
+  return normalizeProfileKey($activeGatewayProfile.get())
+}
+
 // Target profile while a gateway swap is mid-flight (spawning/reconnecting that
 // profile's backend), else null. Drives the chat's "waking up <profile>" loader
 // so a lazy spawn doesn't read as a hang. Single-profile users never swap.
@@ -300,19 +472,32 @@ export const $profileScope = computed([$showAllProfiles, $activeGatewayProfile],
 // $activeGatewayProfile → name, so $profileScope follows).
 export function selectProfile(name: string): void {
   const target = normalizeProfileKey(name)
-  // Switching profiles (or coming back from the all-profiles browse view) starts
-  // fresh; re-tapping the profile you're already in leaves your session be.
+  // Switching profiles (or coming back from the all-profiles browse view)
+  // restores that profile's last open session — fresh draft only when there's
+  // nothing to restore; re-tapping the profile you're already in leaves your
+  // session be.
   const switching = $showAllProfiles.get() || target !== normalizeProfileKey($activeGatewayProfile.get())
   $showAllProfiles.set(false)
   $newChatProfile.set(target)
 
   if (switching) {
-    requestFreshSession()
+    requestProfileSessionRestore(target, null)
   }
 
   void ensureGatewayProfile(target)
 }
 
+// Switch to `name` AND open a specific session — the profile-rail badge click,
+// which jumps straight to the session that needs you. Same context switch as
+// selectProfile, but the restore targets the given session instead of the memo.
+export function selectProfileSession(name: string, sessionId: string): void {
+  const target = normalizeProfileKey(name)
+  $showAllProfiles.set(false)
+  $newChatProfile.set(target)
+  requestProfileSessionRestore(target, sessionId)
+  void ensureGatewayProfile(target)
+}
+
 // Start a fresh session in `name` WITHOUT collapsing the "All profiles" browse
 // view. Unlike selectProfile, it leaves $showAllProfiles untouched, so the
 // unified sidebar stays put — used by the per-profile "+" in the all-profiles

From 32536819997ebc82a75cef7aae52f8e6fd01a506 Mon Sep 17 00:00:00 2001
From: Rod-fernandez <rodrigo@nxtlevelsaas.com>
Date: Sat, 4 Jul 2026 08:41:20 -0400
Subject: [PATCH 4/6] fix(desktop): clear the overlay close button in
 PanelHeader actions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The overlay X floats absolutely at right-3 (w = --titlebar-control-size)
and the panel header rides up into the titlebar band, so right-aligned
PanelHeader actions rendered underneath it (first visible in the kanban
view — 'New card' overlapped the close button).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/src/app/overlays/panel.tsx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/apps/desktop/src/app/overlays/panel.tsx b/apps/desktop/src/app/overlays/panel.tsx
index 60fc2ebfb3268..18cdfd50a25ae 100644
--- a/apps/desktop/src/app/overlays/panel.tsx
+++ b/apps/desktop/src/app/overlays/panel.tsx
@@ -75,7 +75,11 @@ export function PanelHeader({ actions, subtitle, title }: PanelHeaderProps) {
         <h2 className="text-sm font-semibold text-foreground">{title}</h2>
         {subtitle ? <p className="truncate text-xs text-muted-foreground/80">{subtitle}</p> : null}
       </div>
-      {actions ? <div className="flex shrink-0 items-center gap-1.5">{actions}</div> : null}
+      {/* The overlay close button floats absolutely at right-3 with
+          w-(--titlebar-control-size) and costs no layout space, and the header
+          rides up into the titlebar band — right-aligned actions must clear it
+          or they render underneath the X. */}
+      {actions ? <div className="flex shrink-0 items-center gap-1.5 pr-6">{actions}</div> : null}
     </header>
   )
 }

From 969d18664027b7bd955f877774bd145b12257026 Mon Sep 17 00:00:00 2001
From: Rod-fernandez <rodrigo@nxtlevelsaas.com>
Date: Sat, 4 Jul 2026 09:08:47 -0400
Subject: [PATCH 5/6] feat(desktop): kanban live events, attachment transfer,
 full ja/zh-hant coverage

- Live /api/plugins/kanban/events WebSocket: main-process mints authed WS
  URLs (loopback ?token= / OAuth single-use ?ticket=) with ?since= cursor
  and ?board= pinned at handshake; renderer singleton connection with
  250ms-coalesced refetch on events, catch-up on open, 1s..30s backoff;
  healthy socket stretches the 4s poll to a 60s safety net, any drop
  resumes fast polling. Stale preload degrades to polling.
- Attachments: download to ~/Downloads with collision resolution and a
  Reveal toast; multipart upload with a 25MB pre-check mirroring the
  backend cap; binary-capable authed fetch in main (token + OAuth modes);
  errors surface backend detail via parseKanbanApiError.
- ja.ts and zh-hant.ts gain all 360 keys missing relative to zh coverage
  (kanban, badges, overview, and long-standing gaps).
- PanelHeader actions now clear the floating overlay close button.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/electron/connection-config.cjs   |  33 ++
 .../electron/connection-config.test.cjs       |  49 +++
 apps/desktop/electron/kanban-attachments.cjs  | 103 +++++
 .../electron/kanban-attachments.test.cjs      |  88 ++++
 apps/desktop/electron/main.cjs                | 172 ++++++++
 apps/desktop/electron/preload.cjs             |   5 +
 apps/desktop/package.json                     |   2 +-
 .../src/app/kanban/card-drawer.test.tsx       | 195 +++++++++
 apps/desktop/src/app/kanban/card-drawer.tsx   | 110 ++++-
 apps/desktop/src/app/kanban/index.test.tsx    |  66 ++-
 apps/desktop/src/app/kanban/index.tsx         |  38 +-
 .../src/app/kanban/live-events.test.ts        | 253 +++++++++++
 apps/desktop/src/app/kanban/live-events.ts    | 237 ++++++++++
 apps/desktop/src/global.d.ts                  |  26 ++
 apps/desktop/src/i18n/en.ts                   |   8 +
 apps/desktop/src/i18n/ja.ts                   | 413 +++++++++++++++++-
 apps/desktop/src/i18n/types.ts                |   8 +
 apps/desktop/src/i18n/zh-hant.ts              | 406 ++++++++++++++++-
 apps/desktop/src/i18n/zh.ts                   |   8 +
 .../src/kanban-api.attachments.test.ts        |  58 +++
 apps/desktop/src/kanban-api.ts                |  43 ++
 apps/desktop/src/store/kanban.ts              |  11 +
 apps/desktop/src/types/kanban.ts              |   4 +
 23 files changed, 2302 insertions(+), 34 deletions(-)
 create mode 100644 apps/desktop/electron/kanban-attachments.cjs
 create mode 100644 apps/desktop/electron/kanban-attachments.test.cjs
 create mode 100644 apps/desktop/src/app/kanban/card-drawer.test.tsx
 create mode 100644 apps/desktop/src/app/kanban/live-events.test.ts
 create mode 100644 apps/desktop/src/app/kanban/live-events.ts
 create mode 100644 apps/desktop/src/kanban-api.attachments.test.ts

diff --git a/apps/desktop/electron/connection-config.cjs b/apps/desktop/electron/connection-config.cjs
index 12f7859640d8c..05bf94ca48c54 100644
--- a/apps/desktop/electron/connection-config.cjs
+++ b/apps/desktop/electron/connection-config.cjs
@@ -78,6 +78,38 @@ function buildGatewayWsUrlWithTicket(baseUrl, ticket) {
   return `${wsScheme}://${parsed.host}${prefix}/api/ws?ticket=${encodeURIComponent(ticket)}`
 }
 
+/**
+ * Build the kanban /events stream URL. Same WS gate as /api/ws (credential in
+ * the query string: `token` in loopback/token mode, single-use `ticket` on an
+ * OAuth-gated gateway), plus the stream's own params: `since` seeds the event
+ * cursor (omitted at <= 0 so the server starts from "now"), `board` pins the
+ * board at the handshake (the UI reconnects to switch boards).
+ *
+ * @param {string} baseUrl
+ * @param {['token'|'ticket', string]} authParam
+ * @param {{ since?: number, board?: string|null }} [options]
+ */
+function buildKanbanEventsWsUrl(baseUrl, authParam, options = {}) {
+  const parsed = new URL(baseUrl)
+  const wsScheme = parsed.protocol === 'https:' ? 'wss' : 'ws'
+  const prefix = parsed.pathname.replace(/\/+$/, '')
+  const params = new URLSearchParams()
+
+  params.set(authParam[0] === 'ticket' ? 'ticket' : 'token', String(authParam[1] ?? ''))
+
+  const since = Math.floor(Number(options.since))
+  if (Number.isFinite(since) && since > 0) {
+    params.set('since', String(since))
+  }
+
+  const board = String(options.board ?? '').trim()
+  if (board) {
+    params.set('board', board)
+  }
+
+  return `${wsScheme}://${parsed.host}${prefix}/api/plugins/kanban/events?${params.toString()}`
+}
+
 /**
  * Build the WS URL the renderer would connect with, so the connection test can
  * exercise the same transport the app actually uses.
@@ -270,6 +302,7 @@ module.exports = {
   authModeFromStatus,
   buildGatewayWsUrl,
   buildGatewayWsUrlWithTicket,
+  buildKanbanEventsWsUrl,
   connectionScopeKey,
   cookiesHaveSession,
   cookiesHaveLiveSession,
diff --git a/apps/desktop/electron/connection-config.test.cjs b/apps/desktop/electron/connection-config.test.cjs
index 1c7330e78d092..451c815b4e61f 100644
--- a/apps/desktop/electron/connection-config.test.cjs
+++ b/apps/desktop/electron/connection-config.test.cjs
@@ -19,6 +19,7 @@ const {
   authModeFromStatus,
   buildGatewayWsUrl,
   buildGatewayWsUrlWithTicket,
+  buildKanbanEventsWsUrl,
   connectionScopeKey,
   cookiesHaveSession,
   cookiesHaveLiveSession,
@@ -213,6 +214,54 @@ test('buildGatewayWsUrlWithTicket url-encodes the ticket', () => {
   assert.equal(buildGatewayWsUrlWithTicket('https://host', 'a+b/c'), 'wss://host/api/ws?ticket=a%2Bb%2Fc')
 })
 
+// --- buildKanbanEventsWsUrl ---
+
+test('buildKanbanEventsWsUrl (token mode) carries token + since + board', () => {
+  const url = buildKanbanEventsWsUrl('http://127.0.0.1:8321', ['token', 'tok 1'], { since: 42, board: 'ops' })
+  assert.equal(url, 'ws://127.0.0.1:8321/api/plugins/kanban/events?token=tok+1&since=42&board=ops')
+})
+
+test('buildKanbanEventsWsUrl (ticket mode) uses ?ticket= and wss on https', () => {
+  const url = buildKanbanEventsWsUrl('https://gw.example.com', ['ticket', 'tkt-9'], { since: 7 })
+  assert.equal(url, 'wss://gw.example.com/api/plugins/kanban/events?ticket=tkt-9&since=7')
+  assert.ok(!url.includes('token='))
+})
+
+test('buildKanbanEventsWsUrl honors a path prefix', () => {
+  const url = buildKanbanEventsWsUrl('https://host/hermes/', ['token', 't'], {})
+  assert.equal(url, 'wss://host/hermes/api/plugins/kanban/events?token=t')
+})
+
+test('buildKanbanEventsWsUrl omits since when zero/negative/NaN and board when blank', () => {
+  assert.equal(
+    buildKanbanEventsWsUrl('http://host', ['token', 't'], { since: 0, board: '' }),
+    'ws://host/api/plugins/kanban/events?token=t'
+  )
+  assert.equal(
+    buildKanbanEventsWsUrl('http://host', ['token', 't'], { since: -3, board: '   ' }),
+    'ws://host/api/plugins/kanban/events?token=t'
+  )
+  assert.equal(
+    buildKanbanEventsWsUrl('http://host', ['token', 't'], { since: Number.NaN }),
+    'ws://host/api/plugins/kanban/events?token=t'
+  )
+  assert.equal(buildKanbanEventsWsUrl('http://host', ['token', 't']), 'ws://host/api/plugins/kanban/events?token=t')
+})
+
+test('buildKanbanEventsWsUrl floors fractional since values', () => {
+  assert.equal(
+    buildKanbanEventsWsUrl('http://host', ['token', 't'], { since: 9.7 }),
+    'ws://host/api/plugins/kanban/events?token=t&since=9'
+  )
+})
+
+test('buildKanbanEventsWsUrl url-encodes the credential and board', () => {
+  assert.equal(
+    buildKanbanEventsWsUrl('http://host', ['ticket', 'a+b/c'], { board: 'my board' }),
+    'ws://host/api/plugins/kanban/events?ticket=a%2Bb%2Fc&board=my+board'
+  )
+})
+
 // --- authModeFromStatus ---
 
 test('authModeFromStatus returns oauth when auth_required is true', () => {
diff --git a/apps/desktop/electron/kanban-attachments.cjs b/apps/desktop/electron/kanban-attachments.cjs
new file mode 100644
index 0000000000000..17ccbd13a2dc5
--- /dev/null
+++ b/apps/desktop/electron/kanban-attachments.cjs
@@ -0,0 +1,103 @@
+'use strict'
+
+const path = require('node:path')
+
+// Mirror of the backend's per-upload cap (plugins/kanban/dashboard/
+// plugin_api.py _MAX_ATTACHMENT_BYTES). Checked before buffering so a huge
+// pick fails fast with the same 413 detail the backend would return, instead
+// of shipping 2 GB over IPC just to be rejected.
+const MAX_KANBAN_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
+function attachmentSizeError() {
+  const detail = `attachment exceeds ${MAX_KANBAN_ATTACHMENT_BYTES / (1024 * 1024)} MB limit`
+  return new Error(`413: ${JSON.stringify({ detail })}`)
+}
+
+// Same reduction the backend applies (_safe_attachment_name): strip directory
+// components on both separators, drop control chars and leading dots. The
+// server already sanitised the stored filename, but the download target is
+// joined under the user's Downloads dir, so never trust it verbatim.
+function safeAttachmentBasename(raw) {
+  let name = String(raw || '')
+    .replace(/\\/g, '/')
+    .split('/')
+    .pop()
+    .trim()
+  name = Array.from(name)
+    .filter(ch => ch >= ' ' && ch !== '\x7f')
+    .join('')
+    .trim()
+  name = name.replace(/^\.+/, '').trim()
+  if (!name) {
+    return 'attachment'
+  }
+  return name.slice(0, 200)
+}
+
+// Collision-resolved save path under `dir`: foo.pdf → foo (1).pdf → foo (2).pdf.
+// Splits at the FIRST dot to mirror the backend's collision naming, so a file
+// uploaded and downloaded twice round-trips to the same shape.
+function resolveDownloadTarget(dir, filename, exists) {
+  const safe = safeAttachmentBasename(filename)
+  const dotIndex = safe.indexOf('.')
+  const stem = dotIndex === -1 ? safe : safe.slice(0, dotIndex)
+  const ext = dotIndex === -1 ? '' : safe.slice(dotIndex)
+  let candidate = safe
+  let n = 1
+  while (exists(path.join(dir, candidate))) {
+    candidate = `${stem} (${n})${ext}`
+    n += 1
+  }
+  return path.join(dir, candidate)
+}
+
+// RFC 2388 multipart/form-data body for the kanban upload route
+// (POST /tasks/:id/attachments — fields: uploaded_by, file). Built as a
+// Buffer so binary payloads survive untouched.
+function buildKanbanAttachmentMultipart({ contentType, fileBuffer, filename, uploadedBy }, randomHex) {
+  if (!Buffer.isBuffer(fileBuffer)) {
+    throw new Error('buildKanbanAttachmentMultipart: fileBuffer must be a Buffer')
+  }
+  if (fileBuffer.length > MAX_KANBAN_ATTACHMENT_BYTES) {
+    throw attachmentSizeError()
+  }
+
+  const boundary = `----hermesKanbanAttachment${randomHex || Math.random().toString(16).slice(2)}`
+  // Quoted-string escaping for Content-Disposition; CR/LF cannot be escaped
+  // portably, so drop them outright.
+  const safeName = safeAttachmentBasename(filename).replace(/"/g, '%22')
+  const parts = []
+
+  if (uploadedBy) {
+    parts.push(
+      Buffer.from(
+        `--${boundary}\r\nContent-Disposition: form-data; name="uploaded_by"\r\n\r\n${uploadedBy}\r\n`,
+        'utf8'
+      )
+    )
+  }
+
+  parts.push(
+    Buffer.from(
+      `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${safeName}"\r\n` +
+        `Content-Type: ${contentType || 'application/octet-stream'}\r\n\r\n`,
+      'utf8'
+    ),
+    fileBuffer,
+    Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8')
+  )
+
+  return {
+    body: Buffer.concat(parts),
+    boundary,
+    contentType: `multipart/form-data; boundary=${boundary}`
+  }
+}
+
+module.exports = {
+  attachmentSizeError,
+  buildKanbanAttachmentMultipart,
+  MAX_KANBAN_ATTACHMENT_BYTES,
+  resolveDownloadTarget,
+  safeAttachmentBasename
+}
diff --git a/apps/desktop/electron/kanban-attachments.test.cjs b/apps/desktop/electron/kanban-attachments.test.cjs
new file mode 100644
index 0000000000000..0399ff8fc2b76
--- /dev/null
+++ b/apps/desktop/electron/kanban-attachments.test.cjs
@@ -0,0 +1,88 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const path = require('node:path')
+
+const {
+  buildKanbanAttachmentMultipart,
+  MAX_KANBAN_ATTACHMENT_BYTES,
+  resolveDownloadTarget,
+  safeAttachmentBasename
+} = require('./kanban-attachments.cjs')
+
+test('safeAttachmentBasename strips directories, control chars, and leading dots', () => {
+  assert.equal(safeAttachmentBasename('../../etc/passwd'), 'passwd')
+  assert.equal(safeAttachmentBasename('C:\\Users\\evil\\..\\notes.txt'), 'notes.txt')
+  assert.equal(safeAttachmentBasename('.hidden'), 'hidden')
+  assert.equal(safeAttachmentBasename('re\x00port\n.pdf'), 'report.pdf')
+  assert.equal(safeAttachmentBasename(''), 'attachment')
+  assert.equal(safeAttachmentBasename('...'), 'attachment')
+  assert.equal(safeAttachmentBasename(`${'a'.repeat(300)}.txt`).length, 200)
+})
+
+test('resolveDownloadTarget keeps the name when free', () => {
+  const target = resolveDownloadTarget('/downloads', 'report.pdf', () => false)
+  assert.equal(target, path.join('/downloads', 'report.pdf'))
+})
+
+test('resolveDownloadTarget resolves collisions like the backend (first-dot split)', () => {
+  const taken = new Set([
+    path.join('/downloads', 'archive.tar.gz'),
+    path.join('/downloads', 'archive (1).tar.gz')
+  ])
+  const target = resolveDownloadTarget('/downloads', 'archive.tar.gz', p => taken.has(p))
+  assert.equal(target, path.join('/downloads', 'archive (2).tar.gz'))
+})
+
+test('resolveDownloadTarget handles extensionless names', () => {
+  const taken = new Set([path.join('/downloads', 'Makefile')])
+  const target = resolveDownloadTarget('/downloads', 'Makefile', p => taken.has(p))
+  assert.equal(target, path.join('/downloads', 'Makefile (1)'))
+})
+
+test('buildKanbanAttachmentMultipart emits uploaded_by and file parts with the boundary', () => {
+  const payload = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x00, 0xff])
+  const { body, boundary, contentType } = buildKanbanAttachmentMultipart(
+    {
+      contentType: 'image/png',
+      fileBuffer: payload,
+      filename: 'shot.png',
+      uploadedBy: 'desktop'
+    },
+    'deadbeef'
+  )
+
+  assert.equal(boundary, '----hermesKanbanAttachmentdeadbeef')
+  assert.equal(contentType, `multipart/form-data; boundary=${boundary}`)
+
+  const text = body.toString('latin1')
+  assert.match(text, /Content-Disposition: form-data; name="uploaded_by"\r\n\r\ndesktop\r\n/)
+  assert.match(text, /Content-Disposition: form-data; name="file"; filename="shot.png"\r\n/)
+  assert.match(text, /Content-Type: image\/png\r\n\r\n/)
+  assert.ok(text.endsWith(`\r\n--${boundary}--\r\n`))
+  // The binary payload must survive byte-for-byte inside the body.
+  assert.notEqual(body.indexOf(payload), -1)
+})
+
+test('buildKanbanAttachmentMultipart escapes quotes and strips paths from the filename', () => {
+  const { body } = buildKanbanAttachmentMultipart(
+    {
+      fileBuffer: Buffer.from('x'),
+      filename: '../dir/we"ird.txt'
+    },
+    'cafe'
+  )
+  const text = body.toString('utf8')
+  assert.match(text, /filename="we%22ird.txt"/)
+  assert.doesNotMatch(text, /name="uploaded_by"/)
+  assert.match(text, /Content-Type: application\/octet-stream\r\n/)
+})
+
+test('buildKanbanAttachmentMultipart rejects payloads over the backend cap with a 413-shaped error', () => {
+  const big = Buffer.alloc(MAX_KANBAN_ATTACHMENT_BYTES + 1)
+  assert.throws(
+    () => buildKanbanAttachmentMultipart({ fileBuffer: big, filename: 'big.bin' }),
+    /^Error: 413: .*25 MB limit/
+  )
+})
diff --git a/apps/desktop/electron/main.cjs b/apps/desktop/electron/main.cjs
index bd6b867fac0d9..3c54480332ba4 100644
--- a/apps/desktop/electron/main.cjs
+++ b/apps/desktop/electron/main.cjs
@@ -55,6 +55,12 @@ const {
   macTitleBarOverlayHeight
 } = require('./titlebar-overlay-width.cjs')
 const { readDirForIpc } = require('./fs-read-dir.cjs')
+const {
+  attachmentSizeError: kanbanAttachmentSizeError,
+  buildKanbanAttachmentMultipart,
+  MAX_KANBAN_ATTACHMENT_BYTES,
+  resolveDownloadTarget: resolveKanbanDownloadTarget
+} = require('./kanban-attachments.cjs')
 const { readLiveUpdateMarker } = require('./update-marker.cjs')
 const {
   resolveUnpackedRelease,
@@ -107,6 +113,7 @@ const {
   authModeFromStatus,
   buildGatewayWsUrl,
   buildGatewayWsUrlWithTicket,
+  buildKanbanEventsWsUrl,
   connectionScopeKey,
   cookiesHaveSession,
   cookiesHaveLiveSession,
@@ -3385,6 +3392,111 @@ function fetchPublicJson(url, options = {}) {
   })
 }
 
+// Binary-capable authed request against the Hermes backend, for payloads the
+// JSON-only fetchJson / 'hermes:api' pipe can't carry (kanban attachment blobs
+// and multipart uploads). Same auth split as the REST path: OAuth gateways go
+// through the OAuth session partition so the HttpOnly cookie attaches; token /
+// local modes send the static session-token header. HTTP errors reject as
+// `Error("<status>: <body>")` so the renderer's parseKanbanApiError can
+// surface FastAPI detail text unchanged.
+function fetchBackendBuffer(connection, requestPath, options = {}) {
+  const url = `${connection.baseUrl}${requestPath}`
+  const timeoutMs = resolveTimeoutMs(options.timeoutMs, DEFAULT_FETCH_TIMEOUT_MS)
+
+  if (connection.authMode === 'oauth') {
+    return new Promise((resolve, reject) => {
+      const sess = getOauthSession()
+      if (!sess) {
+        reject(new Error('OAuth session partition is unavailable.'))
+        return
+      }
+      const request = electronNet.request({
+        method: options.method || 'GET',
+        url,
+        session: sess,
+        useSessionCookies: true,
+        redirect: 'follow'
+      })
+      if (options.contentType) request.setHeader('Content-Type', options.contentType)
+
+      let timedOut = false
+      const timer = setTimeout(() => {
+        timedOut = true
+        try {
+          request.abort()
+        } catch {
+          // already finished
+        }
+        reject(new Error(`Timed out connecting to Hermes backend after ${timeoutMs}ms`))
+      }, timeoutMs)
+
+      request.on('response', res => {
+        const chunks = []
+        res.on('data', chunk => chunks.push(Buffer.from(chunk)))
+        res.on('end', () => {
+          if (timedOut) return
+          clearTimeout(timer)
+          const buffer = Buffer.concat(chunks)
+          const statusCode = res.statusCode || 500
+          if (statusCode >= 400) {
+            reject(new Error(`${statusCode}: ${buffer.toString('utf8')}`))
+            return
+          }
+          resolve({ buffer, contentType: String(res.headers['content-type'] || '') })
+        })
+      })
+      request.on('error', error => {
+        if (timedOut) return
+        clearTimeout(timer)
+        reject(error)
+      })
+      if (options.body) request.write(options.body)
+      request.end()
+    })
+  }
+
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url)
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+      reject(new Error(`Unsupported Hermes backend URL protocol: ${parsed.protocol}`))
+      return
+    }
+    const client = parsed.protocol === 'https:' ? https : http
+
+    const req = client.request(
+      parsed,
+      {
+        method: options.method || 'GET',
+        headers: {
+          'X-Hermes-Session-Token': connection.token,
+          ...(options.contentType ? { 'Content-Type': options.contentType } : {}),
+          ...(options.body ? { 'Content-Length': String(options.body.length) } : {})
+        }
+      },
+      res => {
+        const chunks = []
+        res.on('error', reject)
+        res.on('data', chunk => chunks.push(chunk))
+        res.on('end', () => {
+          const buffer = Buffer.concat(chunks)
+          if ((res.statusCode || 500) >= 400) {
+            reject(new Error(`${res.statusCode}: ${buffer.toString('utf8') || res.statusMessage}`))
+            return
+          }
+          resolve({ buffer, contentType: String(res.headers['content-type'] || '') })
+        })
+      }
+    )
+
+    req.on('error', reject)
+    req.setTimeout(timeoutMs, () => {
+      req.destroy(new Error(`Timed out connecting to Hermes backend after ${timeoutMs}ms`))
+    })
+    if (options.body) req.write(options.body)
+    req.end()
+  })
+}
+
 function mimeTypeForPath(filePath) {
   const ext = path.extname(filePath || '').toLowerCase()
 
@@ -4634,6 +4746,22 @@ async function freshGatewayWsUrl(profile) {
   return connection.wsUrl
 }
 
+// Mint a fresh URL for the kanban /events stream. Always the PRIMARY backend:
+// kanban is HOME-scoped (the board is the shared cross-profile coordination
+// bus), so like the kanban REST calls it never routes to a pool profile.
+// Fresh per call for the same reason as freshGatewayWsUrl — OAuth WS tickets
+// are single-use with a ~30s TTL, so the renderer mints immediately before
+// every connect/reconnect.
+async function freshKanbanEventsWsUrl(options = {}) {
+  const connection = await ensureBackend(null)
+  const params = { since: options?.since, board: options?.board }
+  if (connection.authMode === 'oauth') {
+    const ticket = await mintGatewayWsTicket(connection.baseUrl)
+    return buildKanbanEventsWsUrl(connection.baseUrl, ['ticket', ticket], params)
+  }
+  return buildKanbanEventsWsUrl(connection.baseUrl, ['token', connection.token], params)
+}
+
 function encryptDesktopSecret(value) {
   return encryptDesktopSecretStrict(value, safeStorage)
 }
@@ -6103,6 +6231,7 @@ ipcMain.handle('hermes:backend:touch', async (_event, profile) => {
   return { ok: true }
 })
 ipcMain.handle('hermes:gateway:ws-url', async (_event, profile) => freshGatewayWsUrl(profile))
+ipcMain.handle('hermes:kanban:events-ws-url', async (_event, options) => freshKanbanEventsWsUrl(options))
 ipcMain.handle('hermes:window:openSession', async (_event, sessionId, opts) => {
   if (typeof sessionId !== 'string' || !sessionId.trim()) {
     return { ok: false, error: 'invalid-session-id' }
@@ -6542,6 +6671,49 @@ ipcMain.handle('hermes:api', async (_event, request) => {
   })
 })
 
+// Kanban attachments move real bytes, which the JSON-only 'hermes:api' pipe
+// can't carry. Download: authed GET → collision-resolved save under the OS
+// Downloads dir (the renderer toasts with a reveal action). Upload: main reads
+// the picked file (the renderer only ever holds a path) and multipart-POSTs it
+// per the backend contract. Kanban is HOME-scoped, so both always target the
+// primary backend — never a pool profile.
+ipcMain.handle('hermes:kanban:attachment:download', async (_event, request) => {
+  const connection = await ensureBackend(null)
+  const { buffer } = await fetchBackendBuffer(connection, String(request?.path || ''), {
+    timeoutMs: 120_000
+  })
+  const target = resolveKanbanDownloadTarget(app.getPath('downloads'), String(request?.filename || ''), fs.existsSync)
+  await fs.promises.mkdir(path.dirname(target), { recursive: true })
+  await fs.promises.writeFile(target, buffer)
+  return { path: target }
+})
+
+ipcMain.handle('hermes:kanban:attachment:upload', async (_event, request) => {
+  const { resolvedPath, stat } = await resolveReadableFileForIpc(String(request?.filePath || ''), {
+    purpose: 'Kanban attachment'
+  })
+  // Pre-check the backend's 25 MB cap with the same 413 detail it would
+  // return, instead of buffering a huge file just to have it rejected.
+  if (stat.size > MAX_KANBAN_ATTACHMENT_BYTES) {
+    throw kanbanAttachmentSizeError()
+  }
+  const connection = await ensureBackend(null)
+  const { body, contentType } = buildKanbanAttachmentMultipart({
+    contentType: mimeTypeForPath(resolvedPath),
+    fileBuffer: await fs.promises.readFile(resolvedPath),
+    filename: path.basename(resolvedPath),
+    uploadedBy: request?.uploadedBy ? String(request.uploadedBy) : 'desktop'
+  })
+  const { buffer } = await fetchBackendBuffer(connection, String(request?.path || ''), {
+    body,
+    contentType,
+    method: 'POST',
+    timeoutMs: 120_000
+  })
+  const text = buffer.toString('utf8')
+  return text ? JSON.parse(text) : null
+})
+
 ipcMain.handle('hermes:notify', (_event, payload) => {
   if (!Notification.isSupported()) return false
   // Action buttons render only on signed macOS builds; elsewhere they're dropped
diff --git a/apps/desktop/electron/preload.cjs b/apps/desktop/electron/preload.cjs
index aa8bcc1612840..6e9991ca7b1f4 100644
--- a/apps/desktop/electron/preload.cjs
+++ b/apps/desktop/electron/preload.cjs
@@ -5,6 +5,7 @@ contextBridge.exposeInMainWorld('hermesDesktop', {
   revalidateConnection: () => ipcRenderer.invoke('hermes:connection:revalidate'),
   touchBackend: profile => ipcRenderer.invoke('hermes:backend:touch', profile),
   getGatewayWsUrl: profile => ipcRenderer.invoke('hermes:gateway:ws-url', profile),
+  getKanbanEventsWsUrl: options => ipcRenderer.invoke('hermes:kanban:events-ws-url', options),
   openSessionWindow: (sessionId, opts) => ipcRenderer.invoke('hermes:window:openSession', sessionId, opts),
   openNewSessionWindow: () => ipcRenderer.invoke('hermes:window:openNewSession'),
   petOverlay: {
@@ -46,6 +47,10 @@ contextBridge.exposeInMainWorld('hermesDesktop', {
     set: name => ipcRenderer.invoke('hermes:profile:set', name)
   },
   api: request => ipcRenderer.invoke('hermes:api', request),
+  kanbanAttachment: {
+    download: request => ipcRenderer.invoke('hermes:kanban:attachment:download', request),
+    upload: request => ipcRenderer.invoke('hermes:kanban:attachment:upload', request)
+  },
   notify: payload => ipcRenderer.invoke('hermes:notify', payload),
   requestMicrophoneAccess: () => ipcRenderer.invoke('hermes:requestMicrophoneAccess'),
   readFileDataUrl: filePath => ipcRenderer.invoke('hermes:readFileDataUrl', filePath),
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 6fd35c0fbc47d..2fb280c0819c1 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -37,7 +37,7 @@
     "test:desktop:nsis": "node scripts/test-desktop.mjs nsis",
     "test:desktop:existing": "node scripts/test-desktop.mjs existing",
     "test:desktop:fresh": "node scripts/test-desktop.mjs fresh",
-    "test:desktop:platforms": "node --test electron/bootstrap-platform.test.cjs electron/hardening.test.cjs electron/backend-env.test.cjs electron/backend-probes.test.cjs electron/backend-ready.test.cjs electron/bootstrap-runner.test.cjs electron/connection-config.test.cjs electron/dashboard-token.test.cjs electron/gateway-ws-probe.test.cjs electron/oauth-net-request.test.cjs electron/desktop-uninstall.test.cjs electron/session-windows.test.cjs electron/link-title-window.test.cjs electron/workspace-cwd.test.cjs electron/fs-read-dir.test.cjs electron/git-root.test.cjs electron/git-worktree-ops.test.cjs electron/windows-child-process.test.cjs electron/update-remote.test.cjs electron/update-count.test.cjs electron/update-rebuild.test.cjs electron/update-marker.test.cjs electron/update-relaunch.test.cjs electron/windows-user-env.test.cjs electron/wsl-clipboard-image.test.cjs electron/titlebar-overlay-width.test.cjs electron/window-state.test.cjs electron/windows-hermes-resolution.test.cjs",
+    "test:desktop:platforms": "node --test electron/bootstrap-platform.test.cjs electron/hardening.test.cjs electron/backend-env.test.cjs electron/backend-probes.test.cjs electron/backend-ready.test.cjs electron/bootstrap-runner.test.cjs electron/connection-config.test.cjs electron/dashboard-token.test.cjs electron/gateway-ws-probe.test.cjs electron/oauth-net-request.test.cjs electron/desktop-uninstall.test.cjs electron/session-windows.test.cjs electron/link-title-window.test.cjs electron/workspace-cwd.test.cjs electron/fs-read-dir.test.cjs electron/git-root.test.cjs electron/git-worktree-ops.test.cjs electron/windows-child-process.test.cjs electron/update-remote.test.cjs electron/update-count.test.cjs electron/update-rebuild.test.cjs electron/update-marker.test.cjs electron/update-relaunch.test.cjs electron/windows-user-env.test.cjs electron/wsl-clipboard-image.test.cjs electron/titlebar-overlay-width.test.cjs electron/window-state.test.cjs electron/windows-hermes-resolution.test.cjs electron/kanban-attachments.test.cjs",
     "typecheck": "tsc -p . --noEmit",
     "lint": "eslint src/ electron/",
     "lint:fix": "eslint src/ electron/ --fix",
diff --git a/apps/desktop/src/app/kanban/card-drawer.test.tsx b/apps/desktop/src/app/kanban/card-drawer.test.tsx
new file mode 100644
index 0000000000000..97ec47cec2aa5
--- /dev/null
+++ b/apps/desktop/src/app/kanban/card-drawer.test.tsx
@@ -0,0 +1,195 @@
+// @vitest-environment jsdom
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $kanbanActiveBoard, $kanbanBoard } from '@/store/kanban'
+import { $notifications, clearNotifications } from '@/store/notifications'
+import type { KanbanAttachment, KanbanTaskDetail } from '@/types/kanban'
+
+import { KanbanCardDrawer } from './card-drawer'
+
+function attachment(id: number, filename: string, extra: Partial<KanbanAttachment> = {}): KanbanAttachment {
+  return {
+    id,
+    task_id: 't_1',
+    filename,
+    content_type: 'application/pdf',
+    size: 2048,
+    uploaded_by: 'desktop',
+    stored_path: `/data/attachments/t_1/${filename}`,
+    created_at: 100,
+    ...extra
+  }
+}
+
+function detailPayload(attachments: KanbanAttachment[]): KanbanTaskDetail {
+  return {
+    task: {
+      id: 't_1',
+      title: 'Ship it',
+      body: null,
+      assignee: 'coder',
+      status: 'todo',
+      priority: 0,
+      created_by: 'test',
+      created_at: 1,
+      started_at: null,
+      completed_at: null,
+      workspace_kind: 'scratch',
+      workspace_path: null,
+      claim_lock: null,
+      claim_expires: null,
+      tenant: null
+    },
+    comments: [],
+    events: [],
+    attachments,
+    links: { parents: [], children: [] },
+    runs: []
+  }
+}
+
+describe('KanbanCardDrawer attachments', () => {
+  let api: ReturnType<typeof vi.fn>
+  let download: ReturnType<typeof vi.fn>
+  let upload: ReturnType<typeof vi.fn>
+  let selectPaths: ReturnType<typeof vi.fn>
+  let revealPath: ReturnType<typeof vi.fn>
+  let detail: KanbanTaskDetail
+
+  beforeEach(() => {
+    detail = detailPayload([attachment(7, 'spec.pdf'), attachment(8, 'notes.txt', { size: 10, content_type: null })])
+    api = vi.fn(async (request: { path: string }) => {
+      if (request.path.startsWith('/api/plugins/kanban/tasks/t_1')) {
+        return detail
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/assignees')) {
+        return { assignees: [] }
+      }
+
+      if (request.path.startsWith('/api/plugins/kanban/board')) {
+        return { columns: [], tenants: [], assignees: [], latest_event_id: 1, now: 1 }
+      }
+
+      throw new Error(`unexpected path ${request.path}`)
+    })
+    download = vi.fn(async () => ({ path: '/Users/me/Downloads/spec.pdf' }))
+    upload = vi.fn(async () => ({ attachment: attachment(9, 'added.png') }))
+    selectPaths = vi.fn(async () => ['/tmp/added.png'])
+    revealPath = vi.fn(async () => true)
+    Object.defineProperty(window, 'hermesDesktop', {
+      configurable: true,
+      value: { api, kanbanAttachment: { download, upload }, revealPath, selectPaths }
+    })
+    $kanbanActiveBoard.set('default')
+    $kanbanBoard.set(null)
+    clearNotifications()
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+    Reflect.deleteProperty(window, 'hermesDesktop')
+    clearNotifications()
+  })
+
+  it('renders attachment names and sizes', async () => {
+    render(<KanbanCardDrawer onClose={() => undefined} taskId="t_1" />)
+
+    expect(await screen.findByText('spec.pdf')).toBeTruthy()
+    expect(screen.getByText('notes.txt')).toBeTruthy()
+    expect(screen.getByText('2.0 KB')).toBeTruthy()
+    expect(screen.getByText('10 B')).toBeTruthy()
+  })
+
+  it('downloads on click and toasts with a reveal action', async () => {
+    render(<KanbanCardDrawer onClose={() => undefined} taskId="t_1" />)
+
+    fireEvent.click(await screen.findByRole('button', { name: 'Download spec.pdf' }))
+
+    await waitFor(() => expect(download).toHaveBeenCalledTimes(1))
+    expect(download).toHaveBeenCalledWith({
+      path: '/api/plugins/kanban/attachments/7?board=default',
+      filename: 'spec.pdf'
+    })
+
+    await waitFor(() => {
+      const toast = $notifications.get()[0]
+
+      expect(toast?.kind).toBe('success')
+      expect(toast?.message).toBe('Saved spec.pdf to Downloads')
+      expect(toast?.action?.label).toBe('Reveal')
+    })
+
+    $notifications.get()[0]?.action?.onClick()
+    expect(revealPath).toHaveBeenCalledWith('/Users/me/Downloads/spec.pdf')
+  })
+
+  it('surfaces the backend detail when a download fails', async () => {
+    download.mockRejectedValueOnce(
+      new Error(
+        "Error invoking remote method 'hermes:kanban:attachment:download': Error: 404: " +
+          '{"detail":"attachment file missing on disk"}'
+      )
+    )
+    render(<KanbanCardDrawer onClose={() => undefined} taskId="t_1" />)
+
+    fireEvent.click(await screen.findByRole('button', { name: 'Download spec.pdf' }))
+
+    await waitFor(() => {
+      const toast = $notifications.get()[0]
+
+      expect(toast?.kind).toBe('error')
+      expect(toast?.message).toBe('attachment file missing on disk')
+    })
+  })
+
+  it('uploads picked files and refetches the detail', async () => {
+    render(<KanbanCardDrawer onClose={() => undefined} taskId="t_1" />)
+    await screen.findByText('spec.pdf')
+
+    const detailFetches = api.mock.calls.filter(([request]) =>
+      (request as { path: string }).path.startsWith('/api/plugins/kanban/tasks/t_1')
+    ).length
+
+    detail = detailPayload([attachment(7, 'spec.pdf'), attachment(8, 'notes.txt'), attachment(9, 'added.png')])
+    fireEvent.click(screen.getByRole('button', { name: /Add attachment/ }))
+
+    await waitFor(() => expect(upload).toHaveBeenCalledTimes(1))
+    expect(selectPaths).toHaveBeenCalledWith({ multiple: true, title: 'Add attachment' })
+    expect(upload).toHaveBeenCalledWith({
+      path: '/api/plugins/kanban/tasks/t_1/attachments?board=default',
+      filePath: '/tmp/added.png',
+      uploadedBy: 'desktop'
+    })
+
+    expect(await screen.findByText('added.png')).toBeTruthy()
+    expect(
+      api.mock.calls.filter(([request]) =>
+        (request as { path: string }).path.startsWith('/api/plugins/kanban/tasks/t_1')
+      ).length
+    ).toBeGreaterThan(detailFetches)
+  })
+
+  it('surfaces the backend detail when an upload is rejected', async () => {
+    upload.mockRejectedValueOnce(
+      new Error(
+        "Error invoking remote method 'hermes:kanban:attachment:upload': Error: 413: " +
+          '{"detail":"attachment exceeds 25 MB limit"}'
+      )
+    )
+    render(<KanbanCardDrawer onClose={() => undefined} taskId="t_1" />)
+    await screen.findByText('spec.pdf')
+
+    fireEvent.click(screen.getByRole('button', { name: /Add attachment/ }))
+
+    await waitFor(() => {
+      const toast = $notifications.get()[0]
+
+      expect(toast?.kind).toBe('error')
+      expect(toast?.title).toBe('Attachment upload failed')
+      expect(toast?.message).toBe('attachment exceeds 25 MB limit')
+    })
+  })
+})
diff --git a/apps/desktop/src/app/kanban/card-drawer.tsx b/apps/desktop/src/app/kanban/card-drawer.tsx
index 9814e2657fda9..7e33e4a5aae38 100644
--- a/apps/desktop/src/app/kanban/card-drawer.tsx
+++ b/apps/desktop/src/app/kanban/card-drawer.tsx
@@ -7,7 +7,16 @@ import { Input } from '@/components/ui/input'
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
 import { Textarea } from '@/components/ui/textarea'
 import { type Translations, useI18n } from '@/i18n'
-import { addKanbanComment, getKanbanAssignees, getKanbanTask, getKanbanTaskLog, updateKanbanTask } from '@/kanban-api'
+import {
+  addKanbanComment,
+  downloadKanbanAttachment,
+  getKanbanAssignees,
+  getKanbanTask,
+  getKanbanTaskLog,
+  parseKanbanApiError,
+  updateKanbanTask,
+  uploadKanbanAttachment
+} from '@/kanban-api'
 import { cn } from '@/lib/utils'
 import {
   $kanbanActiveBoard,
@@ -18,7 +27,7 @@ import {
   setKanbanSelectedTaskId
 } from '@/store/kanban'
 import { notify, notifyError } from '@/store/notifications'
-import type { KanbanRun, KanbanTaskDetail, KanbanUpdateTaskPayload } from '@/types/kanban'
+import type { KanbanAttachment, KanbanRun, KanbanTaskDetail, KanbanUpdateTaskPayload } from '@/types/kanban'
 
 import { PanelBlock, PanelPill, type PanelPillTone, PanelSectionLabel } from '../overlays/panel'
 
@@ -80,6 +89,8 @@ export function KanbanCardDrawer({ onClose, taskId }: KanbanCardDrawerProps) {
   const [saving, setSaving] = useState(false)
   const [commentDraft, setCommentDraft] = useState('')
   const [sendingComment, setSendingComment] = useState(false)
+  const [downloadingAttachmentId, setDownloadingAttachmentId] = useState<null | number>(null)
+  const [uploadingAttachment, setUploadingAttachment] = useState(false)
 
   const reload = useCallback(async () => {
     try {
@@ -166,6 +177,74 @@ export function KanbanCardDrawer({ onClose, taskId }: KanbanCardDrawerProps) {
     }
   }
 
+  async function downloadAttachment(attachment: KanbanAttachment) {
+    if (downloadingAttachmentId !== null) {
+      return
+    }
+
+    setDownloadingAttachmentId(attachment.id)
+
+    try {
+      const { path } = await downloadKanbanAttachment(attachment, $kanbanActiveBoard.get())
+
+      notify({
+        kind: 'success',
+        message: k.attachmentDownloaded(attachment.filename),
+        action: window.hermesDesktop.revealPath
+          ? { label: k.attachmentReveal, onClick: () => void window.hermesDesktop.revealPath?.(path) }
+          : undefined
+      })
+    } catch (error) {
+      notify({
+        kind: 'error',
+        title: k.attachmentDownloadFailed,
+        message: parseKanbanApiError(error).detail || k.attachmentDownloadFailed
+      })
+    } finally {
+      setDownloadingAttachmentId(null)
+    }
+  }
+
+  async function addAttachments() {
+    if (uploadingAttachment) {
+      return
+    }
+
+    const paths = await window.hermesDesktop.selectPaths({ multiple: true, title: k.addAttachment })
+
+    if (paths.length === 0) {
+      return
+    }
+
+    setUploadingAttachment(true)
+
+    let uploaded = 0
+
+    try {
+      for (const filePath of paths) {
+        await uploadKanbanAttachment(taskId, filePath, $kanbanActiveBoard.get())
+        uploaded += 1
+      }
+
+      notify({ kind: 'success', message: k.attachmentUploaded(uploaded) })
+    } catch (error) {
+      // Size/type rejections carry the backend's FastAPI detail (e.g. the
+      // 25 MB cap message) — surface it verbatim instead of a generic failure.
+      notify({
+        kind: 'error',
+        title: k.attachmentUploadFailed,
+        message: parseKanbanApiError(error).detail || k.attachmentUploadFailed
+      })
+    } finally {
+      setUploadingAttachment(false)
+    }
+
+    if (uploaded > 0) {
+      await reload()
+      void refreshKanbanBoard()
+    }
+  }
+
   const task = detail?.task
   const statusOptions = task ? [task.status, ...allowedDropColumns(task.status)] : []
 
@@ -383,21 +462,40 @@ export function KanbanCardDrawer({ onClose, taskId }: KanbanCardDrawerProps) {
               ) : (
                 <div className="space-y-px">
                   {detail.attachments.map(attachment => (
-                    <div
-                      className="flex items-center justify-between gap-2 rounded px-1.5 py-1 text-[0.7rem] text-foreground/85"
+                    <button
+                      aria-label={k.downloadAttachment(attachment.filename)}
+                      className="flex w-full items-center justify-between gap-2 rounded px-1.5 py-1 text-left text-[0.7rem] text-foreground/85 transition-colors hover:bg-foreground/8 disabled:opacity-60"
+                      disabled={downloadingAttachmentId !== null}
                       key={attachment.id}
+                      onClick={() => void downloadAttachment(attachment)}
+                      type="button"
                     >
                       <span className="flex min-w-0 items-center gap-1.5">
-                        <Codicon className="shrink-0 text-muted-foreground/55" name="file" size="0.75rem" />
+                        <Codicon
+                          className="shrink-0 text-muted-foreground/55"
+                          name={downloadingAttachmentId === attachment.id ? 'loading' : 'file'}
+                          size="0.75rem"
+                          spinning={downloadingAttachmentId === attachment.id}
+                        />
                         <span className="truncate">{attachment.filename}</span>
                       </span>
                       <span className="shrink-0 text-[0.62rem] tabular-nums text-muted-foreground/50">
                         {formatBytes(attachment.size)}
                       </span>
-                    </div>
+                    </button>
                   ))}
                 </div>
               )}
+              <Button
+                className="gap-1.5"
+                disabled={uploadingAttachment}
+                onClick={() => void addAttachments()}
+                size="sm"
+                variant="outline"
+              >
+                <Codicon name={uploadingAttachment ? 'loading' : 'add'} size="0.7rem" spinning={uploadingAttachment} />
+                {uploadingAttachment ? k.attachmentUploading : k.addAttachment}
+              </Button>
             </section>
 
             <section className="space-y-1.5">
diff --git a/apps/desktop/src/app/kanban/index.test.tsx b/apps/desktop/src/app/kanban/index.test.tsx
index 236b1bdbd21c8..763fe0866e827 100644
--- a/apps/desktop/src/app/kanban/index.test.tsx
+++ b/apps/desktop/src/app/kanban/index.test.tsx
@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import { cleanup, render, screen } from '@testing-library/react'
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import {
@@ -7,14 +7,22 @@ import {
   $kanbanBoard,
   $kanbanBoardError,
   $kanbanBoards,
+  $kanbanLiveConnected,
   $kanbanRefreshing,
   $kanbanSelectedTaskId,
   KANBAN_COLUMNS
 } from '@/store/kanban'
 import type { KanbanBoardPayload, KanbanCard } from '@/types/kanban'
 
+import { startKanbanLiveEvents, stopKanbanLiveEvents } from './live-events'
+
 import { KanbanView } from './index'
 
+vi.mock('./live-events', () => ({
+  startKanbanLiveEvents: vi.fn(),
+  stopKanbanLiveEvents: vi.fn()
+}))
+
 function card(id: string, status: string, extra: Partial<KanbanCard> = {}): KanbanCard {
   return {
     id,
@@ -85,6 +93,7 @@ describe('KanbanView', () => {
       value: { api }
     })
     window.localStorage.clear()
+    $kanbanLiveConnected.set(false)
     $kanbanBoards.set([])
     $kanbanActiveBoard.set(null)
     $kanbanBoard.set(null)
@@ -156,4 +165,59 @@ describe('KanbanView', () => {
     expect(screen.getByText('On it')).toBeTruthy()
     expect(screen.getByText('Run history')).toBeTruthy()
   })
+
+  it('starts the live event stream on mount and stops it on unmount', async () => {
+    const { unmount } = render(<KanbanView onClose={() => undefined} />)
+
+    expect(await screen.findByText('Task t_alpha')).toBeTruthy()
+    expect(startKanbanLiveEvents).toHaveBeenCalledWith(null)
+
+    vi.mocked(stopKanbanLiveEvents).mockClear()
+    unmount()
+    expect(stopKanbanLiveEvents).toHaveBeenCalled()
+  })
+
+  it('reopens the live stream pinned to the new board on board switch', async () => {
+    render(<KanbanView onClose={() => undefined} />)
+
+    expect(await screen.findByText('Task t_alpha')).toBeTruthy()
+    vi.mocked(startKanbanLiveEvents).mockClear()
+
+    act(() => {
+      $kanbanActiveBoard.set('ops')
+    })
+
+    await waitFor(() => expect(startKanbanLiveEvents).toHaveBeenCalledWith('ops'))
+  })
+
+  it('tears the live stream down while hidden and reopens it on show', async () => {
+    render(<KanbanView onClose={() => undefined} />)
+
+    expect(await screen.findByText('Task t_alpha')).toBeTruthy()
+
+    let visibility: DocumentVisibilityState = 'visible'
+
+    Object.defineProperty(document, 'visibilityState', {
+      configurable: true,
+      get: () => visibility
+    })
+
+    try {
+      vi.mocked(stopKanbanLiveEvents).mockClear()
+      visibility = 'hidden'
+      act(() => {
+        document.dispatchEvent(new Event('visibilitychange'))
+      })
+      expect(stopKanbanLiveEvents).toHaveBeenCalled()
+
+      vi.mocked(startKanbanLiveEvents).mockClear()
+      visibility = 'visible'
+      act(() => {
+        document.dispatchEvent(new Event('visibilitychange'))
+      })
+      expect(startKanbanLiveEvents).toHaveBeenCalledWith(null)
+    } finally {
+      Reflect.deleteProperty(document, 'visibilityState')
+    }
+  })
 })
diff --git a/apps/desktop/src/app/kanban/index.tsx b/apps/desktop/src/app/kanban/index.tsx
index c11013f30f84b..935f608761a71 100644
--- a/apps/desktop/src/app/kanban/index.tsx
+++ b/apps/desktop/src/app/kanban/index.tsx
@@ -26,6 +26,7 @@ import {
   $kanbanBoard,
   $kanbanBoardError,
   $kanbanBoards,
+  $kanbanLiveConnected,
   $kanbanSelectedTaskId,
   isAllowedDrop,
   KANBAN_COLUMNS,
@@ -42,13 +43,16 @@ import { useRefreshHotkey } from '../hooks/use-refresh-hotkey'
 import { Panel, PanelEmpty, PanelHeader } from '../overlays/panel'
 
 import { KanbanCardDrawer } from './card-drawer'
+import { startKanbanLiveEvents, stopKanbanLiveEvents } from './live-events'
 import { NewCardDialog } from './new-card-dialog'
 
-// Live updates via polling (WS /events plumbing is out of scope for v1): the
-// board payload's latest_event_id is the change cursor, so an unchanged poll
-// keeps the previous atom identity and re-renders nothing. Paused while the
-// window is hidden, same as the cron/messaging pollers.
+// Live updates ride the kanban /events WebSocket (live-events.ts); polling is
+// the fallback and the safety net. While the socket is down the board polls
+// fast; while it is healthy the poll stretches to a slow backstop (the
+// payload's latest_event_id cursor keeps unchanged polls render-free either
+// way). Paused while the window is hidden, same as the cron/messaging pollers.
 const BOARD_POLL_INTERVAL_MS = 4_000
+const BOARD_LIVE_POLL_INTERVAL_MS = 60_000
 
 const PRIORITY_TONE: Record<string, string> = {
   high: 'bg-destructive/10 text-destructive',
@@ -87,6 +91,7 @@ function KanbanBoardContent() {
   const board = useStore($kanbanBoard)
   const boardError = useStore($kanbanBoardError)
   const selectedTaskId = useStore($kanbanSelectedTaskId)
+  const liveConnected = useStore($kanbanLiveConnected)
 
   const [nudging, setNudging] = useState(false)
   const [newCardOpen, setNewCardOpen] = useState(false)
@@ -110,7 +115,7 @@ function KanbanBoardContent() {
       }
     }
 
-    const intervalId = window.setInterval(tick, BOARD_POLL_INTERVAL_MS)
+    const intervalId = window.setInterval(tick, liveConnected ? BOARD_LIVE_POLL_INTERVAL_MS : BOARD_POLL_INTERVAL_MS)
 
     document.addEventListener('visibilitychange', tick)
 
@@ -118,7 +123,28 @@ function KanbanBoardContent() {
       window.clearInterval(intervalId)
       document.removeEventListener('visibilitychange', tick)
     }
-  }, [])
+  }, [liveConnected])
+
+  // Live socket lifecycle: connected only while the board is mounted AND the
+  // window is visible; a board switch tears down and reopens with the new
+  // ?board (the stream pins the board at the handshake).
+  useEffect(() => {
+    const sync = () => {
+      if (document.visibilityState === 'visible') {
+        startKanbanLiveEvents(activeBoard)
+      } else {
+        stopKanbanLiveEvents()
+      }
+    }
+
+    sync()
+    document.addEventListener('visibilitychange', sync)
+
+    return () => {
+      document.removeEventListener('visibilitychange', sync)
+      stopKanbanLiveEvents()
+    }
+  }, [activeBoard])
 
   const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 6 } }))
 
diff --git a/apps/desktop/src/app/kanban/live-events.test.ts b/apps/desktop/src/app/kanban/live-events.test.ts
new file mode 100644
index 0000000000000..43466f76f1ddd
--- /dev/null
+++ b/apps/desktop/src/app/kanban/live-events.test.ts
@@ -0,0 +1,253 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  createKanbanLiveConnection,
+  type KanbanLiveHandle,
+  type KanbanLiveSocket,
+  LIVE_RECONNECT_BASE_MS,
+  LIVE_RECONNECT_MAX_MS,
+  LIVE_REFRESH_COALESCE_MS
+} from './live-events'
+
+class FakeSocket implements KanbanLiveSocket {
+  onclose: (() => void) | null = null
+  onerror: (() => void) | null = null
+  onmessage: ((event: { data: unknown }) => void) | null = null
+  onopen: (() => void) | null = null
+  closed = false
+
+  close(): void {
+    this.closed = true
+  }
+
+  open(): void {
+    this.onopen?.()
+  }
+
+  frame(events: unknown[]): void {
+    this.onmessage?.({ data: JSON.stringify({ events, cursor: 99 }) })
+  }
+
+  drop(): void {
+    this.onclose?.()
+  }
+}
+
+describe('createKanbanLiveConnection', () => {
+  let sockets: FakeSocket[]
+  let mintCalls: Array<{ board: null | string; since: number }>
+  let refresh: ReturnType<typeof vi.fn<() => void>>
+  let setConnected: ReturnType<typeof vi.fn<(connected: boolean) => void>>
+  let handle: KanbanLiveHandle | null
+  let since: number
+
+  const deps = () => ({
+    mintWsUrl: (options: { board: null | string; since: number }) => {
+      mintCalls.push(options)
+
+      return Promise.resolve(`ws://test/api/plugins/kanban/events?token=t&since=${options.since}`)
+    },
+    openSocket: () => {
+      const socket = new FakeSocket()
+
+      sockets.push(socket)
+
+      return socket
+    },
+    refresh,
+    setConnected,
+    getSince: () => since
+  })
+
+  // Let the async mint promise inside connect() settle without advancing timers.
+  const settle = async () => {
+    await Promise.resolve()
+    await Promise.resolve()
+  }
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    sockets = []
+    mintCalls = []
+    refresh = vi.fn<() => void>()
+    setConnected = vi.fn<(connected: boolean) => void>()
+    handle = null
+    since = 17
+  })
+
+  afterEach(() => {
+    handle?.stop()
+    vi.useRealTimers()
+  })
+
+  it('mints with the store cursor + board and reports connected on open', async () => {
+    handle = createKanbanLiveConnection('ops', deps())
+    await settle()
+
+    expect(mintCalls).toEqual([{ board: 'ops', since: 17 }])
+    expect(sockets).toHaveLength(1)
+
+    sockets[0].open()
+    expect(setConnected).toHaveBeenCalledWith(true)
+
+    // Catch-up refetch for the mint→open gap, coalesced like event frames.
+    vi.advanceTimersByTime(LIVE_REFRESH_COALESCE_MS)
+    expect(refresh).toHaveBeenCalledTimes(1)
+  })
+
+  it('coalesces a burst of event frames into one refetch', async () => {
+    handle = createKanbanLiveConnection(null, deps())
+    await settle()
+    sockets[0].open()
+    vi.advanceTimersByTime(LIVE_REFRESH_COALESCE_MS)
+    refresh.mockClear()
+
+    sockets[0].frame([{ id: 18 }])
+    sockets[0].frame([{ id: 19 }, { id: 20 }])
+    sockets[0].frame([{ id: 21 }])
+    expect(refresh).not.toHaveBeenCalled()
+
+    vi.advanceTimersByTime(LIVE_REFRESH_COALESCE_MS)
+    expect(refresh).toHaveBeenCalledTimes(1)
+  })
+
+  it('ignores empty and malformed frames', async () => {
+    handle = createKanbanLiveConnection(null, deps())
+    await settle()
+    sockets[0].open()
+    vi.advanceTimersByTime(LIVE_REFRESH_COALESCE_MS)
+    refresh.mockClear()
+
+    sockets[0].frame([])
+    sockets[0].onmessage?.({ data: 'not json' })
+    vi.advanceTimersByTime(LIVE_REFRESH_COALESCE_MS)
+    expect(refresh).not.toHaveBeenCalled()
+  })
+
+  it('flags disconnected on close (poll fallback) and reconnects with capped backoff', async () => {
+    handle = createKanbanLiveConnection('ops', deps())
+    await settle()
+    sockets[0].open()
+    setConnected.mockClear()
+    since = 23
+
+    sockets[0].drop()
+    expect(setConnected).toHaveBeenCalledWith(false)
+
+    // First retry after the base delay, minted with the CURRENT cursor.
+    vi.advanceTimersByTime(LIVE_RECONNECT_BASE_MS)
+    await settle()
+    expect(sockets).toHaveLength(2)
+    expect(mintCalls[1]).toEqual({ board: 'ops', since: 23 })
+
+    // Repeated failures double the delay up to the cap.
+    for (let i = 0; i < 8; i += 1) {
+      sockets[sockets.length - 1].drop()
+      await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_MAX_MS)
+    }
+
+    expect(sockets.length).toBeGreaterThan(2)
+
+    const before = sockets.length
+
+    sockets[sockets.length - 1].drop()
+    // At the cap: no reconnect just before 30s…
+    await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_MAX_MS - 1)
+    expect(sockets).toHaveLength(before)
+    // …and exactly one at 30s.
+    await vi.advanceTimersByTimeAsync(1)
+    expect(sockets).toHaveLength(before + 1)
+  })
+
+  it('resets the backoff after a successful open', async () => {
+    handle = createKanbanLiveConnection(null, deps())
+    await settle()
+    sockets[0].open()
+
+    sockets[0].drop()
+    await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_MAX_MS)
+    sockets[1].open()
+
+    sockets[1].drop()
+    // Back to the base delay, not the doubled one.
+    await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_BASE_MS)
+    expect(sockets).toHaveLength(3)
+  })
+
+  it('retries when minting the URL fails', async () => {
+    let fail = true
+    handle = createKanbanLiveConnection(null, {
+      ...deps(),
+      mintWsUrl: options => {
+        mintCalls.push(options)
+
+        if (fail) {
+          return Promise.reject(new Error('backend down'))
+        }
+
+        return Promise.resolve('ws://test')
+      }
+    })
+    await settle()
+
+    expect(sockets).toHaveLength(0)
+    expect(setConnected).toHaveBeenCalledWith(false)
+
+    fail = false
+    await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_BASE_MS)
+    expect(mintCalls).toHaveLength(2)
+    expect(sockets).toHaveLength(1)
+  })
+
+  it('stop() closes the socket, clears timers, and never reconnects', async () => {
+    handle = createKanbanLiveConnection(null, deps())
+    await settle()
+    sockets[0].open()
+    sockets[0].frame([{ id: 18 }])
+
+    handle.stop()
+    handle = null
+
+    expect(sockets[0].closed).toBe(true)
+    expect(setConnected).toHaveBeenLastCalledWith(false)
+
+    // Neither the pending coalesced refresh nor any reconnect survives stop.
+    refresh.mockClear()
+    await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_MAX_MS * 4)
+    expect(refresh).not.toHaveBeenCalled()
+    expect(sockets).toHaveLength(1)
+  })
+
+  it('stop() during an in-flight mint prevents a late socket from opening', async () => {
+    let resolveMint: ((url: string) => void) | undefined
+    handle = createKanbanLiveConnection(null, {
+      ...deps(),
+      mintWsUrl: () =>
+        new Promise<string>(resolve => {
+          resolveMint = resolve
+        })
+    })
+
+    handle.stop()
+    handle = null
+    resolveMint!('ws://test')
+    await settle()
+
+    expect(sockets).toHaveLength(0)
+  })
+
+  it('a socket replaced mid-reconnect does not double-handle close', async () => {
+    handle = createKanbanLiveConnection(null, deps())
+    await settle()
+    sockets[0].open()
+    sockets[0].drop()
+    await vi.advanceTimersByTimeAsync(LIVE_RECONNECT_BASE_MS)
+    expect(sockets).toHaveLength(2)
+    setConnected.mockClear()
+
+    // The dead first socket firing close again must not touch state.
+    sockets[0].drop()
+    expect(setConnected).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/app/kanban/live-events.ts b/apps/desktop/src/app/kanban/live-events.ts
new file mode 100644
index 0000000000000..1343818443f7e
--- /dev/null
+++ b/apps/desktop/src/app/kanban/live-events.ts
@@ -0,0 +1,237 @@
+import { $kanbanLiveConnected, kanbanLatestEventId, refreshKanbanBoard } from '@/store/kanban'
+
+// Live board updates over the kanban /events WebSocket. The strategy is
+// deliberately cheap: any event frame schedules one coalesced board refetch
+// (the drawer piggybacks on that — it already reloads when the board's
+// latest_event_id moves), so this module never interprets event kinds. While
+// the socket is down the view's fast polling is the fallback; the
+// $kanbanLiveConnected atom is how the poller knows which cadence to run.
+
+// First retry after 1s, doubling to a 30s cap: quick recovery from a blip
+// without hammering a dead backend (polling covers freshness meanwhile).
+export const LIVE_RECONNECT_BASE_MS = 1_000
+export const LIVE_RECONNECT_MAX_MS = 30_000
+
+// A dispatcher pass appends several events in one poll tick; batch the frames
+// into a single refetch instead of one per frame.
+export const LIVE_REFRESH_COALESCE_MS = 250
+
+/** Structural WebSocket surface so tests can drive a fake socket. */
+export interface KanbanLiveSocket {
+  close: () => void
+  onclose: (() => void) | null
+  onerror: (() => void) | null
+  onmessage: ((event: { data: unknown }) => void) | null
+  onopen: (() => void) | null
+}
+
+export interface KanbanLiveDeps {
+  /** Mint the authed WS URL (main process picks token vs ticket). */
+  mintWsUrl?: (options: { board: null | string; since: number }) => Promise<string>
+  openSocket?: (url: string) => KanbanLiveSocket
+  /** Applies an event batch — defaults to the store's board refetch. */
+  refresh?: () => void
+  setConnected?: (connected: boolean) => void
+  getSince?: () => number
+}
+
+export interface KanbanLiveHandle {
+  stop: () => void
+}
+
+/** Open + supervise one /events socket for `board` (null → backend's current
+ *  board). Reconnects with capped exponential backoff until stopped. */
+export function createKanbanLiveConnection(board: null | string, deps: KanbanLiveDeps = {}): KanbanLiveHandle {
+  const mintWsUrl =
+    deps.mintWsUrl ??
+    (options => {
+      const mint = window.hermesDesktop?.getKanbanEventsWsUrl
+
+      if (!mint) {
+        // Stale preload without the channel: stay in polling mode.
+        return Promise.reject(new Error('kanban events WS bridge unavailable'))
+      }
+
+      return mint(options)
+    })
+
+  const openSocket = deps.openSocket ?? (url => new WebSocket(url) as unknown as KanbanLiveSocket)
+  const refresh = deps.refresh ?? (() => void refreshKanbanBoard())
+  const setConnected = deps.setConnected ?? (connected => $kanbanLiveConnected.set(connected))
+  const getSince = deps.getSince ?? kanbanLatestEventId
+
+  let stopped = false
+  let socket: KanbanLiveSocket | null = null
+  let reconnectTimer: null | number = null
+  let refreshTimer: null | number = null
+  let attempt = 0
+  // Bumped on stop so a mint resolving after teardown can't open a socket.
+  let generation = 0
+
+  const scheduleRefresh = () => {
+    if (stopped || refreshTimer !== null) {
+      return
+    }
+
+    refreshTimer = window.setTimeout(() => {
+      refreshTimer = null
+      refresh()
+    }, LIVE_REFRESH_COALESCE_MS)
+  }
+
+  const scheduleReconnect = () => {
+    if (stopped || reconnectTimer !== null) {
+      return
+    }
+
+    const delay = Math.min(LIVE_RECONNECT_BASE_MS * 2 ** attempt, LIVE_RECONNECT_MAX_MS)
+
+    attempt += 1
+    reconnectTimer = window.setTimeout(() => {
+      reconnectTimer = null
+      void connect()
+    }, delay)
+  }
+
+  const handleDown = () => {
+    if (stopped) {
+      return
+    }
+
+    socket = null
+    setConnected(false)
+    scheduleReconnect()
+  }
+
+  async function connect(): Promise<void> {
+    if (stopped) {
+      return
+    }
+
+    const gen = generation
+    let url: string
+
+    try {
+      url = await mintWsUrl({ board, since: getSince() })
+    } catch {
+      handleDown()
+
+      return
+    }
+
+    if (stopped || gen !== generation) {
+      return
+    }
+
+    let ws: KanbanLiveSocket
+
+    try {
+      ws = openSocket(url)
+    } catch {
+      handleDown()
+
+      return
+    }
+
+    socket = ws
+
+    ws.onopen = () => {
+      if (stopped || socket !== ws) {
+        return
+      }
+
+      attempt = 0
+      setConnected(true)
+      // Anything that happened while we were minting/reconnecting is not in
+      // the stream (since= was sampled earlier) — refetch once to catch up.
+      scheduleRefresh()
+    }
+
+    ws.onmessage = event => {
+      if (stopped || socket !== ws) {
+        return
+      }
+
+      let frame: { events?: unknown } | null = null
+
+      try {
+        frame = JSON.parse(String(event.data)) as { events?: unknown }
+      } catch {
+        return
+      }
+
+      if (Array.isArray(frame?.events) && frame.events.length > 0) {
+        scheduleRefresh()
+      }
+    }
+
+    ws.onclose = () => {
+      if (socket === ws) {
+        handleDown()
+      }
+    }
+
+    // The browser always follows error with close; onclose owns recovery.
+    ws.onerror = () => undefined
+  }
+
+  void connect()
+
+  return {
+    stop: () => {
+      if (stopped) {
+        return
+      }
+
+      stopped = true
+      generation += 1
+
+      if (reconnectTimer !== null) {
+        window.clearTimeout(reconnectTimer)
+        reconnectTimer = null
+      }
+
+      if (refreshTimer !== null) {
+        window.clearTimeout(refreshTimer)
+        refreshTimer = null
+      }
+
+      const ws = socket
+
+      socket = null
+
+      if (ws) {
+        ws.onopen = null
+        ws.onmessage = null
+        ws.onclose = null
+        ws.onerror = null
+
+        try {
+          ws.close()
+        } catch {
+          // already closed
+        }
+      }
+
+      setConnected(false)
+    }
+  }
+}
+
+// ── Module singleton ────────────────────────────────────────────────────────
+// The board view is the only subscriber and there must never be two live
+// sockets, so start/stop manage one shared connection (a new start replaces
+// the previous one — that's also the board-switch path: close + reopen with
+// the new ?board).
+
+let active: KanbanLiveHandle | null = null
+
+export function startKanbanLiveEvents(board: null | string): void {
+  active?.stop()
+  active = createKanbanLiveConnection(board)
+}
+
+export function stopKanbanLiveEvents(): void {
+  active?.stop()
+  active = null
+}
diff --git a/apps/desktop/src/global.d.ts b/apps/desktop/src/global.d.ts
index 870d3311837e8..1481f8f4d0849 100644
--- a/apps/desktop/src/global.d.ts
+++ b/apps/desktop/src/global.d.ts
@@ -25,6 +25,10 @@ declare global {
       // reaper spares it while its chat is active.
       touchBackend: (profile?: string | null) => Promise<{ ok: boolean }>
       getGatewayWsUrl: (profile?: null | string) => Promise<string>
+      // Mint a fresh kanban /events WS URL on the primary backend (token or
+      // single-use OAuth ticket in the query string). `since` seeds the event
+      // cursor; `board` pins the stream's board at the handshake.
+      getKanbanEventsWsUrl?: (options?: { board?: null | string; since?: number }) => Promise<string>
       // Open (or focus) a standalone OS window for a single chat session so
       // the user can work with multiple chats side by side. Returns ok:false
       // with an error code when the sessionId is empty/invalid. `watch` opens
@@ -63,6 +67,13 @@ declare global {
         set: (name: string | null) => Promise<DesktopActiveProfile>
       }
       api: <T>(request: HermesApiRequest) => Promise<T>
+      // Binary transfer for kanban attachments (the JSON-only `api` pipe can't
+      // carry blobs). Download saves into the OS Downloads dir and resolves
+      // with the written path; upload multipart-POSTs a local file by path.
+      kanbanAttachment?: {
+        download: (request: HermesKanbanAttachmentDownloadRequest) => Promise<{ path: string }>
+        upload: <T>(request: HermesKanbanAttachmentUploadRequest) => Promise<T>
+      }
       notify: (payload: HermesNotification) => Promise<boolean>
       requestMicrophoneAccess: () => Promise<boolean>
       readFileDataUrl: (filePath: string) => Promise<string>
@@ -513,6 +524,21 @@ export type DesktopBootstrapEvent =
       docsUrl: string
     }
 
+export interface HermesKanbanAttachmentDownloadRequest {
+  /** Backend API path of the blob, e.g. /api/plugins/kanban/attachments/3?board=x */
+  path: string
+  /** Server-recorded filename — the save target under Downloads. */
+  filename: string
+}
+
+export interface HermesKanbanAttachmentUploadRequest {
+  /** Backend API path, e.g. /api/plugins/kanban/tasks/t_1/attachments?board=x */
+  path: string
+  /** Absolute local path of the file to upload (read in the main process). */
+  filePath: string
+  uploadedBy?: string
+}
+
 export interface HermesApiRequest {
   path: string
   method?: string
diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts
index b086407e8c4c9..1aaac14817e28 100644
--- a/apps/desktop/src/i18n/en.ts
+++ b/apps/desktop/src/i18n/en.ts
@@ -1495,6 +1495,14 @@ export const en: Translations = {
     noWorkerLog: 'No worker log yet',
     attachments: 'Attachments',
     noAttachments: 'No attachments',
+    addAttachment: 'Add attachment',
+    attachmentUploading: 'Uploading…',
+    attachmentUploaded: count => (count === 1 ? 'Attachment added' : `${count} attachments added`),
+    attachmentUploadFailed: 'Attachment upload failed',
+    downloadAttachment: name => `Download ${name}`,
+    attachmentDownloaded: name => `Saved ${name} to Downloads`,
+    attachmentDownloadFailed: 'Attachment download failed',
+    attachmentReveal: 'Reveal',
     updateFailed: 'Update failed',
     newCardTitle: 'New card',
     newCardDesc: 'The dispatcher hands ready cards to their assigned profile.',
diff --git a/apps/desktop/src/i18n/ja.ts b/apps/desktop/src/i18n/ja.ts
index 9f4e3075699a0..853a16f07c65c 100644
--- a/apps/desktop/src/i18n/ja.ts
+++ b/apps/desktop/src/i18n/ja.ts
@@ -142,6 +142,7 @@ export const ja = defineLocale({
       microphoneFailed: 'マイクが失敗しました',
       microphoneInUse: 'マイクは他のアプリで使用中です。',
       microphonePermissionDenied: 'マイクのアクセス許可が拒否されました。',
+      microphoneSelectionUnavailable: '選択したマイクは利用できません',
       microphoneStartFailed: 'マイクの録音を開始できませんでした。',
       microphoneUnsupported: 'このランタイムはマイク録音をサポートしていません。',
       noMicrophone: 'マイクが見つかりませんでした。',
@@ -151,7 +152,8 @@ export const ja = defineLocale({
       transcriptionFailed: '音声文字起こしに失敗しました',
       transcriptionUnavailable: '音声文字起こしはまだ利用できません。',
       tryRecordingAgain: 'もう一度録音してください。',
-      unavailable: '音声は利用できません'
+      unavailable: '音声は利用できません',
+      usingSystemMicrophone: 'Hermes は今回の録音にシステムデフォルトのマイクを使用します。'
     },
     native: {
       approvalTitle: '承認が必要です',
@@ -184,7 +186,99 @@ export const ja = defineLocale({
     muteHaptics: '触覚フィードバックをオフ',
     unmuteHaptics: '触覚フィードバックをオン',
     openSettings: '設定を開く',
-    openStarmap: 'メモリグラフを開く'
+    openStarmap: 'メモリグラフを開く',
+    openKeybinds: 'キーボードショートカット'
+  },
+
+  keybinds: {
+    title: 'キーボードショートカット',
+    subtitle: open => `ショートカットをクリックすると再割り当てできます · ${open} でこのパネルを再表示できます。`,
+    rebind: '再割り当て',
+    reset: 'デフォルトに戻す',
+    resetAll: 'すべてリセット',
+    pressKey: 'キーを押してください…',
+    set: '設定',
+    conflictWith: label => `「${label}」にも割り当てられています`,
+    categories: {
+      composer: 'コンポーザー',
+      profiles: 'プロファイル',
+      session: 'セッション',
+      navigation: 'ナビゲーション',
+      view: 'ビュー'
+    },
+    actions: {
+      'keybinds.openPanel': 'キーボードショートカットを開く',
+      'nav.commandPalette': 'コマンドパレットを開く',
+      'nav.commandCenter': 'コマンドセンターを開く',
+      'nav.settings': '設定を開く',
+      'nav.profiles': 'プロファイルを開く',
+      'nav.skills': 'スキルを開く',
+      'nav.messaging': 'メッセージングを開く',
+      'nav.artifacts': 'アーティファクトを開く',
+      'nav.cron': 'スケジュール済みジョブを開く',
+      'nav.kanban': 'カンバンボードを開く',
+      'nav.agents': 'エージェントを開く',
+      'session.new': '新しいセッション',
+      'session.newWindow': '新しいウィンドウでセッションを開始',
+      'session.next': '次のセッション',
+      'session.prev': '前のセッション',
+      'session.slot.1': '最近のセッション 1 に切り替え',
+      'session.slot.2': '最近のセッション 2 に切り替え',
+      'session.slot.3': '最近のセッション 3 に切り替え',
+      'session.slot.4': '最近のセッション 4 に切り替え',
+      'session.slot.5': '最近のセッション 5 に切り替え',
+      'session.slot.6': '最近のセッション 6 に切り替え',
+      'session.slot.7': '最近のセッション 7 に切り替え',
+      'session.slot.8': '最近のセッション 8 に切り替え',
+      'session.slot.9': '最近のセッション 9 に切り替え',
+      'session.focusSearch': 'セッションを検索',
+      'session.togglePin': '現在のセッションをピン留め / 解除',
+      'workspace.newWorktree': '新しいワークツリー',
+      'composer.focus': 'コンポーザーにフォーカス',
+      'composer.modelPicker': 'モデルピッカーを開く',
+      'composer.voice': '音声会話を開始 / 停止',
+      'view.toggleSidebar': 'セッションサイドバーを切り替え',
+      'view.toggleRightSidebar': 'ファイルブラウザーを切り替え',
+      'view.toggleReview': 'レビューペインを切り替え',
+      'view.showFiles': 'ファイルブラウザーを表示',
+      'view.showTerminal': 'ターミナルを切り替え',
+      'view.terminalSelection': 'ターミナルの選択範囲をコンポーザーへ送信',
+      'view.closePreviewTab': 'プレビュータブを閉じる',
+      'view.flipPanes': 'サイドバーの位置を入れ替え',
+      'appearance.toggleMode': 'ライト / ダークを切り替え',
+      'profile.default': 'デフォルトプロファイルに切り替え',
+      'profile.switch.1': 'プロファイル 1 に切り替え',
+      'profile.switch.2': 'プロファイル 2 に切り替え',
+      'profile.switch.3': 'プロファイル 3 に切り替え',
+      'profile.switch.4': 'プロファイル 4 に切り替え',
+      'profile.switch.5': 'プロファイル 5 に切り替え',
+      'profile.switch.6': 'プロファイル 6 に切り替え',
+      'profile.switch.7': 'プロファイル 7 に切り替え',
+      'profile.switch.8': 'プロファイル 8 に切り替え',
+      'profile.switch.9': 'プロファイル 9 に切り替え',
+      'profile.switch.10': 'プロファイル 10 に切り替え',
+      'profile.switch.11': 'プロファイル 11 に切り替え',
+      'profile.switch.12': 'プロファイル 12 に切り替え',
+      'profile.switch.13': 'プロファイル 13 に切り替え',
+      'profile.switch.14': 'プロファイル 14 に切り替え',
+      'profile.switch.15': 'プロファイル 15 に切り替え',
+      'profile.switch.16': 'プロファイル 16 に切り替え',
+      'profile.switch.17': 'プロファイル 17 に切り替え',
+      'profile.switch.18': 'プロファイル 18 に切り替え',
+      'profile.next': '次のプロファイル',
+      'profile.prev': '前のプロファイル',
+      'profile.toggleAll': 'すべてのプロファイル表示を切り替え',
+      'profile.create': 'プロファイルを作成',
+      'composer.send': 'メッセージを送信',
+      'composer.newline': '改行を挿入',
+      'composer.steer': '実行中のターンを誘導',
+      'composer.sendQueued': '次のキュー済みターンを送信',
+      'composer.mention': 'ファイル、フォルダ、URL を参照',
+      'composer.slash': 'スラッシュコマンドパレット',
+      'composer.help': 'クイックヘルプ',
+      'composer.history': 'ポップオーバー / 履歴を切り替え',
+      'composer.cancel': 'ポップオーバーを閉じる · 実行をキャンセル'
+    }
   },
 
   language: {
@@ -563,6 +657,43 @@ export const ja = defineLocale({
           'アプリから Hermes 自身を更新するとき、ローカルのソース変更を保持するか破棄するかを選びます。ターミナル更新では常に確認されます。'
       }
     }),
+    voice: {
+      title: '音声入力',
+      microphoneTitle: 'マイク',
+      microphoneDesc: 'ディクテーションと音声会話に使用するデバイスローカルの入力。',
+      systemDefault: 'システムデフォルトのマイク',
+      refreshDevices: '更新',
+      devicesUnavailable: 'このランタイムではマイクデバイスを利用できません。',
+      missingDeviceOption: '保存済みのマイク（未接続）',
+      selectedDeviceUnavailable:
+        '保存済みのマイクが接続されていません。Hermes はシステムデフォルトにフォールバックします。',
+      backendTitle: '文字起こしバックエンド',
+      localBackend: 'ローカル',
+      remoteBackend: 'リモート',
+      localBackendDesc:
+        '音声はここで収録され、ローカルの Hermes バックエンドで文字起こししてからテキストをエージェントに送信します。',
+      remoteBackendDesc: baseUrl =>
+        `音声はここで収録され、${baseUrl} に送信されて文字起こしされます。モデル API が受け取るのは文字起こしテキストであり、生の音声ではありません。`,
+      sttTitle: '音声認識',
+      refreshStatus: '確認',
+      checkingStatus: '音声認識のステータスを確認中…',
+      statusUnavailable: '音声認識のステータスを取得できません。',
+      statusUnsupported:
+        'このバックエンドはまだ音声認識の診断を公開していません。音声文字起こしは動作する可能性があります。準備状況の詳細を見るにはバックエンドを更新してください。',
+      statusFailed: 'ステータス確認に失敗しました',
+      statusError: message => `音声認識のステータス確認に失敗しました: ${message}`,
+      sttDisabled: '設定で音声認識が無効になっています。',
+      sttReady: provider => `接続中のバックエンドで ${provider} の音声認識が利用可能です。`,
+      sttUnavailable: provider => `接続中のバックエンドで ${provider} の音声認識がまだ準備できていません。`,
+      localSttInstallable: missing =>
+        `ローカル STT に ${missing} がありません。遅延インストールが有効なため、初回のローカル文字起こし時にバックエンドが許可されたパッケージをインストールできます。`,
+      localSttMissing: missing =>
+        `ローカル STT に ${missing} がありません。遅延インストールを有効にするか、このバックエンドにローカル STT パッケージをインストールしてください。`,
+      localCommandAvailable: missing =>
+        `コマンドベースのローカル STT が利用可能です。不足しているパッケージバンドル: ${missing}。デスクトップでの収録に sounddevice や numpy は不要です。`,
+      localPackagesReady: 'このバックエンドにはローカル STT パッケージがインストールされています。',
+      localPackagesMissing: missing => `不足しているローカル STT パッケージ: ${missing}。`
+    },
     about: {
       heading: 'Hermes Desktop',
       version: value => `バージョン ${value}`,
@@ -728,6 +859,29 @@ export const ja = defineLocale({
       serverJson: 'サーバー JSON',
       remove: '削除',
       saveServer: 'サーバーを保存',
+      test: '接続をテスト',
+      testing: 'テスト中…',
+      testOk: count => `接続済み — ツール ${count} 個が利用可能`,
+      testFailed: '接続に失敗しました',
+      enableServer: name => `${name} を有効化`,
+      disableServer: name => `${name} を無効化`,
+      serverEnabled: name => `${name} を有効にしました — 新しいセッションに適用されます。`,
+      serverDisabled: name => `${name} を無効にしました — 新しいセッションに適用されます。`,
+      toggleFailed: name => `${name} の切り替えに失敗しました`,
+      tabServers: 'サーバー',
+      tabCatalog: 'カタログ',
+      catalogLoading: 'MCP カタログを読み込み中…',
+      catalogLoadFailed: 'MCP カタログの読み込みに失敗しました',
+      catalogEmpty: '利用可能なカタログ項目がありません。',
+      catalogInstalled: 'インストール済み',
+      catalogEnabled: '有効',
+      catalogNeedsInstall: 'ビルドが必要',
+      catalogInstall: 'インストール',
+      catalogInstalling: 'インストール中…',
+      catalogInstallStarted: name => `${name} をインストール中… 完了後、新しいセッションに適用されます。`,
+      catalogInstallFailed: name => `${name} のインストールに失敗しました`,
+      catalogEnvPrompt: name => `${name} には認証情報が必要です`,
+      catalogEnvRequired: 'インストール前に必須の値を入力してください。',
       capabilitySummary: (tools, prompts, resources) =>
         `${[`ツール ${tools} 個`, ...(prompts ? [`プロンプト ${prompts} 個`] : []), ...(resources ? [`リソース ${resources} 個`] : [])].join('、')} を有効化`,
       statusConnecting: '接続中…',
@@ -751,6 +905,10 @@ export const ja = defineLocale({
       provider: 'プロバイダー',
       model: 'モデル',
       applying: '適用中...',
+      defaultsLabel: 'デフォルト',
+      reasoning: '推論',
+      reasoningOff: 'オフ',
+      defaultsFailed: 'モデルのデフォルト設定を保存できませんでした',
       auxiliaryTitle: '補助モデル',
       resetAllToMain: 'すべてメインにリセット',
       auxiliaryDesc:
@@ -779,8 +937,14 @@ export const ja = defineLocale({
       collapse: '折りたたむ',
       connectAnother: '別のプロバイダーを接続',
       otherProviders: 'その他のプロバイダー',
+      disconnect: '接続を解除',
+      disconnectInTerminal: '接続を解除（ターミナルで削除コマンドを実行します）',
       removeConfirm: provider => `${provider} を削除しますか？`,
+      removeExternalGeneric: provider => `${provider} は独自の CLI で管理されています — そちらで削除してください。`,
       removeKeyManaged: provider => `${provider} は API キーで設定されています。API Keys から削除してください。`,
+      removeTerminalConfirm: (provider, command) =>
+        `${provider} の接続を解除しますか？認証情報をクリアするため、ターミナルで "${command}" を実行します。`,
+      removeTerminalRunning: provider => `ターミナルで ${provider} の接続解除を実行中…`,
       removedTitle: 'アカウントを削除しました',
       removedMessage: provider => `${provider} を削除しました。`,
       failedRemove: provider => `${provider} を削除できませんでした`,
@@ -847,7 +1011,16 @@ export const ja = defineLocale({
       postSetupCompleteMessage: step => `${step} をインストールしました。`,
       postSetupErrorTitle: 'セットアップはエラーで終了しました',
       postSetupErrorMessage: step => `${step} のログを確認してください。`,
-      postSetupFailed: step => `${step} のセットアップの実行に失敗しました`
+      postSetupFailed: step => `${step} のセットアップの実行に失敗しました`,
+      loadingModels: 'モデルカタログを読み込み中…',
+      modelSectionTitle: 'モデル',
+      modelCount: count => `${count} 個のモデル`,
+      modelInUse: '使用中',
+      modelDefault: 'デフォルト',
+      modelInactiveHint: 'モデルを変更するには、まずこのバックエンドを選択してください。',
+      modelSelectedTitle: 'モデルを選択しました',
+      modelSelectedMessage: model => `${model} は新しいセッションに適用されます。`,
+      failedSelectModel: model => `${model} の選択に失敗しました`
     }
   },
 
@@ -855,6 +1028,7 @@ export const ja = defineLocale({
     tabSkills: 'スキル',
     tabToolsets: 'ツールセット',
     tabMcp: 'MCP',
+    tabHub: 'ハブを見る',
     all: 'すべて',
     searchSkills: 'スキルを検索...',
     searchToolsets: 'ツールセットを検索...',
@@ -902,7 +1076,55 @@ export const ja = defineLocale({
     edit: '編集',
     archive: 'アーカイブ',
     skillArchivedTitle: 'スキルをアーカイブしました',
-    skillArchivedMessage: 'hermes curator restore で復元できます。'
+    skillArchivedMessage: 'hermes curator restore で復元できます。',
+    hub: {
+      searchPlaceholder: 'スキルハブを検索',
+      search: '検索',
+      searching: '検索中…',
+      connectingHubs: 'スキルハブに接続中…',
+      connectedHubs: '接続済みのハブ:',
+      featured: '注目のスキル',
+      landingHint:
+        'ハブを検索して、公式インデックス、GitHub、コミュニティソースからインストール可能なスキルを閲覧できます。',
+      noResults: 'ハブに一致するスキルが見つかりません。',
+      resultCount: (count, ms) => `${count} 件の結果${ms !== null ? `（${ms}ms）` : ''}`,
+      timedOut: sources => `タイムアウト: ${sources}`,
+      installed: 'インストール済み',
+      install: 'インストール',
+      installing: 'インストール中…',
+      uninstall: 'アンインストール',
+      uninstalling: 'アンインストール中…',
+      updateAll: 'インストール済みを更新',
+      updating: '更新中…',
+      preview: 'プレビュー',
+      scan: 'スキャン',
+      scanning: 'スキャン中…',
+      close: '閉じる',
+      files: 'ファイル',
+      noReadme: 'このスキルには SKILL.md のプレビューがありません。',
+      trust: {
+        builtin: '組み込み',
+        trusted: '信頼済み',
+        community: 'コミュニティ'
+      },
+      verdictSafe: '安全',
+      verdictCaution: '注意',
+      verdictDangerous: '危険',
+      policyAllow: 'インストール可',
+      policyAsk: 'インストール前に確認してください',
+      policyBlock: 'ポリシーによりインストールがブロックされています',
+      findings: count => `${count} 件の検出`,
+      noFindings: 'セキュリティ上の検出はありません。',
+      installStarted: name => `${name} をインストール中…`,
+      uninstallStarted: name => `${name} をアンインストール中…`,
+      updateStarted: 'インストール済みスキルを更新中…',
+      actionFailed: 'スキル操作に失敗しました',
+      actionLog: '操作ログ',
+      loadFailed: 'スキルハブの読み込みに失敗しました',
+      previewFailed: 'スキルのプレビューに失敗しました',
+      scanFailed: 'セキュリティスキャンに失敗しました',
+      searchFailed: 'ハブの検索に失敗しました'
+    }
   },
 
   starmap: {
@@ -918,7 +1140,20 @@ export const ja = defineLocale({
     loadFailed: 'メモリグラフを読み込めませんでした',
     loading: '読み込み中…',
     emptyTitle: 'まだ学習はありません',
-    emptyDesc: 'Hermes がスキルやメモリを蓄積すると、ここに表示されます。'
+    emptyDesc: 'Hermes がスキルやメモリを蓄積すると、ここに表示されます。',
+    share: 'マップを共有',
+    shareHint:
+      'コードをコピーしてこのマップを共有するか、コードを貼り付けて読み込みます。レイアウトのみを含み、メモリやスキルの内容は含まれません。',
+    shareTitle: 'マップのインポート / エクスポート',
+    sharePlaceholder: 'マップコードを貼り付け…',
+    copy: 'マップコードをコピー',
+    copied: 'コピーしました！',
+    importMap: 'マップをインポート',
+    importBtn: '読み込む',
+    importEmpty: 'マップコードを貼り付けて読み込みます。',
+    importSuccess: nodes => `${nodes} 個のノードを含むマップを読み込みました。`,
+    importedBadge: 'インポートされたマップ',
+    resetToMine: '自分のマップに戻る'
   },
   agents: {
     close: 'エージェントを閉じる',
@@ -1023,8 +1258,9 @@ export const ja = defineLocale({
     settingsFields: '設定フィールド',
     mcpServers: 'MCP サーバー',
     archivedChats: 'アーカイブ済みチャット',
-    sections: { sessions: 'セッション', system: 'システム', usage: '使用状況' },
+    sections: { maintenance: 'メンテナンス', sessions: 'セッション', system: 'システム', usage: '使用状況' },
     sectionDescriptions: {
+      maintenance: '診断、バックアップ、キュレーター、メモリデータ',
       sessions: 'セッションの検索と管理',
       system: 'ステータス、ログ、システムアクション',
       usage: 'トークン、コスト、スキルの活動履歴'
@@ -1081,7 +1317,54 @@ export const ja = defineLocale({
     noModelUsage: 'モデルの使用履歴はまだありません。',
     topSkills: 'よく使うスキル',
     noSkillActivity: 'スキルのアクティビティはまだありません。',
-    actions: count => `${count} アクション`
+    actions: count => `${count} アクション`,
+    logFile: 'ログファイル',
+    logLevel: 'レベル',
+    logSearchPlaceholder: 'ログ行をフィルター…',
+    maintenance: {
+      runOps: '診断',
+      doctor: 'ドクターを実行',
+      doctorDesc: 'インストール、設定、プロバイダーのヘルスチェック',
+      securityAudit: 'セキュリティ監査',
+      securityAuditDesc: '設定とスキルの危険な設定をスキャン',
+      backup: 'バックアップを作成',
+      backupDesc: '設定、メモリ、スキル、セッションを ZIP 化',
+      debugShare: 'デバッグ共有',
+      debugShareDesc: '秘匿処理済みのレポートとログをアップロードし、共有リンクを取得します（6 時間後に自動削除）',
+      debugShareRunning: 'デバッグレポートをアップロード中…',
+      debugShareLinks: '共有リンク',
+      debugShareFailed: 'デバッグ共有に失敗しました',
+      copyLink: 'リンクをコピー',
+      linkCopied: 'リンクをコピーしました',
+      curator: 'スキルキュレーター',
+      curatorDesc: '古くなったエージェント作成スキルをアーカイブするバックグラウンドレビュー',
+      curatorPaused: '一時停止中',
+      curatorActive: '稼働中',
+      curatorDisabled: '無効',
+      curatorLastRun: when => `前回の実行 ${when}`,
+      curatorNeverRan: '未実行',
+      pause: '一時停止',
+      resume: '再開',
+      runNow: '今すぐ実行',
+      memoryData: 'メモリデータ',
+      memoryDataDesc: 'すべてのセッションに注入される組み込みメモリファイル',
+      memoryProvider: name => `アクティブなプロバイダー: ${name}`,
+      builtinMemory: '組み込み',
+      memoryFile: 'エージェントメモリ（MEMORY.md）',
+      userFile: 'ユーザープロファイル（USER.md）',
+      bytes: size => size,
+      empty: '空',
+      resetMemory: 'メモリをリセット',
+      resetUser: 'プロファイルをリセット',
+      resetAll: '両方リセット',
+      resetConfirm: target => `${target} を削除しますか？この操作は元に戻せません。`,
+      resetDone: files => `${files} を削除しました。`,
+      resetFailed: 'メモリのリセットに失敗しました',
+      actionStarted: name => `${name} を開始しました — ログを追跡中…`,
+      actionFailed: name => `${name} の開始に失敗しました`,
+      running: '実行中…',
+      viewLog: '操作ログ'
+    }
   },
 
   messaging: {
@@ -1300,7 +1583,9 @@ export const ja = defineLocale({
     failedLoadSoul: 'SOUL.md の読み込みに失敗しました',
     failedSaveSoul: 'SOUL.md の保存に失敗しました',
     failedCreate: 'プロファイルの作成に失敗しました',
-    failedRename: 'プロファイルの名前変更に失敗しました'
+    failedRename: 'プロファイルの名前変更に失敗しました',
+    workingBadge: count => `${count} 件のセッションが作業中`,
+    attentionBadge: count => `${count} 件のセッションが入力待ち`
   },
 
   cron: {
@@ -1416,6 +1701,90 @@ export const ja = defineLocale({
     createAction: 'Cron を作成'
   },
 
+  kanban: {
+    title: 'カンバン',
+    close: 'カンバンを閉じる',
+    loading: 'カンバンボードを読み込み中…',
+    failedLoad: 'カンバンボードの読み込みに失敗しました',
+    count: count => `${count} 枚のカード`,
+    board: 'ボード',
+    nudgeDispatcher: 'ディスパッチャーを起動',
+    nudgeSent: (spawned, promoted) => `ディスパッチャーを起動しました — 開始 ${spawned}、昇格 ${promoted}`,
+    nudgeFailed: 'ディスパッチャーの起動に失敗しました',
+    newCard: '新しいカード',
+    noTasks: 'カードがありません',
+    unassigned: '未割り当て',
+    priority: '優先度',
+    progressTitle: (done, total) => `子タスク ${done}/${total} 完了`,
+    diagnostics: '診断',
+    movedByRules: column => `ボードルールにより「${column}」へ移動しました`,
+    moveFailed: '移動に失敗しました',
+    columnLabels: {
+      triage: 'トリアージ',
+      todo: 'Todo',
+      scheduled: 'スケジュール済み',
+      ready: '準備完了',
+      running: '進行中',
+      blocked: 'ブロック中',
+      review: 'レビュー',
+      done: '完了',
+      archived: 'アーカイブ済み'
+    },
+    loadingDetail: 'カードを読み込み中…',
+    status: 'ステータス',
+    assignee: '担当者',
+    description: '説明',
+    noDescription: '説明はありません',
+    latestSummary: '最新の要約',
+    dependencies: '依存関係',
+    parents: '親:',
+    children: '子:',
+    none: 'なし',
+    comments: 'コメント',
+    noComments: 'コメントはまだありません',
+    commentPlaceholder: 'コメントを追加…（⌘Enter で送信）',
+    addComment: 'コメント',
+    commentFailed: 'コメントの追加に失敗しました',
+    events: 'イベント',
+    noEvents: 'イベントはありません',
+    runHistory: '実行履歴',
+    noRuns: '実行履歴はまだありません',
+    runActive: '実行中',
+    workerLog: 'ワーカーログ',
+    loadingLog: 'ログを読み込み中…',
+    noWorkerLog: 'ワーカーログはまだありません',
+    attachments: '添付ファイル',
+    noAttachments: '添付ファイルはありません',
+    addAttachment: '添付ファイルを追加',
+    attachmentUploading: 'アップロード中…',
+    attachmentUploaded: count =>
+      count === 1 ? '添付ファイルを追加しました' : `${count} 件の添付ファイルを追加しました`,
+    attachmentUploadFailed: '添付ファイルのアップロードに失敗しました',
+    downloadAttachment: name => `${name} をダウンロード`,
+    attachmentDownloaded: name => `${name} をダウンロードフォルダーに保存しました`,
+    attachmentDownloadFailed: '添付ファイルのダウンロードに失敗しました',
+    attachmentReveal: 'フォルダで表示',
+    updateFailed: '更新に失敗しました',
+    newCardTitle: '新しいカード',
+    newCardDesc: 'ディスパッチャーは準備完了のカードを割り当てられたプロファイルに渡します。',
+    titleLabel: 'タイトル',
+    titlePlaceholder: '何をする必要がありますか？',
+    assigneeLabel: '担当者',
+    assigneePlaceholder: 'プロファイルを選択',
+    bodyLabel: '説明',
+    bodyPlaceholder: '目標、アプローチ、受け入れ基準…',
+    priorityLabel: '優先度',
+    parentLabel: '親カード',
+    parentNone: '親なし',
+    optional: '任意',
+    createCard: 'カードを作成',
+    creating: '作成中…',
+    created: 'カードを作成しました',
+    createFailed: 'カードの作成に失敗しました',
+    titleRequired: 'タイトルは必須です。',
+    assigneeRequired: '担当者は必須です。'
+  },
+
   artifacts: {
     search: 'アーティファクトを検索...',
     refresh: 'アーティファクトを更新',
@@ -1456,7 +1825,8 @@ export const ja = defineLocale({
       'new-session': '新しいセッション',
       skills: 'スキルとツール',
       messaging: 'メッセージング',
-      artifacts: 'アーティファクト'
+      artifacts: 'アーティファクト',
+      kanban: 'カンバン'
     },
     searchAria: 'セッションを検索',
     searchPlaceholder: 'セッションを検索…',
@@ -1534,7 +1904,10 @@ export const ja = defineLocale({
       removeWorktreeDirty:
         'このワークツリーにはコミットされていない変更があります。強制削除（変更を破棄）するか、レーンを隠してディスク上に残します。',
       forceRemove: '強制削除',
-      enter: label => `${label} を開く`
+      enter: label => `${label} を開く`,
+      reorder: label => `${label} を並べ替え`,
+      toggle: label => `${label} のセッションを開閉`,
+      back: 'すべてのプロジェクト'
     },
     newSessionIn: label => `${label} で新しいセッション`,
     showMoreIn: (count, label) => `${label} でさらに ${count} 件を表示`,
@@ -1595,6 +1968,7 @@ export const ja = defineLocale({
     ],
     startVoice: '音声会話を開始',
     queueMessage: 'メッセージをキューに入れる',
+    steer: '現在の実行を誘導',
     stop: '停止',
     send: '送信',
     speaking: '話しています',
@@ -1888,6 +2262,7 @@ export const ja = defineLocale({
     getKey: 'キーを取得',
     replaceCurrent: '現在の値を置き換え',
     pasteApiKey: 'API キーを貼り付け',
+    localApiKeyPlaceholder: 'API キー（任意 — エンドポイントが必要とする場合のみ）',
     couldNotSave: '認証情報を保存できませんでした。',
     connecting: '接続中',
     update: '更新',
@@ -2214,6 +2589,8 @@ export const ja = defineLocale({
       stopReading: '読み上げを停止',
       readAloud: '読み上げ',
       editMessage: 'メッセージを編集',
+      expandMessage: 'メッセージを展開',
+      scrollToBottom: '最下部へスクロール',
       stop: '停止',
       restorePrevious: '前のチェックポイントに戻す',
       restoreCheckpoint: 'チェックポイントを復元',
@@ -2464,5 +2841,21 @@ export const ja = defineLocale({
       description: 'モバイルサイドバーを表示します。',
       toggle: 'サイドバーを切り替え'
     }
+  },
+
+  commandCenterOverview: {
+    sectionLabel: 'すべてのプロファイル',
+    sectionDescription: '全プロファイルのアクティビティと共有カンバンボード',
+    working: count => `${count} 件作業中`,
+    attention: count => `${count} 件入力待ち`,
+    sessions: count => `${count} セッション`,
+    idle: 'アイドル',
+    noActivity: 'アクティビティはまだありません',
+    currentBadge: '現在',
+    switch: '切り替え',
+    openBoard: 'ボードを開く',
+    kanbanUnavailable: 'このバックエンドではカンバンを利用できません。',
+    noHotCards: 'レビュー中またはブロック中のカードはありません',
+    openCard: title => `カンバンボードで「${title}」を開く`
   }
 })
diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts
index 53b8bce084e15..1fc3e1b0a71f1 100644
--- a/apps/desktop/src/i18n/types.ts
+++ b/apps/desktop/src/i18n/types.ts
@@ -1223,6 +1223,14 @@ export interface Translations {
     noWorkerLog: string
     attachments: string
     noAttachments: string
+    addAttachment: string
+    attachmentUploading: string
+    attachmentUploaded: (count: number) => string
+    attachmentUploadFailed: string
+    downloadAttachment: (name: string) => string
+    attachmentDownloaded: (name: string) => string
+    attachmentDownloadFailed: string
+    attachmentReveal: string
     updateFailed: string
     newCardTitle: string
     newCardDesc: string
diff --git a/apps/desktop/src/i18n/zh-hant.ts b/apps/desktop/src/i18n/zh-hant.ts
index 0b14885c4ef40..37024404e182a 100644
--- a/apps/desktop/src/i18n/zh-hant.ts
+++ b/apps/desktop/src/i18n/zh-hant.ts
@@ -137,6 +137,7 @@ export const zhHant = defineLocale({
       microphoneFailed: '麥克風發生錯誤',
       microphoneInUse: '麥克風正被其他應用程式使用中。',
       microphonePermissionDenied: '麥克風權限被拒絕。',
+      microphoneSelectionUnavailable: '所選麥克風不可用',
       microphoneStartFailed: '無法開始麥克風錄音。',
       microphoneUnsupported: '目前執行環境不支援麥克風錄音。',
       noMicrophone: '找不到麥克風。',
@@ -146,7 +147,8 @@ export const zhHant = defineLocale({
       transcriptionFailed: '語音轉寫失敗',
       transcriptionUnavailable: '語音轉寫暫不可用。',
       tryRecordingAgain: '請再錄製一次。',
-      unavailable: '語音不可用'
+      unavailable: '語音不可用',
+      usingSystemMicrophone: 'Hermes 將在本次錄音中使用系統預設麥克風。'
     },
     native: {
       approvalTitle: '需要核准',
@@ -178,7 +180,99 @@ export const zhHant = defineLocale({
     muteHaptics: '靜音觸感回饋',
     unmuteHaptics: '開啟觸感回饋',
     openSettings: '開啟設定',
-    openStarmap: '開啟記憶圖譜'
+    openStarmap: '開啟記憶圖譜',
+    openKeybinds: '鍵盤快速鍵'
+  },
+
+  keybinds: {
+    title: '鍵盤快速鍵',
+    subtitle: open => `點擊快速鍵即可重新綁定 · ${open} 可重新開啟此面板。`,
+    rebind: '重新綁定',
+    reset: '還原預設',
+    resetAll: '全部重設',
+    pressKey: '請按下按鍵…',
+    set: '設定',
+    conflictWith: label => `已綁定到「${label}」`,
+    categories: {
+      composer: '輸入框',
+      profiles: '設定檔',
+      session: '工作階段',
+      navigation: '導覽',
+      view: '檢視'
+    },
+    actions: {
+      'keybinds.openPanel': '開啟鍵盤快速鍵',
+      'nav.commandPalette': '開啟命令面板',
+      'nav.commandCenter': '開啟命令中心',
+      'nav.settings': '開啟設定',
+      'nav.profiles': '開啟設定檔',
+      'nav.skills': '開啟技能',
+      'nav.messaging': '開啟訊息平台',
+      'nav.artifacts': '開啟成品',
+      'nav.cron': '開啟排程工作',
+      'nav.kanban': '開啟看板',
+      'nav.agents': '開啟代理',
+      'session.new': '新工作階段',
+      'session.newWindow': '在新視窗中開啟新工作階段',
+      'session.next': '下一個工作階段',
+      'session.prev': '上一個工作階段',
+      'session.slot.1': '切換到最近工作階段 1',
+      'session.slot.2': '切換到最近工作階段 2',
+      'session.slot.3': '切換到最近工作階段 3',
+      'session.slot.4': '切換到最近工作階段 4',
+      'session.slot.5': '切換到最近工作階段 5',
+      'session.slot.6': '切換到最近工作階段 6',
+      'session.slot.7': '切換到最近工作階段 7',
+      'session.slot.8': '切換到最近工作階段 8',
+      'session.slot.9': '切換到最近工作階段 9',
+      'session.focusSearch': '搜尋工作階段',
+      'session.togglePin': '釘選/取消釘選目前工作階段',
+      'workspace.newWorktree': '新增工作樹',
+      'composer.focus': '聚焦輸入框',
+      'composer.modelPicker': '開啟模型選擇器',
+      'composer.voice': '開始 / 停止語音對話',
+      'view.toggleSidebar': '切換工作階段側邊欄',
+      'view.toggleRightSidebar': '切換檔案瀏覽器',
+      'view.toggleReview': '切換審查面板',
+      'view.showFiles': '顯示檔案瀏覽器',
+      'view.showTerminal': '顯示終端機',
+      'view.terminalSelection': '將終端機選取範圍傳送到輸入框',
+      'view.closePreviewTab': '關閉預覽分頁',
+      'view.flipPanes': '交換側邊欄位置',
+      'appearance.toggleMode': '切換淺色/深色',
+      'profile.default': '切換到預設設定檔',
+      'profile.switch.1': '切換到設定檔 1',
+      'profile.switch.2': '切換到設定檔 2',
+      'profile.switch.3': '切換到設定檔 3',
+      'profile.switch.4': '切換到設定檔 4',
+      'profile.switch.5': '切換到設定檔 5',
+      'profile.switch.6': '切換到設定檔 6',
+      'profile.switch.7': '切換到設定檔 7',
+      'profile.switch.8': '切換到設定檔 8',
+      'profile.switch.9': '切換到設定檔 9',
+      'profile.switch.10': '切換到設定檔 10',
+      'profile.switch.11': '切換到設定檔 11',
+      'profile.switch.12': '切換到設定檔 12',
+      'profile.switch.13': '切換到設定檔 13',
+      'profile.switch.14': '切換到設定檔 14',
+      'profile.switch.15': '切換到設定檔 15',
+      'profile.switch.16': '切換到設定檔 16',
+      'profile.switch.17': '切換到設定檔 17',
+      'profile.switch.18': '切換到設定檔 18',
+      'profile.next': '下一個設定檔',
+      'profile.prev': '上一個設定檔',
+      'profile.toggleAll': '切換全部設定檔檢視',
+      'profile.create': '建立設定檔',
+      'composer.send': '傳送訊息',
+      'composer.newline': '插入換行',
+      'composer.steer': '引導執行中的回合',
+      'composer.sendQueued': '傳送下一則排隊訊息',
+      'composer.mention': '引用檔案、資料夾、網址',
+      'composer.slash': '斜線命令面板',
+      'composer.help': '快速說明',
+      'composer.history': '切換彈出視窗/歷史',
+      'composer.cancel': '關閉彈出視窗·取消執行'
+    }
   },
 
   language: {
@@ -551,6 +645,39 @@ export const zhHant = defineLocale({
           'Hermes 從應用程式內更新自身時，保留本機原始碼變更（stash）或丟棄（discard）。終端機更新一律會詢問。'
       }
     }),
+    voice: {
+      title: '語音輸入',
+      microphoneTitle: '麥克風',
+      microphoneDesc: '用於聽寫和語音對話的本機輸入裝置。',
+      systemDefault: '系統預設麥克風',
+      refreshDevices: '重新整理',
+      devicesUnavailable: '目前執行環境無法存取麥克風裝置。',
+      missingDeviceOption: '已儲存的麥克風（未連接）',
+      selectedDeviceUnavailable: '已儲存的麥克風未連接。Hermes 將改用系統預設麥克風。',
+      backendTitle: '轉寫後端',
+      localBackend: '本機',
+      remoteBackend: '遠端',
+      localBackendDesc: '音訊在此處擷取，並由本機 Hermes 後端轉寫成文字後傳送給智能體。',
+      remoteBackendDesc: baseUrl =>
+        `音訊在此處擷取，然後傳送到 ${baseUrl} 進行轉寫。模型 API 收到的是轉寫文字，而不是原始音訊。`,
+      sttTitle: '語音轉文字',
+      refreshStatus: '檢查',
+      checkingStatus: '正在檢查語音轉文字狀態…',
+      statusUnavailable: '語音轉文字狀態不可用。',
+      statusUnsupported: '此後端尚未提供語音轉文字診斷介面。語音轉寫可能仍可使用；更新後端後可查看就緒詳情。',
+      statusFailed: '狀態檢查失敗',
+      statusError: message => `語音轉文字狀態檢查失敗：${message}`,
+      sttDisabled: '設定中已停用語音轉文字。',
+      sttReady: provider => `已連線後端上的 ${provider} 語音轉文字已就緒。`,
+      sttUnavailable: provider => `已連線後端上的 ${provider} 語音轉文字尚未就緒。`,
+      localSttInstallable: missing =>
+        `本機 STT 缺少 ${missing}。延遲安裝已啟用，後端可在首次本機轉寫時安裝允許的套件。`,
+      localSttMissing: missing => `本機 STT 缺少 ${missing}。請啟用延遲安裝，或在此後端安裝本機 STT 套件。`,
+      localCommandAvailable: missing =>
+        `命令式本機 STT 可用。缺少的套件組合：${missing}。桌面端擷取不需要 sounddevice 或 numpy。`,
+      localPackagesReady: '此後端已安裝本機 STT 套件。',
+      localPackagesMissing: missing => `缺少本機 STT 套件：${missing}。`
+    },
     about: {
       heading: 'Hermes Desktop',
       version: value => `版本 ${value}`,
@@ -707,6 +834,29 @@ export const zhHant = defineLocale({
       serverJson: '伺服器 JSON',
       remove: '移除',
       saveServer: '儲存伺服器',
+      test: '測試連線',
+      testing: '測試中…',
+      testOk: count => `已連線 — ${count} 個工具可用`,
+      testFailed: '連線失敗',
+      enableServer: name => `啟用 ${name}`,
+      disableServer: name => `停用 ${name}`,
+      serverEnabled: name => `${name} 已啟用 — 對新工作階段生效。`,
+      serverDisabled: name => `${name} 已停用 — 對新工作階段生效。`,
+      toggleFailed: name => `切換 ${name} 失敗`,
+      tabServers: '伺服器',
+      tabCatalog: '目錄',
+      catalogLoading: '正在載入 MCP 目錄…',
+      catalogLoadFailed: 'MCP 目錄載入失敗',
+      catalogEmpty: '沒有可用的目錄項目。',
+      catalogInstalled: '已安裝',
+      catalogEnabled: '已啟用',
+      catalogNeedsInstall: '需要建置',
+      catalogInstall: '安裝',
+      catalogInstalling: '安裝中…',
+      catalogInstallStarted: name => `正在安裝 ${name}… 完成後對新工作階段生效。`,
+      catalogInstallFailed: name => `安裝 ${name} 失敗`,
+      catalogEnvPrompt: name => `${name} 需要憑證`,
+      catalogEnvRequired: '安裝前請填寫必要的值。',
       capabilitySummary: (tools, prompts, resources) =>
         `已啟用 ${[`${tools} 個工具`, ...(prompts ? [`${prompts} 個提示`] : []), ...(resources ? [`${resources} 個資源`] : [])].join('、')}`,
       statusConnecting: '連線中…',
@@ -729,6 +879,10 @@ export const zhHant = defineLocale({
       provider: '提供方',
       model: '模型',
       applying: '套用中...',
+      defaultsLabel: '預設值',
+      reasoning: '推理',
+      reasoningOff: '關閉',
+      defaultsFailed: '儲存模型預設值失敗',
       auxiliaryTitle: '輔助模型',
       resetAllToMain: '全部重設為主要模型',
       auxiliaryDesc: '輔助任務預設使用主要模型。您可以為任何任務指定專用模型。',
@@ -755,8 +909,14 @@ export const zhHant = defineLocale({
       collapse: '收合',
       connectAnother: '連結其他提供方',
       otherProviders: '其他提供方',
+      disconnect: '中斷連線',
+      disconnectInTerminal: '中斷連線（在終端機中執行移除命令）',
       removeConfirm: provider => `移除 ${provider}？`,
+      removeExternalGeneric: provider => `${provider} 由其自身的 CLI 管理 — 請在那裡移除。`,
       removeKeyManaged: provider => `${provider} 由 API 金鑰設定。請從 API Keys 中移除。`,
+      removeTerminalConfirm: (provider, command) =>
+        `中斷 ${provider} 的連線？這將在終端機中執行 "${command}" 以清除憑證。`,
+      removeTerminalRunning: provider => `正在終端機中中斷 ${provider} 的連線…`,
       removedTitle: '帳號已移除',
       removedMessage: provider => `${provider} 已移除。`,
       failedRemove: provider => `無法移除 ${provider}`,
@@ -819,7 +979,16 @@ export const zhHant = defineLocale({
       postSetupCompleteMessage: step => `已安裝 ${step}。`,
       postSetupErrorTitle: '設定完成但有錯誤',
       postSetupErrorMessage: step => `請檢查 ${step} 日誌。`,
-      postSetupFailed: step => `執行 ${step} 設定失敗`
+      postSetupFailed: step => `執行 ${step} 設定失敗`,
+      loadingModels: '正在載入模型目錄…',
+      modelSectionTitle: '模型',
+      modelCount: count => `${count} 個模型`,
+      modelInUse: '使用中',
+      modelDefault: '預設',
+      modelInactiveHint: '請先選擇此後端，然後再變更其模型。',
+      modelSelectedTitle: '模型已選擇',
+      modelSelectedMessage: model => `${model} 將套用至新工作階段。`,
+      failedSelectModel: model => `選擇 ${model} 失敗`
     }
   },
 
@@ -827,6 +996,7 @@ export const zhHant = defineLocale({
     tabSkills: '技能',
     tabToolsets: '工具集',
     tabMcp: 'MCP',
+    tabHub: '瀏覽技能中心',
     all: '全部',
     searchSkills: '搜尋技能...',
     searchToolsets: '搜尋工具集...',
@@ -874,7 +1044,54 @@ export const zhHant = defineLocale({
     edit: '編輯',
     archive: '封存',
     skillArchivedTitle: '技能已封存',
-    skillArchivedMessage: '可透過 hermes curator restore 還原。'
+    skillArchivedMessage: '可透過 hermes curator restore 還原。',
+    hub: {
+      searchPlaceholder: '搜尋技能中心',
+      search: '搜尋',
+      searching: '搜尋中…',
+      connectingHubs: '正在連線技能中心…',
+      connectedHubs: '已連線的來源：',
+      featured: '精選技能',
+      landingHint: '搜尋技能中心，瀏覽來自官方索引、GitHub 和社群來源的可安裝技能。',
+      noResults: '技能中心沒有符合的技能。',
+      resultCount: (count, ms) => `${count} 個結果${ms !== null ? `（${ms}ms）` : ''}`,
+      timedOut: sources => `逾時：${sources}`,
+      installed: '已安裝',
+      install: '安裝',
+      installing: '安裝中…',
+      uninstall: '解除安裝',
+      uninstalling: '解除安裝中…',
+      updateAll: '更新已安裝',
+      updating: '更新中…',
+      preview: '預覽',
+      scan: '掃描',
+      scanning: '掃描中…',
+      close: '關閉',
+      files: '檔案',
+      noReadme: '該技能沒有 SKILL.md 預覽。',
+      trust: {
+        builtin: '內建',
+        trusted: '可信',
+        community: '社群'
+      },
+      verdictSafe: '安全',
+      verdictCaution: '注意',
+      verdictDangerous: '危險',
+      policyAllow: '允許安裝',
+      policyAsk: '安裝前請複查',
+      policyBlock: '安裝被政策封鎖',
+      findings: count => `${count} 項發現`,
+      noFindings: '無安全性發現。',
+      installStarted: name => `正在安裝 ${name}…`,
+      uninstallStarted: name => `正在解除安裝 ${name}…`,
+      updateStarted: '正在更新已安裝技能…',
+      actionFailed: '技能操作失敗',
+      actionLog: '操作記錄',
+      loadFailed: '技能中心載入失敗',
+      previewFailed: '技能預覽失敗',
+      scanFailed: '安全性掃描失敗',
+      searchFailed: '技能中心搜尋失敗'
+    }
   },
 
   starmap: {
@@ -890,7 +1107,19 @@ export const zhHant = defineLocale({
     loadFailed: '無法載入記憶圖譜',
     loading: '載入中…',
     emptyTitle: '尚無學習內容',
-    emptyDesc: '當 Hermes 為你的工作建立技能與記憶時，會顯示在這裡。'
+    emptyDesc: '當 Hermes 為你的工作建立技能與記憶時，會顯示在這裡。',
+    share: '分享圖譜',
+    shareHint: '複製代碼以分享此圖譜，或貼上代碼以載入。僅包含版面配置，不含你的記憶或技能內容。',
+    shareTitle: '匯入 / 匯出圖譜',
+    sharePlaceholder: '貼上圖譜代碼…',
+    copy: '複製圖譜代碼',
+    copied: '已複製！',
+    importMap: '匯入圖譜',
+    importBtn: '載入',
+    importEmpty: '貼上圖譜代碼以載入。',
+    importSuccess: nodes => `已載入包含 ${nodes} 個節點的圖譜。`,
+    importedBadge: '匯入的圖譜',
+    resetToMine: '返回我的圖譜'
   },
   agents: {
     close: '關閉代理',
@@ -995,8 +1224,9 @@ export const zhHant = defineLocale({
     settingsFields: '設定欄位',
     mcpServers: 'MCP 伺服器',
     archivedChats: '已封存聊天',
-    sections: { sessions: '工作階段', system: '系統', usage: '使用量' },
+    sections: { maintenance: '維護', sessions: '工作階段', system: '系統', usage: '使用量' },
     sectionDescriptions: {
+      maintenance: '診斷、備份、策展器與記憶資料',
       sessions: '搜尋和管理工作階段',
       system: '狀態、記錄和系統動作',
       usage: '一段時間內的詞元、費用和技能活動'
@@ -1053,7 +1283,54 @@ export const zhHant = defineLocale({
     noModelUsage: '暫無模型使用量。',
     topSkills: '常用技能',
     noSkillActivity: '暫無技能活動。',
-    actions: count => `${count} 次動作`
+    actions: count => `${count} 次動作`,
+    logFile: '記錄檔',
+    logLevel: '層級',
+    logSearchPlaceholder: '篩選記錄行…',
+    maintenance: {
+      runOps: '診斷',
+      doctor: '執行健檢',
+      doctorDesc: '檢查安裝、設定與提供方的健康狀態',
+      securityAudit: '安全性稽核',
+      securityAuditDesc: '掃描設定與技能中的風險設定',
+      backup: '建立備份',
+      backupDesc: '打包設定、記憶、技能與工作階段',
+      debugShare: '偵錯分享',
+      debugShareDesc: '上傳去識別化報告與記錄，取得可分享連結（6 小時後自動刪除）',
+      debugShareRunning: '正在上傳偵錯報告…',
+      debugShareLinks: '分享連結',
+      debugShareFailed: '偵錯分享失敗',
+      copyLink: '複製連結',
+      linkCopied: '連結已複製',
+      curator: '技能策展器',
+      curatorDesc: '背景審查並封存過期的智能體自建技能',
+      curatorPaused: '已暫停',
+      curatorActive: '執行中',
+      curatorDisabled: '已停用',
+      curatorLastRun: when => `上次執行 ${when}`,
+      curatorNeverRan: '從未執行',
+      pause: '暫停',
+      resume: '繼續',
+      runNow: '立即執行',
+      memoryData: '記憶資料',
+      memoryDataDesc: '注入每個工作階段的內建記憶檔案',
+      memoryProvider: name => `目前提供方：${name}`,
+      builtinMemory: '內建',
+      memoryFile: '智能體記憶（MEMORY.md）',
+      userFile: '使用者輪廓（USER.md）',
+      bytes: size => size,
+      empty: '空',
+      resetMemory: '重設記憶',
+      resetUser: '重設輪廓',
+      resetAll: '全部重設',
+      resetConfirm: target => `刪除 ${target}？此操作無法復原。`,
+      resetDone: files => `已刪除 ${files}。`,
+      resetFailed: '記憶重設失敗',
+      actionStarted: name => `${name} 已啟動 — 正在追蹤記錄…`,
+      actionFailed: name => `${name} 啟動失敗`,
+      running: '執行中…',
+      viewLog: '操作記錄'
+    }
   },
 
   messaging: {
@@ -1255,7 +1532,9 @@ export const zhHant = defineLocale({
     failedLoadSoul: '載入 SOUL.md 失敗',
     failedSaveSoul: '儲存 SOUL.md 失敗',
     failedCreate: '建立設定檔失敗',
-    failedRename: '重新命名設定檔失敗'
+    failedRename: '重新命名設定檔失敗',
+    workingBadge: count => `${count} 個工作階段執行中`,
+    attentionBadge: count => `${count} 個工作階段等待你的輸入`
   },
 
   cron: {
@@ -1369,6 +1648,89 @@ export const zhHant = defineLocale({
     createAction: '建立排程工作'
   },
 
+  kanban: {
+    title: '看板',
+    close: '關閉看板',
+    loading: '正在載入看板…',
+    failedLoad: '載入看板失敗',
+    count: count => `${count} 張卡片`,
+    board: '面板',
+    nudgeDispatcher: '觸發調度器',
+    nudgeSent: (spawned, promoted) => `已觸發調度器 — 啟動 ${spawned}，晉級 ${promoted}`,
+    nudgeFailed: '觸發調度器失敗',
+    newCard: '新增卡片',
+    noTasks: '暫無卡片',
+    unassigned: '未指派',
+    priority: '優先順序',
+    progressTitle: (done, total) => `子任務已完成 ${done}/${total}`,
+    diagnostics: '診斷',
+    movedByRules: column => `已按面板規則移至「${column}」`,
+    moveFailed: '移動失敗',
+    columnLabels: {
+      triage: '分流',
+      todo: '待辦',
+      scheduled: '已排程',
+      ready: '就緒',
+      running: '進行中',
+      blocked: '受阻',
+      review: '審查',
+      done: '完成',
+      archived: '已封存'
+    },
+    loadingDetail: '正在載入卡片…',
+    status: '狀態',
+    assignee: '負責人',
+    description: '描述',
+    noDescription: '暫無描述',
+    latestSummary: '最新摘要',
+    dependencies: '依賴關係',
+    parents: '父任務：',
+    children: '子任務：',
+    none: '無',
+    comments: '留言',
+    noComments: '暫無留言',
+    commentPlaceholder: '新增留言…（⌘Enter 傳送）',
+    addComment: '留言',
+    commentFailed: '新增留言失敗',
+    events: '事件',
+    noEvents: '暫無事件',
+    runHistory: '執行歷史',
+    noRuns: '暫無執行記錄',
+    runActive: '進行中',
+    workerLog: '工作程序記錄',
+    loadingLog: '正在載入記錄…',
+    noWorkerLog: '暫無工作程序記錄',
+    attachments: '附件',
+    noAttachments: '暫無附件',
+    addAttachment: '新增附件',
+    attachmentUploading: '上傳中…',
+    attachmentUploaded: count => (count === 1 ? '附件已新增' : `已新增 ${count} 個附件`),
+    attachmentUploadFailed: '附件上傳失敗',
+    downloadAttachment: name => `下載 ${name}`,
+    attachmentDownloaded: name => `已將 ${name} 儲存到下載資料夾`,
+    attachmentDownloadFailed: '附件下載失敗',
+    attachmentReveal: '在資料夾中顯示',
+    updateFailed: '更新失敗',
+    newCardTitle: '新增卡片',
+    newCardDesc: '調度器會把就緒卡片交給其指派的設定檔執行。',
+    titleLabel: '標題',
+    titlePlaceholder: '需要做什麼？',
+    assigneeLabel: '負責人',
+    assigneePlaceholder: '選擇設定檔',
+    bodyLabel: '描述',
+    bodyPlaceholder: '目標、方案、驗收標準…',
+    priorityLabel: '優先順序',
+    parentLabel: '父卡片',
+    parentNone: '無父卡片',
+    optional: '選填',
+    createCard: '建立卡片',
+    creating: '建立中…',
+    created: '卡片已建立',
+    createFailed: '建立卡片失敗',
+    titleRequired: '標題為必填項目。',
+    assigneeRequired: '負責人為必填項目。'
+  },
+
   artifacts: {
     search: '搜尋成品…',
     refresh: '重新整理成品',
@@ -1409,7 +1771,8 @@ export const zhHant = defineLocale({
       'new-session': '新工作階段',
       skills: '技能與工具',
       messaging: '訊息平台',
-      artifacts: '成品'
+      artifacts: '成品',
+      kanban: '看板'
     },
     searchAria: '搜尋工作階段',
     searchPlaceholder: '搜尋工作階段…',
@@ -1484,7 +1847,10 @@ export const zhHant = defineLocale({
         '從 git 中移除（刪除工作樹目錄，但保留分支），或僅從側邊欄隱藏該軌道並將工作樹保留在磁碟上。',
       removeWorktreeDirty: '此工作樹有未提交的變更。強制移除（捨棄這些變更），或僅隱藏軌道並保留在磁碟上。',
       forceRemove: '強制移除',
-      enter: label => `開啟 ${label}`
+      enter: label => `開啟 ${label}`,
+      reorder: label => `重新排序 ${label}`,
+      toggle: label => `展開/收合 ${label} 工作階段`,
+      back: '全部專案'
     },
     newSessionIn: label => `在 ${label} 中新建工作階段`,
     showMoreIn: (count, label) => `在 ${label} 中再顯示 ${count} 個`,
@@ -1545,6 +1911,7 @@ export const zhHant = defineLocale({
     ],
     startVoice: '開始語音對話',
     queueMessage: '排隊訊息',
+    steer: '引導目前執行',
     stop: '停止',
     send: '傳送',
     speaking: '說話中',
@@ -1828,6 +2195,7 @@ export const zhHant = defineLocale({
     getKey: '取得金鑰',
     replaceCurrent: '取代目前值',
     pasteApiKey: '貼上 API 金鑰',
+    localApiKeyPlaceholder: 'API 金鑰（選填 — 僅當端點需要時填寫）',
     couldNotSave: '無法儲存憑證。',
     connecting: '連線中',
     update: '更新',
@@ -2147,6 +2515,8 @@ export const zhHant = defineLocale({
       stopReading: '停止朗讀',
       readAloud: '朗讀',
       editMessage: '編輯訊息',
+      expandMessage: '展開訊息',
+      scrollToBottom: '捲動到底部',
       stop: '停止',
       restorePrevious: '還原至上一個檢查點',
       restoreCheckpoint: '還原檢查點',
@@ -2369,5 +2739,21 @@ export const zhHant = defineLocale({
       description: '顯示行動裝置側邊欄。',
       toggle: '切換側邊欄'
     }
+  },
+
+  commandCenterOverview: {
+    sectionLabel: '全部設定檔',
+    sectionDescription: '總覽所有設定檔的活動，以及共享的看板',
+    working: count => `${count} 個進行中`,
+    attention: count => `${count} 個待輸入`,
+    sessions: count => `${count} 個工作階段`,
+    idle: '閒置',
+    noActivity: '暫無活動',
+    currentBadge: '目前',
+    switch: '切換',
+    openBoard: '開啟看板',
+    kanbanUnavailable: '此後端不支援看板。',
+    noHotCards: '沒有待審查或受阻的卡片',
+    openCard: title => `在看板中開啟「${title}」`
   }
 })
diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts
index 5faac8af8dcc3..202cdb450dac2 100644
--- a/apps/desktop/src/i18n/zh.ts
+++ b/apps/desktop/src/i18n/zh.ts
@@ -1673,6 +1673,14 @@ export const zh: Translations = {
     noWorkerLog: '暂无工作进程日志',
     attachments: '附件',
     noAttachments: '暂无附件',
+    addAttachment: '添加附件',
+    attachmentUploading: '上传中…',
+    attachmentUploaded: count => (count === 1 ? '附件已添加' : `已添加 ${count} 个附件`),
+    attachmentUploadFailed: '附件上传失败',
+    downloadAttachment: name => `下载 ${name}`,
+    attachmentDownloaded: name => `已将 ${name} 保存到下载文件夹`,
+    attachmentDownloadFailed: '附件下载失败',
+    attachmentReveal: '在文件夹中显示',
     updateFailed: '更新失败',
     newCardTitle: '新建卡片',
     newCardDesc: '调度器会把就绪卡片交给其指定的配置档案执行。',
diff --git a/apps/desktop/src/kanban-api.attachments.test.ts b/apps/desktop/src/kanban-api.attachments.test.ts
new file mode 100644
index 0000000000000..9d66cc3e2dda0
--- /dev/null
+++ b/apps/desktop/src/kanban-api.attachments.test.ts
@@ -0,0 +1,58 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { downloadKanbanAttachment, uploadKanbanAttachment } from '@/kanban-api'
+
+describe('kanban attachment api wrappers', () => {
+  let download: ReturnType<typeof vi.fn>
+  let upload: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    download = vi.fn(async () => ({ path: '/Users/me/Downloads/spec.pdf' }))
+    upload = vi.fn(async () => ({ attachment: null }))
+    Object.defineProperty(window, 'hermesDesktop', {
+      configurable: true,
+      value: { kanbanAttachment: { download, upload } }
+    })
+  })
+
+  afterEach(() => {
+    Reflect.deleteProperty(window, 'hermesDesktop')
+  })
+
+  it('download targets the attachment blob route with the board pinned', async () => {
+    const result = await downloadKanbanAttachment({ id: 7, filename: 'spec.pdf' }, 'ops board')
+
+    expect(download).toHaveBeenCalledWith({
+      path: '/api/plugins/kanban/attachments/7?board=ops%20board',
+      filename: 'spec.pdf'
+    })
+    expect(result.path).toBe('/Users/me/Downloads/spec.pdf')
+  })
+
+  it('download omits ?board when no board is given', async () => {
+    await downloadKanbanAttachment({ id: 3, filename: 'notes.txt' })
+
+    expect(download).toHaveBeenCalledWith({
+      path: '/api/plugins/kanban/attachments/3',
+      filename: 'notes.txt'
+    })
+  })
+
+  it('upload multipart-POSTs the task attachments route with the local path', async () => {
+    await uploadKanbanAttachment('t_a/b', '/tmp/report.pdf', 'default')
+
+    expect(upload).toHaveBeenCalledWith({
+      path: '/api/plugins/kanban/tasks/t_a%2Fb/attachments?board=default',
+      filePath: '/tmp/report.pdf',
+      uploadedBy: 'desktop'
+    })
+  })
+
+  it('rejects with a clear error when the preload bridge predates the channel', async () => {
+    Object.defineProperty(window, 'hermesDesktop', { configurable: true, value: {} })
+
+    expect(() => downloadKanbanAttachment({ id: 1, filename: 'x' })).toThrowError(/updated desktop app/)
+    expect(() => uploadKanbanAttachment('t_1', '/tmp/x')).toThrowError(/updated desktop app/)
+  })
+})
diff --git a/apps/desktop/src/kanban-api.ts b/apps/desktop/src/kanban-api.ts
index 3b3024d38c656..c6f36e9fb9944 100644
--- a/apps/desktop/src/kanban-api.ts
+++ b/apps/desktop/src/kanban-api.ts
@@ -1,5 +1,7 @@
 import type {
   KanbanAssignee,
+  KanbanAttachment,
+  KanbanAttachmentUploadResponse,
   KanbanBoardPayload,
   KanbanBoardsResponse,
   KanbanCreateTaskPayload,
@@ -14,6 +16,7 @@ import type {
 export type {
   KanbanAssignee,
   KanbanAttachment,
+  KanbanAttachmentUploadResponse,
   KanbanBoardInfo,
   KanbanBoardPayload,
   KanbanBoardsResponse,
@@ -139,6 +142,46 @@ export function getKanbanTaskLog(taskId: string, board?: null | string, tailByte
   })
 }
 
+// Attachment bytes ride a dedicated binary IPC (hermes:kanban:attachment:*):
+// the hermes:api pipe is JSON-only, and the blob must cross the same authed
+// HTTP channel as REST in remote mode. Both throw a plain Error when the
+// preload bridge predates the channel (old app shell + new renderer).
+
+function kanbanAttachmentBridge(): NonNullable<(typeof window.hermesDesktop)['kanbanAttachment']> {
+  const bridge = window.hermesDesktop.kanbanAttachment
+
+  if (!bridge) {
+    throw new Error('Attachment transfer requires an updated desktop app.')
+  }
+
+  return bridge
+}
+
+/** GET /attachments/:id → saved into the OS Downloads dir; resolves with the
+ *  written path (collision-resolved, so it may differ from the filename). */
+export function downloadKanbanAttachment(
+  attachment: Pick<KanbanAttachment, 'filename' | 'id'>,
+  board?: null | string
+): Promise<{ path: string }> {
+  return kanbanAttachmentBridge().download({
+    path: kanbanPath(`/attachments/${attachment.id}`, board),
+    filename: attachment.filename
+  })
+}
+
+/** Multipart POST /tasks/:id/attachments from a local file path. */
+export function uploadKanbanAttachment(
+  taskId: string,
+  filePath: string,
+  board?: null | string
+): Promise<KanbanAttachmentUploadResponse> {
+  return kanbanAttachmentBridge().upload<KanbanAttachmentUploadResponse>({
+    path: kanbanPath(`/tasks/${encodeURIComponent(taskId)}/attachments`, board),
+    filePath,
+    uploadedBy: 'desktop'
+  })
+}
+
 export interface KanbanApiError {
   status: null | number
   detail: string
diff --git a/apps/desktop/src/store/kanban.ts b/apps/desktop/src/store/kanban.ts
index f83ae7e691d93..d86c80dc3b79c 100644
--- a/apps/desktop/src/store/kanban.ts
+++ b/apps/desktop/src/store/kanban.ts
@@ -44,6 +44,17 @@ export const $kanbanSelectedTaskId = atom<null | string>(null)
 // overlapping fetches when the interval outpaces a slow backend).
 export const $kanbanRefreshing = atom(false)
 
+// Live /events socket health (set by app/kanban/live-events). While true the
+// board view stretches its poll to a slow safety net; while false it falls
+// back to the fast interval.
+export const $kanbanLiveConnected = atom(false)
+
+/** The board's event cursor — what a live /events subscribe passes as ?since=
+ *  so no events are missed between the last fetch and the handshake. */
+export function kanbanLatestEventId(): number {
+  return $kanbanBoard.get()?.latest_event_id ?? 0
+}
+
 export function setKanbanActiveBoard(slug: null | string): void {
   const next = slug || null
 
diff --git a/apps/desktop/src/types/kanban.ts b/apps/desktop/src/types/kanban.ts
index 684722d131acd..d09fe86ad15dc 100644
--- a/apps/desktop/src/types/kanban.ts
+++ b/apps/desktop/src/types/kanban.ts
@@ -122,6 +122,10 @@ export interface KanbanAttachment {
   created_at: number
 }
 
+export interface KanbanAttachmentUploadResponse {
+  attachment: KanbanAttachment | null
+}
+
 export interface KanbanRun {
   id: number
   task_id: string

From 4505c4fdfd243180814e20d0368ff7cb9e4f5aa1 Mon Sep 17 00:00:00 2001
From: Rod-fernandez <rodrigo@nxtlevelsaas.com>
Date: Sat, 4 Jul 2026 11:33:53 -0400
Subject: [PATCH 6/6] feat(desktop): split-pane multi-session (2 panes)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two chat sessions side-by-side in one window, each with independent
composer, streaming, busy state, and profile.

- Singletons keep their meaning as 'the active pane's view'; the split
  pane runs a factory-created PaneSessionView bundle fed by the
  per-session state cache's new multi-view fan-out. Single-pane behavior
  is unchanged (pinned suites pass unedited).
- Sends/resumes execute only from the active pane; the split's request
  wrapper awaits the gateway-profile swap (closes the Enter-beats-swap
  race); background main-pane RPCs ride a profile-pinned socket; boot
  restore uses ensureProfileSocketOpen and never steals the active swap.
- Open via ⌘⇧\ (rebindable), command palette, or 'Open in split' on any
  session row; same session never opens in both panes; split state and
  width persist; narrow windows collapse the split and restore it.
- Socket keep-set and keepalive include the split session's profile;
  native notifications treat both visible panes as foreground.
- 50+ new tests (split store, cache fan-out, mirror, dispatcher, profile
  pinning, composer bus gating, keybind, keep-set, notifications).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../composer/hooks/use-auto-speak-replies.ts  |   6 +-
 .../chat/composer/hooks/use-composer-draft.ts |  43 +-
 .../chat/composer/hooks/use-composer-queue.ts |   7 +-
 .../composer/hooks/use-composer-submit.ts     |  12 +-
 .../chat/composer/hooks/use-composer-voice.ts |  20 +-
 apps/desktop/src/app/chat/composer/index.tsx  |   8 +-
 .../chat/composer/pane-bus-gating.test.tsx    | 130 +++++
 .../app/chat/composer/status-stack/index.tsx  |   5 +-
 .../app/chat/hooks/use-composer-actions.ts    |  76 ++-
 apps/desktop/src/app/chat/index.tsx           |  82 +--
 .../desktop/src/app/chat/pane-request.test.ts | 223 ++++++++
 apps/desktop/src/app/chat/pane-request.ts     | 134 +++++
 apps/desktop/src/app/chat/pane-view.ts        | 377 ++++++++++++
 .../src/app/chat/scroll-to-bottom-button.tsx  |   6 +-
 .../app/chat/sidebar/session-actions-menu.tsx |  19 +-
 .../desktop/src/app/chat/split-mirror.test.ts | 150 +++++
 apps/desktop/src/app/chat/split-mirror.ts     |  64 +++
 apps/desktop/src/app/chat/split-pane.tsx      | 535 ++++++++++++++++++
 .../desktop/src/app/command-palette/index.tsx |  49 +-
 .../src/app/desktop-controller-split.test.ts  |  58 ++
 .../src/app/desktop-controller-utils.ts       |  47 ++
 apps/desktop/src/app/desktop-controller.tsx   | 378 ++++++++++++-
 .../hooks/use-gateway-boot.keep-set.test.ts   |  73 +++
 .../src/app/gateway/hooks/use-gateway-boot.ts |  54 +-
 apps/desktop/src/app/hooks/use-keybinds.ts    |  11 +-
 .../app/session/hooks/use-model-controls.ts   |  76 ++-
 .../session/hooks/use-prompt-actions/index.ts |  86 +--
 .../hooks/use-prompt-actions/submit.ts        |  35 +-
 .../src/app/session/hooks/use-route-resume.ts |  21 +
 ...use-session-actions.split-profile.test.tsx | 159 ++++++
 .../hooks/use-session-actions/index.ts        | 254 +++++----
 .../hooks/use-session-actions/utils.ts        |  69 ++-
 .../use-session-state-cache.fanout.test.tsx   | 235 ++++++++
 .../session/hooks/use-session-state-cache.ts  | 256 +++++++--
 .../components/assistant-ui/thread/list.tsx   |  19 +-
 apps/desktop/src/i18n/en.ts                   |   4 +
 apps/desktop/src/i18n/ja.ts                   |   4 +
 apps/desktop/src/i18n/types.ts                |   3 +
 apps/desktop/src/i18n/zh-hant.ts              |   4 +
 apps/desktop/src/i18n/zh.ts                   |   4 +
 apps/desktop/src/lib/icons.ts                 |   2 +
 apps/desktop/src/lib/keybinds/actions.test.ts |  40 ++
 apps/desktop/src/lib/keybinds/actions.ts      |   3 +
 apps/desktop/src/store/composer.ts            |  46 +-
 apps/desktop/src/store/gateway.test.ts        | 118 ++++
 apps/desktop/src/store/gateway.ts             |  39 +-
 .../store/native-notifications.split.test.ts  | 144 +++++
 .../desktop/src/store/native-notifications.ts |  34 +-
 apps/desktop/src/store/split.test.ts          | 242 ++++++++
 apps/desktop/src/store/split.ts               | 294 ++++++++++
 apps/desktop/src/store/thread-scroll.ts       |  78 ++-
 51 files changed, 4356 insertions(+), 480 deletions(-)
 create mode 100644 apps/desktop/src/app/chat/composer/pane-bus-gating.test.tsx
 create mode 100644 apps/desktop/src/app/chat/pane-request.test.ts
 create mode 100644 apps/desktop/src/app/chat/pane-request.ts
 create mode 100644 apps/desktop/src/app/chat/pane-view.ts
 create mode 100644 apps/desktop/src/app/chat/split-mirror.test.ts
 create mode 100644 apps/desktop/src/app/chat/split-mirror.ts
 create mode 100644 apps/desktop/src/app/chat/split-pane.tsx
 create mode 100644 apps/desktop/src/app/desktop-controller-split.test.ts
 create mode 100644 apps/desktop/src/app/gateway/hooks/use-gateway-boot.keep-set.test.ts
 create mode 100644 apps/desktop/src/app/session/hooks/use-session-actions.split-profile.test.tsx
 create mode 100644 apps/desktop/src/app/session/hooks/use-session-state-cache.fanout.test.tsx
 create mode 100644 apps/desktop/src/lib/keybinds/actions.test.ts
 create mode 100644 apps/desktop/src/store/gateway.test.ts
 create mode 100644 apps/desktop/src/store/native-notifications.split.test.ts
 create mode 100644 apps/desktop/src/store/split.test.ts
 create mode 100644 apps/desktop/src/store/split.ts

diff --git a/apps/desktop/src/app/chat/composer/hooks/use-auto-speak-replies.ts b/apps/desktop/src/app/chat/composer/hooks/use-auto-speak-replies.ts
index c3268bc9cbd33..25d07e889469c 100644
--- a/apps/desktop/src/app/chat/composer/hooks/use-auto-speak-replies.ts
+++ b/apps/desktop/src/app/chat/composer/hooks/use-auto-speak-replies.ts
@@ -1,9 +1,9 @@
 import { useStore } from '@nanostores/react'
 import { useEffect, useRef } from 'react'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { playSpeechText } from '@/lib/voice-playback'
 import { notifyError } from '@/store/notifications'
-import { $messages } from '@/store/session'
 import { $voicePlayback } from '@/store/voice-playback'
 import { $autoSpeakReplies } from '@/store/voice-prefs'
 
@@ -39,6 +39,8 @@ export function useAutoSpeakReplies({
   sessionId
 }: UseAutoSpeakReplies) {
   const enabled = useStore($autoSpeakReplies)
+  // Pane bundle: re-arm on THIS pane's transcript updates.
+  const { $messages } = usePaneView()
   const latest = useRef({ conversationActive, failureLabel, markSpoken, pendingReply })
   latest.current = { conversationActive, failureLabel, markSpoken, pendingReply }
 
@@ -75,5 +77,5 @@ export function useAutoSpeakReplies({
     const stops = [$messages.subscribe(speakLatest), $voicePlayback.listen(speakLatest)]
 
     return () => stops.forEach(f => f())
-  }, [enabled, sessionId])
+  }, [$messages, enabled, sessionId])
 }
diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts b/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts
index 5f8bcf8e2330b..796092a644957 100644
--- a/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts
+++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-draft.ts
@@ -1,8 +1,9 @@
 import { useAui, useAuiState, useComposerRuntime } from '@assistant-ui/react'
 import { type RefObject, useCallback, useEffect, useRef, useState } from 'react'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { SLASH_COMMAND_RE } from '@/lib/chat-runtime'
-import { $composerAttachments, type ComposerAttachment, stashSessionDraft, takeSessionDraft } from '@/store/composer'
+import { type ComposerAttachment, stashSessionDraft, takeSessionDraft } from '@/store/composer'
 import { isBrowsingHistory } from '@/store/composer-input-history'
 
 import { cloneAttachments, DRAFT_PERSIST_DEBOUNCE_MS, type QueueEditState } from '../composer-utils'
@@ -45,6 +46,11 @@ export function useComposerDraft({
 }: UseComposerDraftArgs) {
   const aui = useAui()
   const composerRuntime = useComposerRuntime()
+  // The pane bundle: this composer's attachments atom + the active-pane gate
+  // for the window-global insert/focus bus. Single-pane these are the module
+  // singletons and the gate is always true — today's behavior exactly.
+  const view = usePaneView()
+  const { $composerAttachments } = view
 
   // Coarse edges only — these flip rarely (empty↔non-empty, the `?` help sigil,
   // steerable-vs-slash), so typing within a line costs no render.
@@ -132,25 +138,35 @@ export function useComposerDraft({
     [paintDraft]
   )
 
+  // Mount/focusKey/enable auto-focus, gated to the ACTIVE pane. Ungated, the
+  // split's ChatBar would steal focus on mount (boot restore of a persisted
+  // split), on its pane-local session swaps (focusKey), and on gateway
+  // reconnects (inputDisabled flips) — and the focusin would bubble into the
+  // split wrapper's onFocusCapture, activating the pane, installing the
+  // identity mirror, and swapping the gateway profile without any user
+  // gesture. Single-pane isActive() is always true — today's behavior.
   useEffect(() => {
-    if (!inputDisabled) {
+    if (!inputDisabled && view.isActive()) {
       focusInput()
     }
-  }, [focusInput, focusKey, focusRequestId, inputDisabled])
+  }, [focusInput, focusKey, focusRequestId, inputDisabled, view])
 
   useEffect(() => {
     if (inputDisabled) {
       return undefined
     }
 
+    // Active-pane gate: with the split open, BOTH mounted composers subscribe
+    // as 'main', so global requests (deep-link blueprint, terminal Cmd+L,
+    // review pane) must land only in the pane the user is working in.
     const offFocus = onComposerFocusRequest(target => {
-      if (target === 'main') {
+      if (target === 'main' && view.isActive()) {
         setFocusRequestId(id => id + 1)
       }
     })
 
     const offInsert = onComposerInsertRequest(({ mode, target, text }) => {
-      if (target === 'main') {
+      if (target === 'main' && view.isActive()) {
         appendExternalText(text, mode)
       }
     })
@@ -159,10 +175,13 @@ export function useComposerDraft({
       offFocus()
       offInsert()
     }
-  }, [appendExternalText, inputDisabled])
+  }, [appendExternalText, inputDisabled, view])
 
-  const stashAt = (scope: string | null, text = draftRef.current, attachments = $composerAttachments.get()) =>
-    stashSessionDraft(scope, text, attachments)
+  const stashAt = useCallback(
+    (scope: string | null, text = draftRef.current, attachments = $composerAttachments.get()) =>
+      stashSessionDraft(scope, text, attachments),
+    [$composerAttachments]
+  )
 
   const loadIntoComposer = (text: string, attachments: ComposerAttachment[]) => {
     $composerAttachments.set(cloneAttachments(attachments))
@@ -237,7 +256,7 @@ export function useComposerDraft({
       unsubscribe()
       window.clearTimeout(draftPersistTimerRef.current)
     }
-  }, [composerRuntime, queueEditRef])
+  }, [composerRuntime, queueEditRef, stashAt])
 
   const insertText = (text: string) => {
     const base = draftRef.current
@@ -275,11 +294,11 @@ export function useComposerDraft({
 
   useEffect(() => {
     return onComposerInsertRefsRequest(({ refs, target }) => {
-      if (target === 'main') {
+      if (target === 'main' && view.isActive()) {
         insertInlineRefsRef.current(refs)
       }
     })
-  }, [])
+  }, [view])
 
   // Per-thread draft swap — the composer's only session coupling. Lifecycle
   // never clears composer state; this effect alone stashes on leave, restores
@@ -322,7 +341,7 @@ export function useComposerDraft({
       window.removeEventListener('pagehide', flushPendingDraftPersist)
       flushPendingDraftPersist()
     }
-  }, [syncDraftFromEditor])
+  }, [stashAt, syncDraftFromEditor])
 
   return {
     activeQueueSessionKeyRef,
diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-queue.ts b/apps/desktop/src/app/chat/composer/hooks/use-composer-queue.ts
index c40d56a4826b7..fa5f5a21561da 100644
--- a/apps/desktop/src/app/chat/composer/hooks/use-composer-queue.ts
+++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-queue.ts
@@ -1,5 +1,6 @@
 import { type RefObject, useCallback, useEffect, useRef, useState } from 'react'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { useI18n } from '@/i18n'
 import { triggerHaptic } from '@/lib/haptics'
 import { useSessionSlice } from '@/lib/use-session-slice'
@@ -60,6 +61,8 @@ export function useComposerQueue({
   sessionId
 }: UseComposerQueueArgs) {
   const { t } = useI18n()
+  // Pane bundle: queued sends clear THIS pane's attachments atom.
+  const { $composerAttachments } = usePaneView()
 
   // Per-session slice (edge): re-renders only when THIS session's queue changes,
   // not on cross-session queue churn (the plain atom's map ref changes on every
@@ -173,11 +176,11 @@ export function useComposerQueue({
     }
 
     clearDraft()
-    clearComposerAttachments()
+    clearComposerAttachments($composerAttachments)
     triggerHaptic('selection')
 
     return true
-  }, [activeQueueSessionKey, attachments, clearDraft, draftRef])
+  }, [$composerAttachments, activeQueueSessionKey, attachments, clearDraft, draftRef])
 
   // All queue drain paths share one lock + send-then-remove sequence.
   // `pickEntry` lets each caller choose head, by-id, or skip-edited.
diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-submit.ts b/apps/desktop/src/app/chat/composer/hooks/use-composer-submit.ts
index eab822d7cd89d..0f5bf27b5f0e9 100644
--- a/apps/desktop/src/app/chat/composer/hooks/use-composer-submit.ts
+++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-submit.ts
@@ -1,5 +1,6 @@
 import { type RefObject, useEffect, useRef } from 'react'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { SLASH_COMMAND_RE } from '@/lib/chat-runtime'
 import { triggerHaptic } from '@/lib/haptics'
 import { clearComposerAttachments, clearSessionDraft, type ComposerAttachment } from '@/store/composer'
@@ -71,6 +72,11 @@ export function useComposerSubmit({
   setComposerText,
   stashAt
 }: UseComposerSubmitArgs) {
+  // Pane bundle: sends clear THIS pane's attachments; external submit requests
+  // land only in the active pane (both mounted composers subscribe as 'main').
+  const view = usePaneView()
+  const { $composerAttachments } = view
+
   // Shared send primitive: fire onSubmit, and if the gateway rejects (accepted
   // === false) or throws, re-load + re-stash the draft so the words survive.
   const dispatchSubmit = (text: string, attachments?: ComposerAttachment[]) => {
@@ -96,11 +102,11 @@ export function useComposerSubmit({
   useEffect(
     () =>
       onComposerSubmitRequest(({ target, text }) => {
-        if (target === 'main' && !inputDisabled) {
+        if (target === 'main' && !inputDisabled && view.isActive()) {
           dispatchSubmitRef.current(text)
         }
       }),
-    [inputDisabled]
+    [inputDisabled, view]
   )
 
   const submitDraft = () => {
@@ -159,7 +165,7 @@ export function useComposerSubmit({
       triggerHaptic('submit')
       resetBrowseState(sessionId)
       clearDraft()
-      clearComposerAttachments()
+      clearComposerAttachments($composerAttachments)
       dispatchSubmit(text, submittedAttachments)
     }
 
diff --git a/apps/desktop/src/app/chat/composer/hooks/use-composer-voice.ts b/apps/desktop/src/app/chat/composer/hooks/use-composer-voice.ts
index 2cff7a4084c71..1a26dfab83cf7 100644
--- a/apps/desktop/src/app/chat/composer/hooks/use-composer-voice.ts
+++ b/apps/desktop/src/app/chat/composer/hooks/use-composer-voice.ts
@@ -1,11 +1,11 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { useI18n } from '@/i18n'
 import { chatMessageText } from '@/lib/chat-messages'
 import { triggerHaptic } from '@/lib/haptics'
 import { resetBrowseState } from '@/store/composer-input-history'
 import { notifyError } from '@/store/notifications'
-import { $messages } from '@/store/session'
 import { $autoSpeakReplies, setAutoSpeakReplies } from '@/store/voice-prefs'
 
 import { onComposerVoiceToggleRequest } from '../focus'
@@ -45,6 +45,10 @@ export function useComposerVoice({
   sessionId
 }: UseComposerVoiceArgs) {
   const { t } = useI18n()
+  // Pane bundle: replies are read from THIS pane's transcript, and the
+  // window-global voice-toggle hotkey lands only in the active pane.
+  const view = usePaneView()
+  const { $messages } = view
   const [voiceConversationActive, setVoiceConversationActive] = useState(false)
   const lastSpokenIdRef = useRef<string | null>(null)
 
@@ -122,7 +126,19 @@ export function useComposerVoice({
     }
   }, [conversation, disabled, voiceConversationActive])
 
-  useEffect(() => onComposerVoiceToggleRequest(toggleVoiceConversation), [toggleVoiceConversation])
+  // Active-pane gate: with the split open BOTH composers subscribe to the
+  // broadcast toggle, so an ungated handler would start/stop two recorders
+  // against two sessions on one hotkey press. Single-pane isActive() is
+  // always true — today's behavior exactly.
+  useEffect(
+    () =>
+      onComposerVoiceToggleRequest(() => {
+        if (view.isActive()) {
+          toggleVoiceConversation()
+        }
+      }),
+    [toggleVoiceConversation, view]
+  )
 
   // Explicit start/end for the on-screen conversation controls (the hotkey uses
   // the gated toggle above).
diff --git a/apps/desktop/src/app/chat/composer/index.tsx b/apps/desktop/src/app/chat/composer/index.tsx
index 1f5df46eb2a47..48829a650c07c 100644
--- a/apps/desktop/src/app/chat/composer/index.tsx
+++ b/apps/desktop/src/app/chat/composer/index.tsx
@@ -2,6 +2,7 @@ import { ComposerPrimitive } from '@assistant-ui/react'
 import { useStore } from '@nanostores/react'
 import { type ClipboardEvent, type FormEvent, type KeyboardEvent, useEffect, useRef } from 'react'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { composerFill, composerSurfaceGlass } from '@/components/chat/composer-dock'
 import { Button } from '@/components/ui/button'
 import { useI18n } from '@/i18n'
@@ -9,14 +10,12 @@ import { chatMessageText } from '@/lib/chat-messages'
 import { DATA_IMAGE_URL_RE } from '@/lib/embedded-images'
 import { triggerHaptic } from '@/lib/haptics'
 import { cn } from '@/lib/utils'
-import { $composerAttachments } from '@/store/composer'
 import { browseBackward, browseForward, deriveUserHistory, isBrowsingHistory } from '@/store/composer-input-history'
 import { POPOUT_WIDTH_REM } from '@/store/composer-popout'
 import { removeQueuedPrompt } from '@/store/composer-queue'
 import { $activeSessionAwaitingInput } from '@/store/prompts'
 import { toggleReview } from '@/store/review'
-import { $gatewayState, $messages } from '@/store/session'
-import { $threadScrolledUp } from '@/store/thread-scroll'
+import { $gatewayState } from '@/store/session'
 import { $autoSpeakReplies } from '@/store/voice-prefs'
 import { useTheme } from '@/themes'
 
@@ -82,6 +81,9 @@ export function ChatBar({
   onSubmit,
   onTranscribeAudio
 }: ChatBarProps) {
+  // The pane bundle: this composer's attachments + transcript + scroll flags.
+  // Unwrapped (single-pane) these are the exact global atoms as before.
+  const { $composerAttachments, $messages, $threadScrolledUp } = usePaneView()
   const attachments = useStore($composerAttachments)
   const scrolledUp = useStore($threadScrolledUp)
   const autoSpeak = useStore($autoSpeakReplies)
diff --git a/apps/desktop/src/app/chat/composer/pane-bus-gating.test.tsx b/apps/desktop/src/app/chat/composer/pane-bus-gating.test.tsx
new file mode 100644
index 0000000000000..175f67884f939
--- /dev/null
+++ b/apps/desktop/src/app/chat/composer/pane-bus-gating.test.tsx
@@ -0,0 +1,130 @@
+import { AssistantRuntimeProvider, ExportedMessageRepository, type ThreadMessage } from '@assistant-ui/react'
+import { act, cleanup, render } from '@testing-library/react'
+import type { ReactNode } from 'react'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { createSplitPaneView, type PaneSessionView, PaneViewContext } from '@/app/chat/pane-view'
+import { useIncrementalExternalStoreRuntime } from '@/lib/incremental-external-store-runtime'
+import { clearSessionDraft } from '@/store/composer'
+import { $activePaneId } from '@/store/split'
+
+import { requestComposerInsert } from './focus'
+import { useComposerDraft } from './hooks/use-composer-draft'
+
+// Composer bus gating (design §3.6): with the split open BOTH mounted
+// composers subscribe to the window-global bus as 'main', so an insert
+// targeted 'main' (deep-link blueprint, terminal Cmd+L, review pane) must
+// reach only the ACTIVE pane's draft engine. This drives the REAL
+// useComposerDraft twice — main (default context) and split (provider) — and
+// asserts delivery through each engine's draftRef + editor DOM.
+
+type DraftApi = ReturnType<typeof useComposerDraft>
+
+const EMPTY_REPOSITORY = ExportedMessageRepository.fromBranchableArray([])
+
+function RuntimeShell({ children }: { children: ReactNode }) {
+  const runtime = useIncrementalExternalStoreRuntime<ThreadMessage>({
+    isRunning: false,
+    messageRepository: EMPTY_REPOSITORY,
+    onCancel: async () => undefined,
+    onEdit: async () => undefined,
+    onNew: async () => undefined,
+    onReload: async () => undefined,
+    setMessages: () => undefined
+  })
+
+  return <AssistantRuntimeProvider runtime={runtime}>{children}</AssistantRuntimeProvider>
+}
+
+function DraftProbe({ onReady, testId }: { onReady: (api: DraftApi) => void; testId: string }) {
+  const draft = useComposerDraft({
+    activeQueueSessionKey: null,
+    focusKey: null,
+    inputDisabled: false,
+    queueEditRef: { current: null },
+    sessionId: null
+  })
+
+  onReady(draft)
+
+  return <div contentEditable data-testid={testId} ref={draft.editorRef} suppressContentEditableWarning />
+}
+
+function PaneComposer({
+  onReady,
+  testId,
+  view
+}: {
+  onReady: (api: DraftApi) => void
+  testId: string
+  view?: PaneSessionView
+}) {
+  const probe = (
+    <RuntimeShell>
+      <DraftProbe onReady={onReady} testId={testId} />
+    </RuntimeShell>
+  )
+
+  // Main pane = NO provider: the default context is the main bundle, exactly
+  // like the production tree.
+  return view ? <PaneViewContext.Provider value={view}>{probe}</PaneViewContext.Provider> : probe
+}
+
+async function dispatchInsert(text: string) {
+  await act(async () => {
+    requestComposerInsert(text, { mode: 'block', target: 'main' })
+    // The bus defers dispatch by a macrotask.
+    await new Promise(resolve => window.setTimeout(resolve, 10))
+  })
+}
+
+describe('composer bus gating across panes', () => {
+  let mainDraft!: DraftApi
+  let splitDraft!: DraftApi
+  let splitView: PaneSessionView
+
+  beforeEach(() => {
+    // The draft engine stashes per-session drafts (scope null for a fresh
+    // draft) into localStorage on unmount — clear it so a prior test's draft
+    // can't restore into this one's freshly mounted engines.
+    window.localStorage.clear()
+    clearSessionDraft(null)
+    $activePaneId.set('main')
+    splitView = createSplitPaneView()
+
+    render(
+      <>
+        <PaneComposer onReady={api => (mainDraft = api)} testId="main-editor" />
+        <PaneComposer onReady={api => (splitDraft = api)} testId="split-editor" view={splitView} />
+      </>
+    )
+  })
+
+  afterEach(() => {
+    cleanup()
+    $activePaneId.set('main')
+  })
+
+  it("delivers a 'main'-targeted insert only to the ACTIVE pane's draft engine", async () => {
+    await dispatchInsert('hello main pane')
+
+    expect(mainDraft.draftRef.current).toBe('hello main pane')
+    expect(splitDraft.draftRef.current).toBe('')
+
+    $activePaneId.set('split')
+    await dispatchInsert('hello split pane')
+
+    expect(splitDraft.draftRef.current).toBe('hello split pane')
+    // The main engine kept its earlier draft — the split-targeted insert
+    // never leaked into it.
+    expect(mainDraft.draftRef.current).toBe('hello main pane')
+  })
+
+  it('paints the delivered insert into the active pane editor DOM only', async () => {
+    $activePaneId.set('split')
+    await dispatchInsert('/blueprint deploy')
+
+    expect(document.querySelector('[data-testid="split-editor"]')?.textContent).toContain('/blueprint deploy')
+    expect(document.querySelector('[data-testid="main-editor"]')?.textContent ?? '').toBe('')
+  })
+})
diff --git a/apps/desktop/src/app/chat/composer/status-stack/index.tsx b/apps/desktop/src/app/chat/composer/status-stack/index.tsx
index fd360764da45b..d455313a5cd11 100644
--- a/apps/desktop/src/app/chat/composer/status-stack/index.tsx
+++ b/apps/desktop/src/app/chat/composer/status-stack/index.tsx
@@ -3,6 +3,7 @@ import { type ReactNode, useEffect, useLayoutEffect, useMemo, useRef } from 'rea
 import { useNavigate } from 'react-router-dom'
 
 import { blurComposerInput } from '@/app/chat/composer/focus'
+import { usePaneView } from '@/app/chat/pane-view'
 import { AGENTS_ROUTE } from '@/app/routes'
 import { composerDockCard } from '@/components/chat/composer-dock'
 import { StatusSection } from '@/components/chat/status-section'
@@ -20,7 +21,6 @@ import {
   stopBackgroundProcess
 } from '@/store/composer-status'
 import { $previewStatusBySession, dismissPreviewArtifact } from '@/store/preview-status'
-import { $threadScrolledUp } from '@/store/thread-scroll'
 import { openSessionInNewWindow } from '@/store/windows'
 
 import { PreviewStatusRow } from './preview-row'
@@ -66,6 +66,9 @@ interface ComposerStatusStackProps {
 export function ComposerStatusStack({ queue, sessionId }: ComposerStatusStackProps) {
   const { t } = useI18n()
   const navigate = useNavigate()
+  // Pane-scoped scroll dim: the stack fades with ITS pane's thread, not the
+  // other pane's (single-pane = the module singleton, unchanged).
+  const { $threadScrolledUp } = usePaneView()
   const itemsBySession = useStore($statusItemsBySession)
   const previewsBySession = useStore($previewStatusBySession)
   const scrolledUp = useStore($threadScrolledUp)
diff --git a/apps/desktop/src/app/chat/hooks/use-composer-actions.ts b/apps/desktop/src/app/chat/hooks/use-composer-actions.ts
index d510c59f45b4e..3614d0a439280 100644
--- a/apps/desktop/src/app/chat/hooks/use-composer-actions.ts
+++ b/apps/desktop/src/app/chat/hooks/use-composer-actions.ts
@@ -1,3 +1,4 @@
+import type { WritableAtom } from 'nanostores'
 import { useCallback } from 'react'
 
 import { requestComposerFocus, requestComposerInsert, requestComposerInsertRefs } from '@/app/chat/composer/focus'
@@ -8,6 +9,7 @@ import { attachmentId, contextPath, pathLabel } from '@/lib/chat-runtime'
 import { readDesktopFileDataUrl, selectDesktopPaths } from '@/lib/desktop-fs'
 import { normalize } from '@/lib/text'
 import {
+  $composerAttachments,
   addComposerAttachment,
   type ComposerAttachment,
   removeComposerAttachment,
@@ -257,20 +259,33 @@ export function partitionDroppedFiles(candidates: DroppedFile[]): {
 
 interface ComposerActionsOptions {
   activeSessionId: string | null
+  /** Attachments atom this instance's attach paths write into. Defaults to the
+   *  main composer's module singleton; the split pane passes its own bundle
+   *  atom (see app/chat/pane-view.ts). */
+  attachmentsAtom?: WritableAtom<ComposerAttachment[]>
   currentCwd: string
   requestGateway: <T>(method: string, params?: Record<string, unknown>) => Promise<T>
 }
 
-/** Add to the main composer and focus it. All sidebar/picker/drop attach paths funnel through here. */
-const attachToMain = (attachment: ComposerAttachment) => {
-  addComposerAttachment(attachment)
-  requestComposerFocus('main')
-}
-
-export function useComposerActions({ activeSessionId, currentCwd, requestGateway }: ComposerActionsOptions) {
+export function useComposerActions({
+  activeSessionId,
+  attachmentsAtom = $composerAttachments,
+  currentCwd,
+  requestGateway
+}: ComposerActionsOptions) {
   const { t } = useI18n()
   const copy = t.desktop
 
+  /** Add to this pane's composer and focus it. All sidebar/picker/drop attach
+   *  paths funnel through here. */
+  const attachToMain = useCallback(
+    (attachment: ComposerAttachment) => {
+      addComposerAttachment(attachment, attachmentsAtom)
+      requestComposerFocus('main')
+    },
+    [attachmentsAtom]
+  )
+
   const addTextToDraft = useCallback((text: string) => {
     requestComposerInsert(text, { mode: 'block' })
   }, [])
@@ -288,21 +303,24 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
     requestComposerInsert(refText, { mode: 'inline' })
   }, [])
 
-  const addContextRefAttachment = useCallback((refText: string, label?: string, detail?: string) => {
-    const kind: ComposerAttachment['kind'] = refText.startsWith('@folder:')
-      ? 'folder'
-      : refText.startsWith('@url:')
-        ? 'url'
-        : 'file'
-
-    attachToMain({
-      id: attachmentId(kind, refText),
-      kind,
-      label: label || refText.replace(/^@(file|folder|url):/, ''),
-      detail,
-      refText
-    })
-  }, [])
+  const addContextRefAttachment = useCallback(
+    (refText: string, label?: string, detail?: string) => {
+      const kind: ComposerAttachment['kind'] = refText.startsWith('@folder:')
+        ? 'folder'
+        : refText.startsWith('@url:')
+          ? 'url'
+          : 'file'
+
+      attachToMain({
+        id: attachmentId(kind, refText),
+        kind,
+        label: label || refText.replace(/^@(file|folder|url):/, ''),
+        detail,
+        refText
+      })
+    },
+    [attachToMain]
+  )
 
   const pickContextPaths = useCallback(
     async (kind: 'file' | 'folder') => {
@@ -329,7 +347,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
         })
       }
     },
-    [currentCwd]
+    [attachToMain, currentCwd]
   )
 
   const insertContextPathInlineRef = useCallback(
@@ -371,7 +389,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
 
       return true
     },
-    [currentCwd]
+    [attachToMain, currentCwd]
   )
 
   const attachImagePath = useCallback(
@@ -394,7 +412,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
         const previewUrl = await attachmentPreviewDataUrl(filePath)
 
         if (previewUrl) {
-          addComposerAttachment({ ...baseAttachment, previewUrl })
+          addComposerAttachment({ ...baseAttachment, previewUrl }, attachmentsAtom)
         }
 
         return true
@@ -404,7 +422,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
         return true
       }
     },
-    [copy.imagePreviewFailed]
+    [attachmentsAtom, attachToMain, copy.imagePreviewFailed]
   )
 
   const attachImageBlob = useCallback(
@@ -509,7 +527,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
 
       return true
     },
-    [currentCwd]
+    [attachToMain, currentCwd]
   )
 
   const attachDroppedItems = useCallback(
@@ -599,7 +617,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
 
   const removeAttachment = useCallback(
     async (id: string) => {
-      const removed = removeComposerAttachment(id)
+      const removed = removeComposerAttachment(id, attachmentsAtom)
 
       if (
         removed?.kind === 'image' &&
@@ -614,7 +632,7 @@ export function useComposerActions({ activeSessionId, currentCwd, requestGateway
         }).catch(() => undefined)
       }
     },
-    [activeSessionId, requestGateway]
+    [activeSessionId, attachmentsAtom, requestGateway]
   )
 
   return {
diff --git a/apps/desktop/src/app/chat/index.tsx b/apps/desktop/src/app/chat/index.tsx
index 57ecb2c0389ab..eed2977653b95 100644
--- a/apps/desktop/src/app/chat/index.tsx
+++ b/apps/desktop/src/app/chat/index.tsx
@@ -25,26 +25,8 @@ import { cn } from '@/lib/utils'
 import type { ComposerAttachment } from '@/store/composer'
 import { $pinnedSessionIds } from '@/store/layout'
 import { $activeGatewayProfile, $gatewaySwapTarget, normalizeProfileKey } from '@/store/profile'
-import {
-  $activeSessionId,
-  $awaitingResponse,
-  $busy,
-  $contextSuggestions,
-  $currentCwd,
-  $currentModel,
-  $currentProvider,
-  $freshDraftReady,
-  $gatewayState,
-  $introPersonality,
-  $introSeed,
-  $lastVisibleMessageIsUser,
-  $messages,
-  $messagesEmpty,
-  $resumeExhaustedSessionId,
-  $selectedStoredSessionId,
-  $sessions,
-  sessionPinId
-} from '@/store/session'
+import { $gatewayState, $introPersonality, $introSeed, $sessions, sessionPinId } from '@/store/session'
+import { $activePaneId, $splitPaneSession } from '@/store/split'
 import { isSecondaryWindow, isWatchWindow } from '@/store/windows'
 import type { ModelOptionsResponse } from '@/types/hermes'
 
@@ -59,6 +41,7 @@ import { droppedFileInlineRefs, type SessionDragPayload, sessionInlineRef } from
 import type { ChatBarState } from './composer/types'
 import { type DroppedFile, partitionDroppedFiles } from './hooks/use-composer-actions'
 import { useFileDropZone } from './hooks/use-file-drop-zone'
+import { usePaneView } from './pane-view'
 import { ScrollToBottomButton } from './scroll-to-bottom-button'
 import { SessionActionsMenu } from './sidebar/session-actions-menu'
 import { threadLoadingState } from './thread-loading'
@@ -198,6 +181,9 @@ function ChatRuntimeBoundary({
   onThreadMessagesChange,
   suppressMessages
 }: ChatRuntimeBoundaryProps) {
+  // The pane's transcript atom — unwrapped (single-pane) this is the exact
+  // global $messages the boundary always subscribed to.
+  const { $messages } = usePaneView()
   const storeMessages = useStore($messages)
   const messages = suppressMessages ? NO_MESSAGES : storeMessages
   const runtimeMessageCacheRef = useRef(new WeakMap<ChatMessage, ThreadMessage>())
@@ -283,14 +269,21 @@ export function ChatView({
 }: ChatViewProps) {
   const location = useLocation()
   const { t } = useI18n()
-  const activeSessionId = useStore($activeSessionId)
-  const awaitingResponse = useStore($awaitingResponse)
-  const busy = useStore($busy)
-  const contextSuggestions = useStore($contextSuggestions)
-  const currentCwd = useStore($currentCwd)
-  const currentModel = useStore($currentModel)
-  const currentProvider = useStore($currentProvider)
-  const freshDraftReady = useStore($freshDraftReady)
+  // The pane bundle: every session-view read below goes through it. With the
+  // default (main) context these are the exact global atoms this component
+  // always subscribed to — single-pane behavior is bit-for-bit unchanged.
+  const view = usePaneView()
+  const activePaneId = useStore($activePaneId)
+  const paneActive = activePaneId === view.paneId
+  const splitPaneSession = useStore($splitPaneSession)
+  const activeSessionId = useStore(view.$activeSessionId)
+  const awaitingResponse = useStore(view.$awaitingResponse)
+  const busy = useStore(view.$busy)
+  const contextSuggestions = useStore(view.$contextSuggestions)
+  const currentCwd = useStore(view.$currentCwd)
+  const currentModel = useStore(view.$currentModel)
+  const currentProvider = useStore(view.$currentProvider)
+  const freshDraftReady = useStore(view.$freshDraftReady)
   const gatewayState = useStore($gatewayState)
   const gatewaySwapTarget = useStore($gatewaySwapTarget)
   const gatewayOpen = gatewayState === 'open'
@@ -301,11 +294,17 @@ export function ChatView({
   // the entire chat shell (header, chat bar, thread wrapper) per token. The
   // runtime that DOES need the messages lives in ChatRuntimeBoundary below;
   // this component only needs streaming-stable derivations.
-  const messagesEmpty = useStore($messagesEmpty)
-  const lastVisibleIsUser = useStore($lastVisibleMessageIsUser)
-  const selectedSessionId = useStore($selectedStoredSessionId)
-  const resumeExhaustedSessionId = useStore($resumeExhaustedSessionId)
-  const routedSessionId = routeSessionId(location.pathname)
+  const messagesEmpty = useStore(view.$messagesEmpty)
+  const lastVisibleIsUser = useStore(view.$lastVisibleMessageIsUser)
+  const selectedSessionId = useStore(view.$selectedStoredSessionId)
+  const resumeExhaustedSessionId = useStore(view.$resumeExhaustedSessionId)
+
+  // The pane's routing target. The MAIN pane stays URL-derived (identical
+  // values + reactivity to before); the split pane reads its pane-local
+  // session pointer — the URL always belongs to the main pane.
+  const routedSessionId =
+    view.paneId === 'main' ? routeSessionId(location.pathname) : (splitPaneSession?.storedId ?? null)
+
   const isRoutedSessionView = Boolean(routedSessionId)
 
   // The URL points at a session the store hasn't loaded yet (sidebar / cmd-K /
@@ -315,8 +314,10 @@ export function ChatView({
   const routeSessionMismatch = isRoutedSessionView && routedSessionId !== selectedSessionId
 
   // The compact new-session pop-out skips the wordmark/tagline intro — it's a
-  // scratch window, not the full-height empty state.
+  // scratch window, not the full-height empty state. The split pane skips it
+  // too: its fresh draft is a side surface, not the app's empty state.
   const showIntro =
+    view.paneId === 'main' &&
     !isSecondaryWindow() &&
     freshDraftReady &&
     !isRoutedSessionView &&
@@ -442,7 +443,11 @@ export function ChatView({
         selectedSessionId={selectedSessionId}
       />
 
-      <PromptOverlays />
+      {/* Blocking prompts (clarify/approval/sudo/secret) read active-scoped
+          globals, so only the ACTIVE pane may render them — the inactive pane
+          signals through the sidebar attention badge instead. Single-pane the
+          main pane is always active, so this renders exactly as before. */}
+      {paneActive && <PromptOverlays />}
 
       <ChatRuntimeBoundary
         busy={busy}
@@ -487,7 +492,12 @@ export function ChatView({
           )}
           {showChatBar && <ScrollToBottomButton />}
           <ChatDropOverlay kind={dragKind} />
-          <ChatSwapOverlay profile={gatewaySwapTarget} />
+          {/* The swap pill describes the ACTIVE gateway's profile move, so
+              only the active pane paints it — with the panes on different
+              profiles every focus flip runs a swap, and an ungated overlay
+              would pulse over BOTH transcripts on each click. Single-pane
+              paneActive is always true — today's behavior. */}
+          <ChatSwapOverlay profile={paneActive ? gatewaySwapTarget : null} />
         </div>
         {/* Composer renders OUTSIDE the contain:[layout paint] wrapper above:
             that wrapper is a containing block for — and clips — position:fixed
diff --git a/apps/desktop/src/app/chat/pane-request.test.ts b/apps/desktop/src/app/chat/pane-request.test.ts
new file mode 100644
index 0000000000000..479aa869eee7e
--- /dev/null
+++ b/apps/desktop/src/app/chat/pane-request.test.ts
@@ -0,0 +1,223 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import type { SessionInfo } from '@/hermes'
+import { $paneStates } from '@/store/panes'
+import { setSelectedStoredSessionId, setSessions } from '@/store/session'
+import { $activePaneId, $splitFreshDraft, $splitPaneSession, SPLIT_PANE_ID } from '@/store/split'
+
+import { createMainPaneRequest, createPaneRequest } from './pane-request'
+import { MAIN_PANE_VIEW } from './pane-view'
+
+// The main pane's selection, as the wrapper reads it: the UNMIRRORED cache
+// ref (while the split is focused the $selectedStoredSessionId singleton
+// mirrors the SPLIT's session). The atom is set alongside to mirror how
+// use-session-actions writes both in lockstep.
+function setMainSelection(storedId: null | string) {
+  MAIN_PANE_VIEW.selectedStoredSessionIdRef.current = storedId
+  setSelectedStoredSessionId(storedId)
+}
+
+// Profile pinning (design §4): the split's request wrapper closes the
+// Enter-beats-swap race when active and pins to the profile's own socket when
+// inactive; the main pane's wrapper is a pure pass-through until the split
+// opens.
+
+const ensureGatewayProfile = vi.fn<(profile: string | null | undefined) => Promise<void>>(async () => undefined)
+
+const ensureProfileSocketOpen = vi.fn<
+  (profile: string | null | undefined) => Promise<null | { request: typeof socketRequest }>
+>(async () => ({ request: socketRequest }))
+
+const socketRequest = vi.fn(async () => 'socket-result' as never)
+
+vi.mock('@/store/profile', () => ({
+  ensureGatewayProfile: (profile: string | null | undefined) => ensureGatewayProfile(profile)
+}))
+
+vi.mock('@/store/gateway', () => ({
+  ensureProfileSocketOpen: (profile: string | null | undefined) => ensureProfileSocketOpen(profile)
+}))
+
+function storedSession(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    ended_at: null,
+    id: 'stored-1',
+    input_tokens: 0,
+    is_active: false,
+    last_active: 1,
+    message_count: 0,
+    model: null,
+    output_tokens: 0,
+    preview: null,
+    source: 'desktop',
+    started_at: 1,
+    title: 'stored',
+    tool_call_count: 0,
+    ...overrides
+  }
+}
+
+afterEach(() => {
+  ensureGatewayProfile.mockClear()
+  ensureProfileSocketOpen.mockClear()
+  socketRequest.mockClear()
+  $paneStates.set({})
+  $splitPaneSession.set(null)
+  $splitFreshDraft.set(false)
+  $activePaneId.set('main')
+  setMainSelection(null)
+  setSessions([])
+})
+
+describe('createPaneRequest (split pane)', () => {
+  it('active pane: awaits the in-flight profile swap BEFORE the shared request goes out', async () => {
+    let releaseSwap!: () => void
+    ensureGatewayProfile.mockImplementationOnce(
+      () =>
+        new Promise<void>(resolve => {
+          releaseSwap = resolve
+        })
+    )
+
+    const order: string[] = []
+
+    const requestGateway = vi.fn(async (method: string) => {
+      order.push(`request:${method}`)
+
+      return 'active-result' as never
+    })
+
+    const paneRequest = createPaneRequest({
+      getProfile: () => 'coder',
+      isActive: () => true,
+      requestGateway
+    })
+
+    const pending = paneRequest('prompt.submit', { text: 'hi' })
+    await Promise.resolve()
+
+    // The swap hasn't settled — the submit must still be parked.
+    expect(ensureGatewayProfile).toHaveBeenCalledWith('coder')
+    expect(requestGateway).not.toHaveBeenCalled()
+
+    order.push('swap:settled')
+    releaseSwap()
+
+    await expect(pending).resolves.toBe('active-result')
+    expect(order).toEqual(['swap:settled', 'request:prompt.submit'])
+    expect(ensureProfileSocketOpen).not.toHaveBeenCalled()
+  })
+
+  it("inactive pane: pins to the profile's own socket and never touches the active gateway", async () => {
+    const requestGateway = vi.fn(async () => 'active-result' as never)
+
+    const paneRequest = createPaneRequest({
+      getProfile: () => 'coder',
+      isActive: () => false,
+      requestGateway
+    })
+
+    await expect(paneRequest('session.resume', { session_id: 's-1' }, 5_000)).resolves.toBe('socket-result')
+
+    expect(ensureProfileSocketOpen).toHaveBeenCalledWith('coder')
+    expect(socketRequest).toHaveBeenCalledWith('session.resume', { session_id: 's-1' }, 5_000, undefined)
+    expect(requestGateway).not.toHaveBeenCalled()
+    expect(ensureGatewayProfile).not.toHaveBeenCalled()
+  })
+
+  it('inactive pane: surfaces a gateway-unavailable error when no socket can be opened', async () => {
+    ensureProfileSocketOpen.mockResolvedValueOnce(null)
+
+    const paneRequest = createPaneRequest({
+      getProfile: () => 'coder',
+      isActive: () => false,
+      requestGateway: vi.fn(async () => 'unused' as never)
+    })
+
+    await expect(paneRequest('session.resume')).rejects.toThrow('Hermes gateway unavailable')
+  })
+})
+
+describe('createMainPaneRequest', () => {
+  it('split closed: pure pass-through — no profile machinery at all', async () => {
+    const requestGateway = vi.fn(async () => 'main-result' as never)
+    const mainRequest = createMainPaneRequest({ requestGateway })
+
+    await expect(mainRequest('prompt.submit', { text: 'hi' })).resolves.toBe('main-result')
+
+    expect(requestGateway).toHaveBeenCalledWith('prompt.submit', { text: 'hi' }, undefined, undefined)
+    expect(ensureGatewayProfile).not.toHaveBeenCalled()
+  })
+
+  it("split open, main pane ACTIVE: settles the swap onto the main session's profile before sending", async () => {
+    $paneStates.set({ [SPLIT_PANE_ID]: { open: true } })
+    $splitPaneSession.set({ profile: 'coder', storedId: 'stored-split' })
+    setMainSelection('stored-main')
+    setSessions([storedSession({ id: 'stored-main', profile: 'analyst' })])
+
+    const requestGateway = vi.fn(async () => 'main-result' as never)
+    const mainRequest = createMainPaneRequest({ requestGateway })
+
+    await expect(mainRequest('prompt.submit')).resolves.toBe('main-result')
+
+    expect(ensureGatewayProfile).toHaveBeenCalledWith('analyst')
+    expect(requestGateway).toHaveBeenCalledTimes(1)
+    expect(ensureProfileSocketOpen).not.toHaveBeenCalled()
+  })
+
+  it('split open with a fresh main draft: settles any in-flight swap with a null profile', async () => {
+    $paneStates.set({ [SPLIT_PANE_ID]: { open: true } })
+    $splitPaneSession.set({ profile: 'coder', storedId: 'stored-split' })
+    setMainSelection(null)
+
+    const requestGateway = vi.fn(async () => 'main-result' as never)
+    const mainRequest = createMainPaneRequest({ requestGateway })
+
+    await mainRequest('prompt.submit')
+
+    expect(ensureGatewayProfile).toHaveBeenCalledWith(null)
+  })
+
+  it("split FOCUSED (main pane background): pins to the main session's own profile socket", async () => {
+    // The background main-pane dispatchers (reconnect route-resume, bounded
+    // auto-retry, queue auto-drain) fire while the split is focused. The
+    // active gateway belongs to the split then, so their RPCs must ride the
+    // main session's pinned socket — and the profile must come from the
+    // UNMIRRORED selection ref, not the mirrored singleton.
+    $paneStates.set({ [SPLIT_PANE_ID]: { open: true } })
+    $splitPaneSession.set({ profile: 'coder', storedId: 'stored-split' })
+    $activePaneId.set('split')
+    MAIN_PANE_VIEW.selectedStoredSessionIdRef.current = 'stored-main'
+    // The mirrored singleton points at the SPLIT's session — it must be ignored.
+    setSelectedStoredSessionId('stored-split')
+    setSessions([
+      storedSession({ id: 'stored-main', profile: 'analyst' }),
+      storedSession({ id: 'stored-split', profile: 'coder' })
+    ])
+
+    const requestGateway = vi.fn(async () => 'active-result' as never)
+    const mainRequest = createMainPaneRequest({ requestGateway })
+
+    await expect(mainRequest('session.resume', { session_id: 'stored-main' })).resolves.toBe('socket-result')
+
+    expect(ensureProfileSocketOpen).toHaveBeenCalledWith('analyst')
+    expect(socketRequest).toHaveBeenCalledWith('session.resume', { session_id: 'stored-main' }, undefined, undefined)
+    expect(requestGateway).not.toHaveBeenCalled()
+    expect(ensureGatewayProfile).not.toHaveBeenCalled()
+  })
+
+  it('split FOCUSED with a profile-less main pane: stays on the shared path', async () => {
+    $paneStates.set({ [SPLIT_PANE_ID]: { open: true } })
+    $splitPaneSession.set({ profile: 'coder', storedId: 'stored-split' })
+    $activePaneId.set('split')
+    MAIN_PANE_VIEW.selectedStoredSessionIdRef.current = null
+
+    const requestGateway = vi.fn(async () => 'active-result' as never)
+    const mainRequest = createMainPaneRequest({ requestGateway })
+
+    await expect(mainRequest('config.get')).resolves.toBe('active-result')
+
+    expect(ensureProfileSocketOpen).not.toHaveBeenCalled()
+    expect(ensureGatewayProfile).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/app/chat/pane-request.ts b/apps/desktop/src/app/chat/pane-request.ts
new file mode 100644
index 0000000000000..ec0defcd6b9b9
--- /dev/null
+++ b/apps/desktop/src/app/chat/pane-request.ts
@@ -0,0 +1,134 @@
+import { ensureProfileSocketOpen } from '@/store/gateway'
+import { ensureGatewayProfile } from '@/store/profile'
+import { $sessions } from '@/store/session'
+import { $splitOpen } from '@/store/split'
+import { isSecondaryWindow } from '@/store/windows'
+
+import { MAIN_PANE_VIEW } from './pane-view'
+
+// ── Profile-pinned gateway request wrappers (design §4) ─────────────────────
+//
+// Invariant P1: sends/resumes execute only from the ACTIVE pane, whose
+// activation already swapped the active gateway to its profile. These wrappers
+// close the remaining holes:
+//
+// 1. Enter-beats-swap — activation `void`s its ensureGatewayProfile, so a
+//    keystroke-fast submit could race out over the previous pane's socket.
+//    The active branch awaits the (serialized, no-op-when-settled) swap first.
+// 2. Background-pane ops — a pane can issue RPCs while INACTIVE (the split's
+//    boot restore; the MAIN pane's reconnect route-resume, bounded auto-retry
+//    and queue auto-drain while the split is focused). Those must never ride
+//    the active gateway — with the panes on different profiles it belongs to
+//    the OTHER pane — so they go out over their own profile's pinned socket
+//    (opened/reused without touching the active pointer).
+
+export type PaneGatewayRequest = <T>(
+  method: string,
+  params?: Record<string, unknown>,
+  timeoutMs?: number,
+  signal?: AbortSignal
+) => Promise<T>
+
+interface PaneRequestDeps {
+  /** The pane's session profile tag (null = default profile / untagged). */
+  getProfile: () => string | null
+  isActive: () => boolean
+  /** The shared active-gateway request (use-gateway-request). */
+  requestGateway: PaneGatewayRequest
+}
+
+/** The SPLIT pane's request fn: active → settle the profile swap, then the
+ *  shared active-gateway path; inactive → the profile's own pinned socket. */
+export function createPaneRequest({ getProfile, isActive, requestGateway }: PaneRequestDeps): PaneGatewayRequest {
+  return async <T>(method: string, params: Record<string, unknown> = {}, timeoutMs?: number, signal?: AbortSignal) => {
+    const profile = getProfile()
+
+    if (isActive()) {
+      // No-op fast path when already on-profile; a null tag still awaits any
+      // in-flight swap (ensureGatewayProfile's "no explicit profile" branch),
+      // which is exactly the race being closed.
+      await ensureGatewayProfile(profile)
+
+      return requestGateway<T>(method, params, timeoutMs, signal)
+    }
+
+    const socket = await ensureProfileSocketOpen(profile)
+
+    if (!socket) {
+      throw new Error('Hermes gateway unavailable')
+    }
+
+    return socket.request<T>(method, params, timeoutMs, signal)
+  }
+}
+
+/**
+ * The MAIN pane's session profile: its selected session's row tag. Null for a
+ * fresh draft ("no explicit profile" → ensureGatewayProfile only settles any
+ * in-flight swap and keeps the current gateway — today's semantics). Also
+ * used by SplitChatPane's switch-back activation to restore the gateway.
+ *
+ * Reads the UNMIRRORED selection: while the split pane is focused the
+ * $selectedStoredSessionId singleton mirrors the SPLIT's session
+ * (split-mirror.ts), so the main pane's truth is the cache ref the controller
+ * binds into MAIN_PANE_VIEW — written synchronously by every main-pane
+ * resume/draft/create. Split closed, ref and atom are always identical.
+ */
+export function mainPaneSessionProfile(): string | null {
+  const selected = MAIN_PANE_VIEW.selectedStoredSessionIdRef.current
+
+  if (!selected) {
+    return null
+  }
+
+  return (
+    $sessions.get().find(session => session.id === selected || session._lineage_root_id === selected)?.profile ?? null
+  )
+}
+
+/**
+ * The MAIN pane's request fn. With the split closed this is a pure
+ * pass-through — byte-identical single-pane behavior. While the split is open:
+ *
+ * - main pane ACTIVE → the same swap-settling guard as the split's wrapper,
+ *   so a send fired the instant focus returns can't race the activation swap
+ *   back onto the split's socket;
+ * - main pane BACKGROUND (split focused) → the main session's own profile
+ *   socket. The active gateway belongs to the split, and the non-interactive
+ *   main-pane dispatchers (reconnect route-resume, bounded resume auto-retry,
+ *   composer queue auto-drain) keep firing while the split is focused — with
+ *   the panes on different profiles their RPCs would otherwise land on the
+ *   split profile's backend and "session not found".
+ */
+export function createMainPaneRequest({ requestGateway }: { requestGateway: PaneGatewayRequest }): PaneGatewayRequest {
+  return async <T>(method: string, params: Record<string, unknown> = {}, timeoutMs?: number, signal?: AbortSignal) => {
+    // Secondary windows share localStorage, so their $splitOpen snapshot can
+    // read true for a split only the main window renders — stay pass-through.
+    if (!$splitOpen.get() || isSecondaryWindow()) {
+      return requestGateway<T>(method, params, timeoutMs, signal)
+    }
+
+    const profile = mainPaneSessionProfile()
+
+    if (MAIN_PANE_VIEW.isActive()) {
+      await ensureGatewayProfile(profile)
+
+      return requestGateway<T>(method, params, timeoutMs, signal)
+    }
+
+    // A profile-less main pane (fresh draft) has no pinned socket to prefer,
+    // and nothing session-bound can be in flight for a draft — keep the
+    // shared path rather than guessing a profile.
+    if (profile === null) {
+      return requestGateway<T>(method, params, timeoutMs, signal)
+    }
+
+    const socket = await ensureProfileSocketOpen(profile)
+
+    if (!socket) {
+      throw new Error('Hermes gateway unavailable')
+    }
+
+    return socket.request<T>(method, params, timeoutMs, signal)
+  }
+}
diff --git a/apps/desktop/src/app/chat/pane-view.ts b/apps/desktop/src/app/chat/pane-view.ts
new file mode 100644
index 0000000000000..9a1519e4ca766
--- /dev/null
+++ b/apps/desktop/src/app/chat/pane-view.ts
@@ -0,0 +1,377 @@
+import { atom, computed, type ReadableAtom, type WritableAtom } from 'nanostores'
+import { createContext, type MutableRefObject, useContext } from 'react'
+
+import type { ContextSuggestion } from '@/app/types'
+import type { ChatMessage } from '@/lib/chat-messages'
+import { $composerAttachments, type ComposerAttachment } from '@/store/composer'
+import {
+  $activeSessionId,
+  $awaitingResponse,
+  $busy,
+  $contextSuggestions,
+  $currentBranch,
+  $currentCwd,
+  $currentFastMode,
+  $currentModel,
+  $currentPersonality,
+  $currentProvider,
+  $currentReasoningEffort,
+  $currentServiceTier,
+  $currentUsage,
+  $freshDraftReady,
+  $lastVisibleMessageIsUser,
+  $messages,
+  $messagesEmpty,
+  $resumeExhaustedSessionId,
+  $resumeFailedSessionId,
+  $selectedStoredSessionId,
+  $sessionStartedAt,
+  $turnStartedAt,
+  $yoloActive,
+  getRememberedWorkspaceCwd,
+  setActiveSessionId,
+  setAwaitingResponse,
+  setBusy,
+  setContextSuggestions,
+  setCurrentBranch,
+  setCurrentCwd,
+  setCurrentFastMode,
+  setCurrentModel,
+  setCurrentPersonality,
+  setCurrentProvider,
+  setCurrentReasoningEffort,
+  setCurrentServiceTier,
+  setCurrentUsage,
+  setFreshDraftReady,
+  setMessages,
+  setResumeExhaustedSessionId,
+  setResumeFailedSessionId,
+  setSelectedStoredSessionId,
+  setSessionStartedAt,
+  setTurnStartedAt,
+  setYoloActive
+} from '@/store/session'
+import { $activePaneId, $splitPaneSession, type PaneId, setSplitPaneFreshDraft, setSplitPaneSession } from '@/store/split'
+import {
+  createThreadScrollAtoms,
+  mainThreadScroll,
+  type ThreadScrollInstance
+} from '@/store/thread-scroll'
+import type { UsageStats } from '@/types/hermes'
+
+import { lastVisibleMessageIsUser } from './thread-loading'
+
+type Updater<T> = T | ((current: T) => T)
+
+/**
+ * One chat pane's view-state bundle — the atoms/setters/refs a mounted
+ * ChatView + composer + thread subtree reads and writes, plus the pane's
+ * routing surface. The MAIN pane's bundle IS the existing `store/session.ts`
+ * singleton block (aliased, not copied), so every consumer migrated to
+ * `usePaneView()` keeps reading the identical atom objects in single-pane
+ * mode — bit-for-bit today's behavior. The split pane gets a fresh,
+ * factory-created instance whose setters are plain atom writes (no
+ * localStorage side effects), so a background stream can never clobber the
+ * sticky composer-model keys.
+ */
+export interface PaneSessionView {
+  paneId: PaneId
+
+  // ── View atoms (see store/session.ts for meanings) ─────────────────────
+  $activeSessionId: WritableAtom<string | null>
+  $selectedStoredSessionId: WritableAtom<string | null>
+  $messages: WritableAtom<ChatMessage[]>
+  $messagesEmpty: ReadableAtom<boolean>
+  $lastVisibleMessageIsUser: ReadableAtom<boolean>
+  $busy: WritableAtom<boolean>
+  $awaitingResponse: WritableAtom<boolean>
+  $freshDraftReady: WritableAtom<boolean>
+  $resumeFailedSessionId: WritableAtom<string | null>
+  $resumeExhaustedSessionId: WritableAtom<string | null>
+  $currentModel: WritableAtom<string>
+  $currentProvider: WritableAtom<string>
+  $currentReasoningEffort: WritableAtom<string>
+  $currentServiceTier: WritableAtom<string>
+  $currentFastMode: WritableAtom<boolean>
+  $yoloActive: WritableAtom<boolean>
+  $currentCwd: WritableAtom<string>
+  $currentBranch: WritableAtom<string>
+  $currentUsage: WritableAtom<UsageStats>
+  $sessionStartedAt: WritableAtom<number | null>
+  $turnStartedAt: WritableAtom<number | null>
+  $currentPersonality: WritableAtom<string>
+  $contextSuggestions: WritableAtom<ContextSuggestion[]>
+  $composerAttachments: WritableAtom<ComposerAttachment[]>
+  $threadScrolledUp: WritableAtom<boolean>
+  $threadJumpButtonVisible: WritableAtom<boolean>
+
+  // ── Setters (Updater form, mirroring store/session.ts signatures) ──────
+  setActiveSessionId: (next: Updater<string | null>) => void
+  setSelectedStoredSessionId: (next: Updater<string | null>) => void
+  setMessages: (next: Updater<ChatMessage[]>) => void
+  setBusy: (next: Updater<boolean>) => void
+  setAwaitingResponse: (next: Updater<boolean>) => void
+  setFreshDraftReady: (next: Updater<boolean>) => void
+  setResumeFailedSessionId: (next: Updater<string | null>) => void
+  setResumeExhaustedSessionId: (next: Updater<string | null>) => void
+  setCurrentModel: (next: Updater<string>) => void
+  setCurrentProvider: (next: Updater<string>) => void
+  setCurrentReasoningEffort: (next: Updater<string>) => void
+  setCurrentServiceTier: (next: Updater<string>) => void
+  setCurrentFastMode: (next: Updater<boolean>) => void
+  setYoloActive: (next: Updater<boolean>) => void
+  setCurrentCwd: (next: Updater<string>) => void
+  setCurrentBranch: (next: Updater<string>) => void
+  setCurrentUsage: (next: Updater<UsageStats>) => void
+  setSessionStartedAt: (next: Updater<number | null>) => void
+  setTurnStartedAt: (next: Updater<number | null>) => void
+  setCurrentPersonality: (next: Updater<string>) => void
+  setContextSuggestions: (next: Updater<ContextSuggestion[]>) => void
+
+  // ── Thread-scroll instance ops (per-pane; see store/thread-scroll.ts) ──
+  setThreadAtBottom: (isAtBottom: boolean) => void
+  resetThreadScroll: () => void
+  requestScrollToBottom: () => void
+  onScrollToBottomRequest: (handler: () => void) => () => void
+
+  // ── Refs owned by the pane ──────────────────────────────────────────────
+  activeSessionIdRef: MutableRefObject<string | null>
+  selectedStoredSessionIdRef: MutableRefObject<string | null>
+  busyRef: MutableRefObject<boolean>
+  creatingSessionRef: MutableRefObject<boolean>
+  /** Runtime id whose transcript currently occupies this pane's $messages. */
+  viewSessionIdRef: MutableRefObject<string | null>
+
+  // ── Pane routing surface ────────────────────────────────────────────────
+  /** Stored id this pane should be showing (main: route; split: $splitPaneSession). */
+  getTargetSessionId: () => string | null
+  /** main: router navigate(sessionRoute(id)); split: $splitPaneSession swap. */
+  navigateToSession: (storedId: string, replace?: boolean) => void
+  /** main: router navigate(NEW_CHAT_ROUTE); split: pane-local fresh-draft flag. */
+  navigateToNewChat: (replace?: boolean) => void
+  isActive: () => boolean
+}
+
+const ref = <T>(value: T): MutableRefObject<T> => ({ current: value })
+
+const paneThreadScrollMembers = (threadScroll: ThreadScrollInstance) => ({
+  $threadScrolledUp: threadScroll.$threadScrolledUp,
+  $threadJumpButtonVisible: threadScroll.$threadJumpButtonVisible,
+  setThreadAtBottom: threadScroll.setThreadAtBottom,
+  resetThreadScroll: threadScroll.resetThreadScroll,
+  requestScrollToBottom: threadScroll.requestScrollToBottom,
+  onScrollToBottomRequest: threadScroll.onScrollToBottomRequest
+})
+
+/**
+ * The main pane's bundle: the existing global singletons, aliased. Nothing is
+ * copied — `MAIN_PANE_VIEW.$messages === store/session.$messages` — which is
+ * the whole compat shim: with the split closed, every migrated consumer is
+ * reading exactly the atoms it read before.
+ *
+ * The routing surface + pane refs need the router / state-cache instances that
+ * only exist once DesktopController mounts, so they start as inert defaults
+ * and the controller injects the live bindings via {@link bindMainPaneView}.
+ */
+export const MAIN_PANE_VIEW: PaneSessionView = {
+  paneId: 'main',
+
+  $activeSessionId,
+  $selectedStoredSessionId,
+  $messages,
+  $messagesEmpty,
+  $lastVisibleMessageIsUser,
+  $busy,
+  $awaitingResponse,
+  $freshDraftReady,
+  $resumeFailedSessionId,
+  $resumeExhaustedSessionId,
+  $currentModel,
+  $currentProvider,
+  $currentReasoningEffort,
+  $currentServiceTier,
+  $currentFastMode,
+  $yoloActive,
+  $currentCwd,
+  $currentBranch,
+  $currentUsage,
+  $sessionStartedAt,
+  $turnStartedAt,
+  $currentPersonality,
+  $contextSuggestions,
+  $composerAttachments,
+
+  setActiveSessionId,
+  setSelectedStoredSessionId,
+  setMessages,
+  setBusy,
+  setAwaitingResponse,
+  setFreshDraftReady,
+  setResumeFailedSessionId,
+  setResumeExhaustedSessionId,
+  setCurrentModel,
+  setCurrentProvider,
+  setCurrentReasoningEffort,
+  setCurrentServiceTier,
+  setCurrentFastMode,
+  setYoloActive,
+  setCurrentCwd,
+  setCurrentBranch,
+  setCurrentUsage,
+  setSessionStartedAt,
+  setTurnStartedAt,
+  setCurrentPersonality,
+  setContextSuggestions,
+
+  ...paneThreadScrollMembers(mainThreadScroll),
+
+  activeSessionIdRef: ref<string | null>(null),
+  selectedStoredSessionIdRef: ref<string | null>(null),
+  busyRef: ref(false),
+  creatingSessionRef: ref(false),
+  viewSessionIdRef: ref<string | null>(null),
+
+  getTargetSessionId: () => null,
+  navigateToSession: () => undefined,
+  navigateToNewChat: () => undefined,
+  isActive: () => $activePaneId.get() === 'main'
+}
+
+export type MainPaneViewBindings = Partial<
+  Pick<
+    PaneSessionView,
+    | 'activeSessionIdRef'
+    | 'busyRef'
+    | 'creatingSessionRef'
+    | 'getTargetSessionId'
+    | 'navigateToNewChat'
+    | 'navigateToSession'
+    | 'selectedStoredSessionIdRef'
+    | 'viewSessionIdRef'
+  >
+>
+
+/** Inject the router + state-cache bindings into the main bundle at controller
+ *  mount. Everything else on MAIN_PANE_VIEW is a module-level alias and never
+ *  changes; only the per-mount surfaces are late-bound. */
+export function bindMainPaneView(bindings: MainPaneViewBindings): void {
+  Object.assign(MAIN_PANE_VIEW, bindings)
+}
+
+// Split setters are plain atom writes (Updater unwrap only) — deliberately NOT
+// the store/session setters, whose model/cwd variants persist to localStorage.
+// Structural atom shape (get/set on the same T) mirrors store/session's
+// updateAtom so inference lands on the mutable array type.
+interface PaneAtom<T> {
+  get: () => T
+  set: (value: T) => void
+}
+
+const update = <T>(store: PaneAtom<T>, next: Updater<T>) =>
+  store.set(typeof next === 'function' ? (next as (current: T) => T)(store.get()) : next)
+
+/** A fresh, self-contained bundle for the split pane. Same defaults as the
+ *  main block; the composer-sticky atoms seed from the live sticky values so
+ *  a split new-chat opens on your last pick — but split setters are plain
+ *  atom writes, so nothing here ever touches the persisted keys. */
+export function createSplitPaneView(): PaneSessionView {
+  const $paneActiveSessionId = atom<string | null>(null)
+  const $paneSelectedStoredSessionId = atom<string | null>(null)
+  const $paneMessages = atom<ChatMessage[]>([])
+  const $paneBusy = atom(false)
+  const $paneAwaitingResponse = atom(false)
+  const $paneFreshDraftReady = atom(false)
+  const $paneResumeFailedSessionId = atom<string | null>(null)
+  const $paneResumeExhaustedSessionId = atom<string | null>(null)
+  const $paneCurrentModel = atom($currentModel.get())
+  const $paneCurrentProvider = atom($currentProvider.get())
+  const $paneCurrentReasoningEffort = atom($currentReasoningEffort.get())
+  const $paneCurrentServiceTier = atom('')
+  const $paneCurrentFastMode = atom($currentFastMode.get())
+  const $paneYoloActive = atom(false)
+  const $paneCurrentCwd = atom(getRememberedWorkspaceCwd())
+  const $paneCurrentBranch = atom('')
+
+  const $paneCurrentUsage = atom<UsageStats>({
+    calls: 0,
+    input: 0,
+    output: 0,
+    total: 0
+  })
+
+  const $paneSessionStartedAt = atom<number | null>(null)
+  const $paneTurnStartedAt = atom<number | null>(null)
+  const $paneCurrentPersonality = atom('')
+  const $paneContextSuggestions = atom<ContextSuggestion[]>([])
+  const $paneComposerAttachments = atom<ComposerAttachment[]>([])
+
+  return {
+    paneId: 'split',
+
+    $activeSessionId: $paneActiveSessionId,
+    $selectedStoredSessionId: $paneSelectedStoredSessionId,
+    $messages: $paneMessages,
+    $messagesEmpty: computed($paneMessages, messages => messages.length === 0),
+    $lastVisibleMessageIsUser: computed($paneMessages, lastVisibleMessageIsUser),
+    $busy: $paneBusy,
+    $awaitingResponse: $paneAwaitingResponse,
+    $freshDraftReady: $paneFreshDraftReady,
+    $resumeFailedSessionId: $paneResumeFailedSessionId,
+    $resumeExhaustedSessionId: $paneResumeExhaustedSessionId,
+    $currentModel: $paneCurrentModel,
+    $currentProvider: $paneCurrentProvider,
+    $currentReasoningEffort: $paneCurrentReasoningEffort,
+    $currentServiceTier: $paneCurrentServiceTier,
+    $currentFastMode: $paneCurrentFastMode,
+    $yoloActive: $paneYoloActive,
+    $currentCwd: $paneCurrentCwd,
+    $currentBranch: $paneCurrentBranch,
+    $currentUsage: $paneCurrentUsage,
+    $sessionStartedAt: $paneSessionStartedAt,
+    $turnStartedAt: $paneTurnStartedAt,
+    $currentPersonality: $paneCurrentPersonality,
+    $contextSuggestions: $paneContextSuggestions,
+    $composerAttachments: $paneComposerAttachments,
+
+    setActiveSessionId: next => update($paneActiveSessionId, next),
+    setSelectedStoredSessionId: next => update($paneSelectedStoredSessionId, next),
+    setMessages: next => update($paneMessages, next),
+    setBusy: next => update($paneBusy, next),
+    setAwaitingResponse: next => update($paneAwaitingResponse, next),
+    setFreshDraftReady: next => update($paneFreshDraftReady, next),
+    setResumeFailedSessionId: next => update($paneResumeFailedSessionId, next),
+    setResumeExhaustedSessionId: next => update($paneResumeExhaustedSessionId, next),
+    setCurrentModel: next => update($paneCurrentModel, next),
+    setCurrentProvider: next => update($paneCurrentProvider, next),
+    setCurrentReasoningEffort: next => update($paneCurrentReasoningEffort, next),
+    setCurrentServiceTier: next => update($paneCurrentServiceTier, next),
+    setCurrentFastMode: next => update($paneCurrentFastMode, next),
+    setYoloActive: next => update($paneYoloActive, next),
+    setCurrentCwd: next => update($paneCurrentCwd, next),
+    setCurrentBranch: next => update($paneCurrentBranch, next),
+    setCurrentUsage: next => update($paneCurrentUsage, next),
+    setSessionStartedAt: next => update($paneSessionStartedAt, next),
+    setTurnStartedAt: next => update($paneTurnStartedAt, next),
+    setCurrentPersonality: next => update($paneCurrentPersonality, next),
+    setContextSuggestions: next => update($paneContextSuggestions, next),
+
+    ...paneThreadScrollMembers(createThreadScrollAtoms()),
+
+    activeSessionIdRef: ref<string | null>(null),
+    selectedStoredSessionIdRef: ref<string | null>(null),
+    busyRef: ref(false),
+    creatingSessionRef: ref(false),
+    viewSessionIdRef: ref<string | null>(null),
+
+    getTargetSessionId: () => $splitPaneSession.get()?.storedId ?? null,
+    navigateToSession: storedId => setSplitPaneSession(storedId),
+    navigateToNewChat: () => setSplitPaneFreshDraft(),
+    isActive: () => $activePaneId.get() === 'split'
+  }
+}
+
+/** DEFAULT = the main bundle, so every consumer that never sees a provider
+ *  keeps today's behavior exactly. Only SplitChatPane mounts a provider. */
+export const PaneViewContext = createContext<PaneSessionView>(MAIN_PANE_VIEW)
+
+export const usePaneView = (): PaneSessionView => useContext(PaneViewContext)
diff --git a/apps/desktop/src/app/chat/scroll-to-bottom-button.tsx b/apps/desktop/src/app/chat/scroll-to-bottom-button.tsx
index dfe8b4e4d0b72..ab75249eb2506 100644
--- a/apps/desktop/src/app/chat/scroll-to-bottom-button.tsx
+++ b/apps/desktop/src/app/chat/scroll-to-bottom-button.tsx
@@ -6,7 +6,8 @@ import { useI18n } from '@/i18n'
 import { triggerHaptic } from '@/lib/haptics'
 import { cn } from '@/lib/utils'
 import { $approvalRequest } from '@/store/prompts'
-import { $threadJumpButtonVisible, requestScrollToBottom } from '@/store/thread-scroll'
+
+import { usePaneView } from './pane-view'
 
 /**
  * Floating "jump to bottom" control. Sits centered just above the composer,
@@ -30,6 +31,9 @@ import { $threadJumpButtonVisible, requestScrollToBottom } from '@/store/thread-
  */
 export function ScrollToBottomButton() {
   const { t } = useI18n()
+  // Pane-scoped: this button jumps ITS pane's viewport (single-pane = the
+  // module singleton instance, unchanged).
+  const { $threadJumpButtonVisible, requestScrollToBottom } = usePaneView()
   const visible = useStore($threadJumpButtonVisible)
   const request = useStore($approvalRequest)
   // Scrolled away while an approval is pending → the inline Run/Reject bar is
diff --git a/apps/desktop/src/app/chat/sidebar/session-actions-menu.tsx b/apps/desktop/src/app/chat/sidebar/session-actions-menu.tsx
index 08c13550a4356..1040066841755 100644
--- a/apps/desktop/src/app/chat/sidebar/session-actions-menu.tsx
+++ b/apps/desktop/src/app/chat/sidebar/session-actions-menu.tsx
@@ -22,7 +22,8 @@ import { exportSession } from '@/lib/session-export'
 import { activeGateway } from '@/store/gateway'
 import { notify, notifyError } from '@/store/notifications'
 import { $activeSessionId, $selectedStoredSessionId, setSessions } from '@/store/session'
-import { canOpenSessionWindow, openSessionInNewWindow } from '@/store/windows'
+import { openSessionInSplitPane } from '@/store/split'
+import { canOpenSessionWindow, isSecondaryWindow, openSessionInNewWindow } from '@/store/windows'
 
 import type { SessionTitleResponse } from '../../types'
 
@@ -131,6 +132,22 @@ function useSessionActions({
           }
         ]
       : []),
+    // Secondary windows (pop-outs, watch windows) never host the split pane.
+    // Opening an already-visible session just focuses the pane showing it
+    // (openSplitPane's same-session guard).
+    ...(!isSecondaryWindow()
+      ? [
+          {
+            disabled: !sessionId,
+            icon: 'split-horizontal',
+            label: r.openInSplit,
+            onSelect: () => {
+              triggerHaptic('selection')
+              openSessionInSplitPane(sessionId, profile)
+            }
+          }
+        ]
+      : []),
     {
       disabled: !sessionId,
       icon: 'cloud-download',
diff --git a/apps/desktop/src/app/chat/split-mirror.test.ts b/apps/desktop/src/app/chat/split-mirror.test.ts
new file mode 100644
index 0000000000000..10bf87a63e620
--- /dev/null
+++ b/apps/desktop/src/app/chat/split-mirror.test.ts
@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, it } from 'vitest'
+
+import {
+  $activeSessionId,
+  $busy,
+  $messages,
+  $selectedStoredSessionId,
+  setActiveSessionId,
+  setBusy,
+  setMessages,
+  setSelectedStoredSessionId
+} from '@/store/session'
+import { $activePaneId } from '@/store/split'
+
+import { createSplitPaneView, MAIN_PANE_VIEW } from './pane-view'
+import { mirrorPaneToGlobals } from './split-mirror'
+
+// The activation republish (design §3.6): while the split pane is focused the
+// IDENTITY singletons carry its session, and switching back restores the main
+// pane's — without ever touching the atoms the main pane renders from.
+
+// Main-pane identity as production writes it: atom + cache ref in lockstep
+// (use-session-actions pairs every id write; the refs are the UNMIRRORED
+// truth the teardown restores from).
+function setMainIdentity(runtimeId: null | string, storedId: null | string) {
+  setActiveSessionId(runtimeId)
+  MAIN_PANE_VIEW.activeSessionIdRef.current = runtimeId
+  setSelectedStoredSessionId(storedId)
+  MAIN_PANE_VIEW.selectedStoredSessionIdRef.current = storedId
+}
+
+function resetGlobals() {
+  setMainIdentity(null, null)
+  setMessages([])
+  setBusy(false)
+  $activePaneId.set('main')
+}
+
+describe('mirrorPaneToGlobals', () => {
+  afterEach(resetGlobals)
+
+  it('activation copy: the identity globals equal the split view the instant the mirror installs', () => {
+    setMainIdentity('rt-main', 'stored-main')
+
+    const view = createSplitPaneView()
+    view.setActiveSessionId('rt-split')
+    view.setSelectedStoredSessionId('stored-split')
+
+    const off = mirrorPaneToGlobals(view)
+
+    expect($activeSessionId.get()).toBe('rt-split')
+    expect($selectedStoredSessionId.get()).toBe('stored-split')
+
+    off()
+  })
+
+  it('tracks split view identity writes while installed (pane-local navigation)', () => {
+    const view = createSplitPaneView()
+    const off = mirrorPaneToGlobals(view)
+
+    view.setActiveSessionId('rt-a')
+    view.setSelectedStoredSessionId('stored-a')
+
+    expect($activeSessionId.get()).toBe('rt-a')
+    expect($selectedStoredSessionId.get()).toBe('stored-a')
+
+    view.setSelectedStoredSessionId('stored-b')
+
+    expect($selectedStoredSessionId.get()).toBe('stored-b')
+
+    off()
+  })
+
+  it('teardown restores the main pane identity from its cache refs', () => {
+    setMainIdentity('rt-main', 'stored-main')
+
+    const view = createSplitPaneView()
+    view.setActiveSessionId('rt-split')
+    view.setSelectedStoredSessionId('stored-split')
+
+    const off = mirrorPaneToGlobals(view)
+
+    expect($activeSessionId.get()).toBe('rt-split')
+
+    off()
+
+    expect($activeSessionId.get()).toBe('rt-main')
+    expect($selectedStoredSessionId.get()).toBe('stored-main')
+  })
+
+  it('honors a BACKGROUND main-pane resume that rebound the ids mid-mirror', () => {
+    // The reconnect route-resume / bounded auto-retry keep running for the
+    // main session while the split is focused. They rewrite atom+ref in
+    // lockstep; an install-time snapshot would restore the DEAD pre-reconnect
+    // runtime id on switch-back — the refs are the live truth.
+    setMainIdentity('rt-main-old', 'stored-main')
+
+    const view = createSplitPaneView()
+    view.setActiveSessionId('rt-split')
+    view.setSelectedStoredSessionId('stored-split')
+
+    const off = mirrorPaneToGlobals(view)
+
+    // Background resume rebinds the main runtime id while the mirror is up.
+    setMainIdentity('rt-main-rebound', 'stored-main')
+
+    // A later split-view write re-asserts the mirrored identity…
+    view.setActiveSessionId('rt-split-2')
+    expect($activeSessionId.get()).toBe('rt-split-2')
+
+    off()
+
+    // …and switch-back lands on the REBOUND main id, not the stale snapshot.
+    expect($activeSessionId.get()).toBe('rt-main-rebound')
+    expect($selectedStoredSessionId.get()).toBe('stored-main')
+  })
+
+  it('stops tracking after teardown — later split writes stay pane-local', () => {
+    const view = createSplitPaneView()
+    const off = mirrorPaneToGlobals(view)
+    off()
+
+    view.setActiveSessionId('rt-late')
+
+    expect($activeSessionId.get()).toBeNull()
+  })
+
+  it('never touches the atoms the main pane renders from ($messages / $busy)', () => {
+    setMessages([{ id: 'm-main', parts: [{ text: 'main transcript', type: 'text' }], role: 'user' }])
+    setBusy(false)
+
+    const view = createSplitPaneView()
+    view.setMessages([{ id: 'm-split', parts: [{ text: 'split transcript', type: 'text' }], role: 'user' }])
+    view.setBusy(true)
+
+    const off = mirrorPaneToGlobals(view)
+
+    // The split streams while focused — its transcript/busy stay in ITS
+    // bundle; the main pane keeps rendering its own.
+    view.setMessages([
+      { id: 'm-split', parts: [{ text: 'split transcript', type: 'text' }], role: 'user' },
+      { id: 'a-split', parts: [{ text: 'reply', type: 'text' }], role: 'assistant' }
+    ])
+
+    expect($messages.get().map(message => message.id)).toEqual(['m-main'])
+    expect($busy.get()).toBe(false)
+
+    off()
+  })
+})
diff --git a/apps/desktop/src/app/chat/split-mirror.ts b/apps/desktop/src/app/chat/split-mirror.ts
new file mode 100644
index 0000000000000..2cfc21b343588
--- /dev/null
+++ b/apps/desktop/src/app/chat/split-mirror.ts
@@ -0,0 +1,64 @@
+import { $activeSessionId, $selectedStoredSessionId } from '@/store/session'
+
+import { MAIN_PANE_VIEW, type PaneSessionView } from './pane-view'
+
+// ── Active-pane → global-singleton mirror ───────────────────────────────────
+//
+// Global surfaces scope themselves on the ACTIVE session's identity: blocking
+// prompts (store/prompts.ts `$active` computeds, store/clarify.ts), native
+// notification session-matching, preview attribution, the sidebar highlight,
+// oneshot/compaction/background-delegation. Single-pane, the identity atoms
+// and the main chat view are the same thing; with the split pane FOCUSED they
+// must diverge — the globals follow the split's session while the main pane
+// keeps rendering its own.
+//
+// The mirror therefore copies exactly the two IDENTITY atoms — nothing else:
+//
+// - `$activeSessionId` / `$selectedStoredSessionId` have no INTERACTIVE
+//   concurrent writer while the split is focused: every user-driven main-pane
+//   writer (resume, fresh draft, delete/archive re-route) is either
+//   interaction-gated behind main-pane activation (pointerdown capture tears
+//   this mirror down first) or wrapped by the controller to hand focus back to
+//   the main pane before it runs. Background main-pane writers DO exist —
+//   the reconnect route-resume and its bounded auto-retry rewrite the ids for
+//   the main session while the split stays focused — which is why teardown
+//   restores from the main pane's cache refs (always the live unmirrored
+//   truth; every main-pane id write pairs the atom with its ref) instead of
+//   an install-time snapshot that a background resume would invalidate.
+// - The remaining view atoms ($messages, $busy, model family, cwd, clocks…)
+//   keep live main-session writers (the state cache's main projection and
+//   gateway-event.ts heartbeats), so mirroring them would interleave two
+//   sessions' values into one atom. They stay main-pane truth; the split pane
+//   reads its own bundle. Documented v1 line: identity follows focus, the
+//   heavyweight workspace/status surfaces stay anchored to the main pane.
+//
+// Writes use raw `atom.set` — same effect as the store setters for these two
+// atoms (no persistence side effects), and deliberately not routed through the
+// MAIN pane setter block so a future persisting setter can't be reached from a
+// background flush (design §3.6 / risk 6).
+
+/**
+ * Install the split-pane → globals identity mirror. Fires immediately (the
+ * activation copy) and tracks every subsequent pane write. Teardown restores
+ * the main pane's CURRENT identity from its cache refs (bound into
+ * MAIN_PANE_VIEW by the controller), so a background main-pane resume that
+ * rebound the runtime id mid-mirror is honored on switch-back.
+ * Returns the teardown.
+ */
+export function mirrorPaneToGlobals(view: PaneSessionView): () => void {
+  const unsubscribers = [
+    view.$activeSessionId.subscribe(value => $activeSessionId.set(value)),
+    view.$selectedStoredSessionId.subscribe(value => $selectedStoredSessionId.set(value))
+  ]
+
+  return () => {
+    for (const unsubscribe of unsubscribers) {
+      unsubscribe()
+    }
+
+    // Late ref lookup: bindMainPaneView may have swapped the ref objects in
+    // after this mirror was created.
+    $activeSessionId.set(MAIN_PANE_VIEW.activeSessionIdRef.current)
+    $selectedStoredSessionId.set(MAIN_PANE_VIEW.selectedStoredSessionIdRef.current)
+  }
+}
diff --git a/apps/desktop/src/app/chat/split-pane.tsx b/apps/desktop/src/app/chat/split-pane.tsx
new file mode 100644
index 0000000000000..9f6d4b851ae06
--- /dev/null
+++ b/apps/desktop/src/app/chat/split-pane.tsx
@@ -0,0 +1,535 @@
+import { useStore } from '@nanostores/react'
+import { useQueryClient } from '@tanstack/react-query'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { NavigateFunction } from 'react-router-dom'
+
+import { formatRefValue } from '@/components/assistant-ui/directive-text'
+import { getSession, type HermesGateway, type SessionInfo } from '@/hermes'
+import { type ChatMessage, chatMessageText } from '@/lib/chat-messages'
+import { cn } from '@/lib/utils'
+import { $activeGatewayProfile, ensureGatewayProfile, normalizeProfileKey } from '@/store/profile'
+import { $gatewayState } from '@/store/session'
+import {
+  $activePaneId,
+  $splitFreshDraft,
+  $splitPaneRuntimeSessionId,
+  $splitPaneSession,
+  type PaneId,
+  registerSplitPaneModelDelegate,
+  restoreSplitPaneSession,
+  setActivePane,
+  setSplitPaneSession
+} from '@/store/split'
+import { useSkinCommand } from '@/themes/use-skin-command'
+
+import { useModelControls } from '../session/hooks/use-model-controls'
+import { usePromptActions } from '../session/hooks/use-prompt-actions'
+import { useSessionActions } from '../session/hooks/use-session-actions'
+import {
+  isSessionGoneError,
+  resolveStoredSession,
+  upsertResolvedSession
+} from '../session/hooks/use-session-actions/utils'
+import type { RegisteredSessionView, useSessionStateCache } from '../session/hooks/use-session-state-cache'
+import { ModelMenuPanel } from '../shell/model-menu-panel'
+import type { ClientSessionState } from '../types'
+
+import { requestComposerFocus } from './composer/focus'
+import { useComposerActions } from './hooks/use-composer-actions'
+import { createPaneRequest, mainPaneSessionProfile, type PaneGatewayRequest } from './pane-request'
+import { createSplitPaneView, PaneViewContext } from './pane-view'
+import { mirrorPaneToGlobals } from './split-mirror'
+
+import { ChatView } from './index'
+
+type SessionStateCache = ReturnType<typeof useSessionStateCache>
+
+// A NavigateFunction the split's session-actions instance can never reach a
+// router through: its navigation is pane-local ($splitPaneSession), and the
+// router-only actions (selectSidebarItem/openSettings) are main-pane calls.
+const noopNavigate: NavigateFunction = () => undefined
+
+// The §3.1 boot-probe row lookup. The persisted profile tag routes the probe
+// with an EXPLICIT profile (the reason the tag exists), so it neither depends
+// on $sessions/$profiles having finished their first load — 'open' fires at
+// WS connect, BEFORE refreshSessions/refreshProfiles complete — nor violates
+// the pane-context explicit-profile REST rule. Outcomes:
+//   row           — authoritative hit (upserted so the follow-up resume finds
+//                    it cached with its owning profile);
+//   row: undefined — authoritative miss (tagged backend 404'd, and the
+//                    cross-profile scan found nothing) → close the split;
+//   indeterminate — the tagged backend couldn't answer (still spawning,
+//                    transport error) → KEEP the split; the resume driver
+//                    surfaces the explicit Retry state if it stays down.
+async function probeSplitSessionRow(
+  storedId: string,
+  taggedProfile: null | string
+): Promise<{ indeterminate: boolean; row?: SessionInfo }> {
+  if (taggedProfile) {
+    try {
+      const row = await getSession(storedId, taggedProfile)
+
+      upsertResolvedSession(row, storedId)
+
+      return { indeterminate: false, row }
+    } catch (err) {
+      if (!isSessionGoneError(err)) {
+        return { indeterminate: true }
+      }
+
+      // Authoritative 404 on the tagged profile: fall through to the scan as
+      // a last chance (stale tag — e.g. the session moved profiles).
+    }
+  }
+
+  return { indeterminate: false, row: await resolveStoredSession(storedId) }
+}
+
+interface SplitChatPaneProps {
+  ensureSessionState: SessionStateCache['ensureSessionState']
+  gateway: HermesGateway | null
+  maxVoiceRecordingSeconds?: number
+  /** Route a session delete through the controller's pane-aware wrapper. */
+  onRemoveSession: (storedSessionId: string) => void
+  onToggleSelectedPin: () => void
+  openMemoryGraph: () => void
+  publishPaneState: SessionStateCache['publishPaneState']
+  refreshSessions: () => Promise<void>
+  registerPaneView: (view: RegisteredSessionView) => () => void
+  /** The shared active-gateway request — wrapped per-pane below. */
+  requestGateway: PaneGatewayRequest
+  runtimeIdByStoredSessionIdRef: SessionStateCache['runtimeIdByStoredSessionIdRef']
+  sessionStateByRuntimeIdRef: SessionStateCache['sessionStateByRuntimeIdRef']
+  sttEnabled: boolean
+  syncSessionStateToView: SessionStateCache['syncSessionStateToView']
+  updateSessionState: SessionStateCache['updateSessionState']
+}
+
+/**
+ * The second chat pane (design §3.7): owns a factory-created view bundle, its
+ * own session/prompt/composer action instances bound to that bundle, the
+ * pane-local resume driver (the split's analog of use-route-resume), and the
+ * activation choreography — identity mirror install/teardown, gateway profile
+ * swap, composer focus. Mounted by DesktopController only while $splitOpen.
+ */
+export function SplitChatPane({
+  ensureSessionState,
+  gateway,
+  maxVoiceRecordingSeconds,
+  onRemoveSession,
+  onToggleSelectedPin,
+  openMemoryGraph,
+  publishPaneState,
+  refreshSessions,
+  registerPaneView,
+  requestGateway,
+  runtimeIdByStoredSessionIdRef,
+  sessionStateByRuntimeIdRef,
+  sttEnabled,
+  syncSessionStateToView,
+  updateSessionState
+}: SplitChatPaneProps) {
+  const queryClient = useQueryClient()
+  const [view] = useState(() => createSplitPaneView())
+  const activePaneId = useStore($activePaneId)
+  const paneActive = activePaneId === 'split'
+  const splitSession = useStore($splitPaneSession)
+  const splitFreshDraft = useStore($splitFreshDraft)
+  const gatewayState = useStore($gatewayState)
+  const splitActiveSessionId = useStore(view.$activeSessionId)
+  const splitSelectedStoredSessionId = useStore(view.$selectedStoredSessionId)
+  const splitCurrentCwd = useStore(view.$currentCwd)
+  const splitTarget = splitSession?.storedId ?? null
+
+  // Fan-out registration: the state cache projects this pane's viewed session
+  // into the bundle. Unregistering on close freezes the view while the truth
+  // layer keeps caching (background streaming keeps working).
+  useEffect(() => registerPaneView(view), [registerPaneView, view])
+
+  // Expose the split's runtime session id for non-React modules (native
+  // notifications treat a split-visible session as foreground).
+  useEffect(() => {
+    const off = view.$activeSessionId.subscribe(id => $splitPaneRuntimeSessionId.set(id))
+
+    return () => {
+      off()
+      $splitPaneRuntimeSessionId.set(null)
+    }
+  }, [view])
+
+  const requestGatewayRef = useRef(requestGateway)
+  requestGatewayRef.current = requestGateway
+
+  // Profile-pinned request wrapper (design §4): active → settle the gateway
+  // swap then the shared path; inactive (boot restore) → the split profile's
+  // own socket, never the active pointer. Stable identity (latest-ref inner)
+  // so the action hooks don't re-instantiate per render.
+  const [paneRequest] = useState<PaneGatewayRequest>(() =>
+    createPaneRequest({
+      getProfile: () => $splitPaneSession.get()?.profile ?? null,
+      isActive: () => view.isActive(),
+      requestGateway: (method, params, timeoutMs, signal) =>
+        requestGatewayRef.current(method, params, timeoutMs, signal)
+    })
+  )
+
+  // Pane-local "route token": createBackendSessionForSend aborts if the pane's
+  // target moved while session.create was in flight — same guard the main pane
+  // gets from the URL token.
+  const getSplitRouteToken = useCallback(
+    () => `split:${$splitPaneSession.get()?.storedId ?? ($splitFreshDraft.get() ? 'draft' : 'closed')}`,
+    []
+  )
+
+  const {
+    branchCurrentSession,
+    createBackendSessionForSend,
+    resumeSession,
+    startFreshSessionDraft
+  } = useSessionActions({
+    activeSessionId: splitActiveSessionId,
+    activeSessionIdRef: view.activeSessionIdRef,
+    busyRef: view.busyRef,
+    creatingSessionRef: view.creatingSessionRef,
+    ensureSessionState,
+    getRouteToken: getSplitRouteToken,
+    navigate: noopNavigate,
+    requestGateway: paneRequest,
+    runtimeIdByStoredSessionIdRef,
+    selectedStoredSessionId: splitSelectedStoredSessionId,
+    selectedStoredSessionIdRef: view.selectedStoredSessionIdRef,
+    sessionStateByRuntimeIdRef,
+    syncSessionStateToView,
+    updateSessionState,
+    view
+  })
+
+  const branchInNewChat = useCallback(
+    async (messageId?: string) => {
+      const branched = await branchCurrentSession(messageId)
+
+      if (branched) {
+        await refreshSessions().catch(() => undefined)
+      }
+
+      return branched
+    },
+    [branchCurrentSession, refreshSessions]
+  )
+
+  const handleSkinCommand = useSkinCommand()
+
+  const {
+    cancelRun,
+    editMessage,
+    handleThreadMessagesChange,
+    reloadFromMessage,
+    restoreToMessage,
+    steerPrompt,
+    submitText,
+    transcribeVoiceAudio
+  } = usePromptActions({
+    activeSessionId: splitActiveSessionId,
+    activeSessionIdRef: view.activeSessionIdRef,
+    branchCurrentSession: branchInNewChat,
+    busyRef: view.busyRef,
+    createBackendSessionForSend,
+    handleSkinCommand,
+    openMemoryGraph,
+    refreshSessions,
+    requestGateway: paneRequest,
+    resumeStoredSession: resumeSession,
+    selectedStoredSessionIdRef: view.selectedStoredSessionIdRef,
+    startFreshSessionDraft,
+    sttEnabled,
+    updateSessionState,
+    view
+  })
+
+  // This pane's file pickers / clipboard / drops, writing its own attachments
+  // atom and targeting its own session.
+  const composer = useComposerActions({
+    activeSessionId: splitActiveSessionId,
+    attachmentsAtom: view.$composerAttachments,
+    currentCwd: splitCurrentCwd,
+    requestGateway: paneRequest
+  })
+
+  // This pane's model controls: a pick writes THIS bundle's chip (plain,
+  // non-persisting setters — the sticky composer-model localStorage keys stay
+  // main-pane-only), targets THIS pane's runtime session, and rides the
+  // profile-pinned request. The controller's shared instance would have
+  // written the MAIN chip + sticky keys for a split pick.
+  const { selectModel } = useModelControls({
+    activeSessionId: splitActiveSessionId,
+    queryClient,
+    requestGateway: paneRequest,
+    view
+  })
+
+  // Route global ModelPickerOverlay picks here while this pane is focused
+  // (the overlay mounts outside any PaneViewContext). Latest-ref so the
+  // registration survives selectModel identity churn.
+  const selectModelRef = useRef(selectModel)
+  selectModelRef.current = selectModel
+
+  useEffect(() => {
+    registerSplitPaneModelDelegate(selection => selectModelRef.current(selection))
+
+    return () => registerSplitPaneModelDelegate(null)
+  }, [])
+
+  const paneModelMenuContent = useMemo(
+    () =>
+      gatewayState === 'open' ? (
+        <ModelMenuPanel gateway={gateway || undefined} onSelectModel={selectModel} requestGateway={paneRequest} />
+      ) : null,
+    [gateway, gatewayState, paneRequest, selectModel]
+  )
+
+  // ── Activation choreography (design §3.6) ─────────────────────────────────
+  // Runs synchronously on $activePaneId writes (store subscription, not a
+  // React effect) so call-time readers of the identity globals are correct the
+  // instant pointerdown-capture flips the pane — before any click handler.
+  const mirrorOffRef = useRef<(() => void) | null>(null)
+  const publishPaneStateRef = useRef(publishPaneState)
+  publishPaneStateRef.current = publishPaneState
+  // Gateway profile the main pane's context sat on when focus left it. A
+  // fresh main draft has no selected session ⇒ no row tag ⇒
+  // mainPaneSessionProfile() null ⇒ ensureGatewayProfile(null) would KEEP the
+  // split's profile on switch-back — and the next send would silently create
+  // the draft's session on the split's profile. Captured before the split's
+  // swap so switch-back restores the draft's real context.
+  const mainProfileBeforeSplitFocusRef = useRef<null | string>(null)
+
+  useEffect(() => {
+    const apply = (paneId: PaneId) => {
+      if (paneId === 'split') {
+        if (!mirrorOffRef.current) {
+          mainProfileBeforeSplitFocusRef.current = normalizeProfileKey($activeGatewayProfile.get())
+          // Warm repaint from the cache, then point the identity globals at
+          // this pane (the mirror's immediate fire is the activation copy).
+          publishPaneStateRef.current('split')
+          mirrorOffRef.current = mirrorPaneToGlobals(view)
+        }
+
+        // Swap the active gateway to this pane's profile — identical to what
+        // selecting one of its sessions does today. Serialized + no-op when
+        // already on-profile; the paneRequest wrapper closes the Enter race.
+        void ensureGatewayProfile($splitPaneSession.get()?.profile ?? null)
+      } else if (mirrorOffRef.current) {
+        mirrorOffRef.current()
+        mirrorOffRef.current = null
+        publishPaneStateRef.current('main')
+        void ensureGatewayProfile(mainPaneSessionProfile() ?? mainProfileBeforeSplitFocusRef.current)
+      }
+
+      // Typing lands in the focused pane (both composers subscribe as 'main';
+      // the draft engine's active-pane gate routes it).
+      requestComposerFocus('main')
+    }
+
+    // openSplitPane focuses the split before this mounts — apply immediately.
+    if ($activePaneId.get() === 'split') {
+      apply('split')
+    }
+
+    const off = $activePaneId.listen(apply)
+
+    return () => {
+      off()
+
+      // Unmounted while focused (split closed via keybind mid-focus, or the
+      // chat route swapped away): restore the main pane's identity globals.
+      if (mirrorOffRef.current) {
+        mirrorOffRef.current()
+        mirrorOffRef.current = null
+        publishPaneStateRef.current('main')
+      }
+    }
+  }, [view])
+
+  // ── Pane-local resume driver — the split's use-route-resume ───────────────
+  // Waits for the gateway to open; the first target after mount is a boot
+  // restore and gets the §3.1 probe (404/archived → split closes instead of
+  // mounting a pane that can never resume). Resumes run through the pane's
+  // view: while the split is INACTIVE this opens the profile's own socket and
+  // never steals the active gateway from the pane the user is typing in.
+  // Accepted v1 cosmetic: a stale persisted session shows this pane's loader
+  // from first paint until the probe lands (gateway open + one row fetch),
+  // then collapses cleanly — the pane is not held hidden during the probe
+  // because with the gateway down that would suppress a perfectly valid
+  // restore indefinitely.
+  const bootProbeRef = useRef(false)
+  const resumeSessionRef = useRef(resumeSession)
+  resumeSessionRef.current = resumeSession
+  const startFreshSessionDraftRef = useRef(startFreshSessionDraft)
+  startFreshSessionDraftRef.current = startFreshSessionDraft
+
+  useEffect(() => {
+    if (gatewayState !== 'open') {
+      return
+    }
+
+    if (!splitTarget) {
+      // Fresh-draft split: seed the pane view once (openSplitPane with no
+      // session, or the dispatcher's startFreshDraft).
+      if (splitFreshDraft && !view.$freshDraftReady.get()) {
+        startFreshSessionDraftRef.current()
+      }
+
+      return
+    }
+
+    if (view.selectedStoredSessionIdRef.current === splitTarget && view.activeSessionIdRef.current) {
+      return
+    }
+
+    let cancelled = false
+
+    void (async () => {
+      if (!bootProbeRef.current) {
+        bootProbeRef.current = true
+        let resolvedProfile: null | string | undefined
+
+        const restored = await restoreSplitPaneSession(async storedId => {
+          const probe = await probeSplitSessionRow(storedId, $splitPaneSession.get()?.profile ?? null)
+
+          // Indeterminate (tagged backend still spawning / transport error):
+          // keep the split rather than discarding a session that may be fine —
+          // returning the current session is a truthy "still valid" for
+          // restoreSplitPaneSession. The resume below then either succeeds or
+          // arms the pane's explicit Retry state.
+          if (probe.indeterminate) {
+            return $splitPaneSession.get()
+          }
+
+          if (!probe.row || probe.row.archived) {
+            return null
+          }
+
+          resolvedProfile = probe.row.profile ?? null
+
+          return probe.row
+        })
+
+        if (cancelled || !restored || restored.storedId !== splitTarget) {
+          return
+        }
+
+        // Refresh a missing profile tag from the resolved row so the pinned
+        // request wrapper and the gateway keep-set route correctly.
+        if (restored.profile === null && resolvedProfile) {
+          setSplitPaneSession(splitTarget, resolvedProfile)
+        }
+      }
+
+      if (cancelled) {
+        return
+      }
+
+      await resumeSessionRef.current(splitTarget)
+
+      // No bounded auto-retry driver for the split (that's use-route-resume,
+      // main-pane-only): a terminal failure surfaces the explicit error +
+      // manual Retry instead of an endless loader. onRetryResume clears the
+      // latch through resumeSession for a fresh attempt.
+      if (!cancelled && view.$resumeFailedSessionId.get() === splitTarget) {
+        view.setResumeExhaustedSessionId(splitTarget)
+      }
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [gatewayState, splitFreshDraft, splitTarget, view])
+
+  const dismissError = useCallback(
+    (messageId: string) => {
+      const runtimeSessionId = view.activeSessionIdRef.current
+
+      if (!runtimeSessionId) {
+        return
+      }
+
+      const clearErrorIn = (messages: ChatMessage[]): ChatMessage[] =>
+        messages.flatMap(message => {
+          if (message.id !== messageId || !message.error) {
+            return [message]
+          }
+
+          if (!chatMessageText(message).trim() && !message.parts.some(part => part.type !== 'text')) {
+            return []
+          }
+
+          return [{ ...message, error: undefined, pending: false }]
+        })
+
+      // View first, then the cache — same ordering rationale as the main
+      // pane's dismissError (the flush merges errors from the current view).
+      view.setMessages(clearErrorIn(view.$messages.get()))
+
+      updateSessionState(runtimeSessionId, (state: ClientSessionState) => ({
+        ...state,
+        messages: clearErrorIn(state.messages)
+      }))
+    },
+    [updateSessionState, view]
+  )
+
+  const activate = useCallback(() => setActivePane('split'), [])
+
+  return (
+    <PaneViewContext.Provider value={view}>
+      {/* Same box contract as the main chat column (ChatView owns its header
+          placement); the inset hairline flips with focus — accent while
+          active, quiet stroke while not. */}
+      <div
+        className={cn(
+          'relative flex h-full min-h-0 min-w-0 flex-col overflow-hidden',
+          paneActive
+            ? 'shadow-[inset_0_0_0_1px_color-mix(in_srgb,var(--dt-composer-ring,var(--ui-stroke-secondary))_45%,transparent)]'
+            : 'shadow-[inset_0_0_0_1px_var(--ui-stroke-secondary)]'
+        )}
+        data-pane-active={paneActive ? 'true' : 'false'}
+        data-pane-id="chat-split-view"
+        onFocusCapture={activate}
+        onPointerDownCapture={activate}
+      >
+        <ChatView
+          gateway={gateway}
+          maxVoiceRecordingSeconds={maxVoiceRecordingSeconds}
+          modelMenuContent={paneModelMenuContent}
+          onAddContextRef={composer.addContextRefAttachment}
+          onAddUrl={url => composer.addContextRefAttachment(`@url:${formatRefValue(url)}`, url)}
+          onAttachDroppedItems={composer.attachDroppedItems}
+          onAttachImageBlob={composer.attachImageBlob}
+          onBranchInNewChat={messageId => void branchInNewChat(messageId)}
+          onCancel={cancelRun}
+          onDeleteSelectedSession={() => {
+            const selected = view.$selectedStoredSessionId.get()
+
+            if (selected) {
+              onRemoveSession(selected)
+            }
+          }}
+          onDismissError={dismissError}
+          onEdit={editMessage}
+          onPasteClipboardImage={opts => composer.pasteClipboardImage(opts)}
+          onPickFiles={() => void composer.pickContextPaths('file')}
+          onPickFolders={() => void composer.pickContextPaths('folder')}
+          onPickImages={() => void composer.pickImages()}
+          onReload={reloadFromMessage}
+          onRemoveAttachment={id => void composer.removeAttachment(id)}
+          onRestoreToMessage={restoreToMessage}
+          onRetryResume={sessionId => void resumeSession(sessionId, true)}
+          onSteer={steerPrompt}
+          onSubmit={submitText}
+          onThreadMessagesChange={handleThreadMessagesChange}
+          onToggleSelectedPin={onToggleSelectedPin}
+          onTranscribeAudio={transcribeVoiceAudio}
+        />
+      </div>
+    </PaneViewContext.Provider>
+  )
+}
diff --git a/apps/desktop/src/app/command-palette/index.tsx b/apps/desktop/src/app/command-palette/index.tsx
index 2d6496e514328..4d4f52044c0d5 100644
--- a/apps/desktop/src/app/command-palette/index.tsx
+++ b/apps/desktop/src/app/command-palette/index.tsx
@@ -18,6 +18,7 @@ import {
   ChevronLeft,
   ChevronRight,
   Clock,
+  Columns2,
   Cpu,
   Download,
   Egg,
@@ -59,8 +60,10 @@ import { $bindings } from '@/store/keybinds'
 import { openPetGenerate } from '@/store/pet-generate'
 import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import { requestStartWorkSession } from '@/store/projects'
+import { $splitOpen, closeSplitPane, dispatchOpenSession, openSplitPane } from '@/store/split'
 import { runGatewayRestart } from '@/store/system-actions'
 import { applyBackendUpdate } from '@/store/updates'
+import { isSecondaryWindow } from '@/store/windows'
 import { luminance } from '@/themes/color'
 import { type ThemeMode, useTheme } from '@/themes/context'
 import { isUserTheme, resolveTheme } from '@/themes/user-themes'
@@ -296,6 +299,7 @@ export function CommandPalette() {
   const open = useStore($commandPaletteOpen)
   const pendingPage = useStore($commandPalettePage)
   const bindings = useStore($bindings)
+  const splitOpen = useStore($splitOpen)
   const worktrees = useStore($repoWorktrees)
   const navigate = useNavigate()
   const { availableThemes, resolvedMode, setMode, setTheme, themeName } = useTheme()
@@ -355,6 +359,18 @@ export function CommandPalette() {
 
   const go = useCallback((path: string) => () => navigate(path), [navigate])
 
+  // Session opens route through the active-pane dispatcher (they land in the
+  // focused chat pane; a duplicate focuses the pane already showing it). The
+  // navigate() fallback only runs before DesktopController registers it.
+  const openSession = useCallback(
+    (sessionId: string) => () => {
+      if (!dispatchOpenSession(sessionId)) {
+        navigate(sessionRoute(sessionId))
+      }
+    },
+    [navigate]
+  )
+
   // Step up one nested page (or back to the root list), clearing the filter so
   // the parent page doesn't reopen mid-search.
   const goBack = useCallback(() => {
@@ -476,7 +492,31 @@ export function CommandPalette() {
             keywords: ['star map', 'memory', 'memories', 'skills', 'graph', 'learning', 'constellation'],
             label: t.starmap.title,
             run: go(STARMAP_ROUTE)
-          }
+          },
+          // Secondary windows (pop-outs, watch windows) never host the split.
+          ...(!isSecondaryWindow()
+            ? [
+                splitOpen
+                  ? {
+                      action: 'view.toggleSplit',
+                      icon: Columns2,
+                      id: 'view-close-split',
+                      keywords: ['split', 'pane', 'panel', 'close', 'side by side'],
+                      label: cc.closeSplit,
+                      run: () => closeSplitPane()
+                    }
+                  : {
+                      action: 'view.toggleSplit',
+                      icon: Columns2,
+                      id: 'view-split-right',
+                      keywords: ['split', 'pane', 'panel', 'right', 'side by side'],
+                      label: cc.splitRight,
+                      run: () => {
+                        openSplitPane()
+                      }
+                    }
+              ]
+            : [])
         ]
       },
       ...branchGroup,
@@ -576,7 +616,7 @@ export function CommandPalette() {
         ]
       }
     ]
-  }, [go, settingsSectionLabel, t, worktrees])
+  }, [go, settingsSectionLabel, splitOpen, t, worktrees])
 
   // The long, granular lists (settings fields, API keys, MCP servers, archived
   // chats) only surface once the user types — otherwise they'd bury the
@@ -600,7 +640,7 @@ export function CommandPalette() {
             id: `goto-${directId}`,
             keywords: ['session', 'id', 'go to', directId],
             label: `${t.commandCenter.goToSession} ${directId}`,
-            run: go(sessionRoute(directId))
+            run: openSession(directId)
           }
         ]
       })
@@ -681,7 +721,7 @@ export function CommandPalette() {
           id: `session-${session.id}`,
           keywords: ['chat', 'session', ...(session.preview ? [session.preview] : [])],
           label: session.title,
-          run: go(sessionRoute(session.id))
+          run: openSession(session.id)
         }))
       })
     }
@@ -731,6 +771,7 @@ export function CommandPalette() {
     configFieldLabel,
     go,
     mcpServers,
+    openSession,
     resolvedMode,
     search,
     sessions,
diff --git a/apps/desktop/src/app/desktop-controller-split.test.ts b/apps/desktop/src/app/desktop-controller-split.test.ts
new file mode 100644
index 0000000000000..cad4a351859a6
--- /dev/null
+++ b/apps/desktop/src/app/desktop-controller-split.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveOpenSessionDispatch } from './desktop-controller-utils'
+
+// The open-in-active-pane dispatcher's decision table (design §3.5). The
+// invariant under test: the same session may never be open in both panes —
+// opening a duplicate focuses the pane that already shows it.
+
+const base = {
+  activePaneId: 'main' as const,
+  mainSelectedStoredSessionId: 'stored-main',
+  splitOpen: true,
+  splitStoredSessionId: 'stored-split',
+  storedSessionId: 'stored-other'
+}
+
+describe('resolveOpenSessionDispatch', () => {
+  it('split closed: always the plain navigate path (single-pane behavior)', () => {
+    expect(
+      resolveOpenSessionDispatch({ ...base, splitOpen: false, storedSessionId: 'stored-split' })
+    ).toEqual({ kind: 'navigate' })
+
+    expect(
+      resolveOpenSessionDispatch({
+        ...base,
+        activePaneId: 'split',
+        splitOpen: false,
+        splitStoredSessionId: null
+      })
+    ).toEqual({ kind: 'navigate' })
+  })
+
+  it('main active: a fresh session opens via the router', () => {
+    expect(resolveOpenSessionDispatch(base)).toEqual({ kind: 'navigate' })
+  })
+
+  it('split active: a fresh session opens pane-locally in the split (URL untouched)', () => {
+    expect(resolveOpenSessionDispatch({ ...base, activePaneId: 'split' })).toEqual({ kind: 'open-in-split' })
+  })
+
+  it("duplicate of the split's session focuses the split — from either active pane", () => {
+    expect(resolveOpenSessionDispatch({ ...base, storedSessionId: 'stored-split' })).toEqual({ kind: 'focus-split' })
+
+    expect(
+      resolveOpenSessionDispatch({ ...base, activePaneId: 'split', storedSessionId: 'stored-split' })
+    ).toEqual({ kind: 'focus-split' })
+  })
+
+  it("split active: duplicate of the MAIN pane's session focuses the main pane instead of double-opening", () => {
+    expect(
+      resolveOpenSessionDispatch({ ...base, activePaneId: 'split', storedSessionId: 'stored-main' })
+    ).toEqual({ kind: 'focus-main' })
+  })
+
+  it("main active: re-opening the main pane's own session keeps today's re-navigate", () => {
+    expect(resolveOpenSessionDispatch({ ...base, storedSessionId: 'stored-main' })).toEqual({ kind: 'navigate' })
+  })
+})
diff --git a/apps/desktop/src/app/desktop-controller-utils.ts b/apps/desktop/src/app/desktop-controller-utils.ts
index 53b15f701b0ca..502bf58749762 100644
--- a/apps/desktop/src/app/desktop-controller-utils.ts
+++ b/apps/desktop/src/app/desktop-controller-utils.ts
@@ -39,3 +39,50 @@ export function sameCronSignature(a: SessionInfo[], b: SessionInfo[]): boolean {
     )
   })
 }
+
+// ── Open-in-active-pane dispatcher (split pane) ─────────────────────────────
+
+export type OpenSessionDispatchAction =
+  /** Focus the split pane — it already shows the session. */
+  | { kind: 'focus-split' }
+  /** Focus the main pane — it already shows the session. */
+  | { kind: 'focus-main' }
+  /** Point the split pane at the session (pane-local open; URL untouched). */
+  | { kind: 'open-in-split' }
+  /** Route through the URL — exactly the pre-split navigate() path. */
+  | { kind: 'navigate' }
+
+/**
+ * Where a session-open lands with the split pane in play. Pure so the
+ * duplicate-session invariant ("the same session may never be open in both
+ * panes — opening a duplicate focuses the pane that already shows it") is unit
+ * testable. With the split closed the answer is always `navigate`, which is
+ * byte-for-byte today's behavior.
+ */
+export function resolveOpenSessionDispatch(args: {
+  activePaneId: 'main' | 'split'
+  mainSelectedStoredSessionId: null | string
+  splitOpen: boolean
+  splitStoredSessionId: null | string
+  storedSessionId: string
+}): OpenSessionDispatchAction {
+  const { activePaneId, mainSelectedStoredSessionId, splitOpen, splitStoredSessionId, storedSessionId } = args
+
+  if (!splitOpen) {
+    return { kind: 'navigate' }
+  }
+
+  if (splitStoredSessionId === storedSessionId) {
+    return { kind: 'focus-split' }
+  }
+
+  if (activePaneId === 'split') {
+    if (mainSelectedStoredSessionId === storedSessionId) {
+      return { kind: 'focus-main' }
+    }
+
+    return { kind: 'open-in-split' }
+  }
+
+  return { kind: 'navigate' }
+}
diff --git a/apps/desktop/src/app/desktop-controller.tsx b/apps/desktop/src/app/desktop-controller.tsx
index 0e7756b9d8078..83be209d2fd2c 100644
--- a/apps/desktop/src/app/desktop-controller.tsx
+++ b/apps/desktop/src/app/desktop-controller.tsx
@@ -7,7 +7,7 @@ import { BootFailureOverlay } from '@/components/boot-failure-overlay'
 import { DesktopInstallOverlay } from '@/components/desktop-install-overlay'
 import { GatewayConnectingOverlay } from '@/components/gateway-connecting-overlay'
 import { DesktopOnboardingOverlay } from '@/components/onboarding'
-import { Pane, PaneMain } from '@/components/pane-shell'
+import { Pane, PaneMain, PaneShell } from '@/components/pane-shell'
 import { RemoteDisplayBanner } from '@/components/remote-display-banner'
 import { useMediaQuery } from '@/hooks/use-media-query'
 import { isFocusWithin } from '@/lib/keybinds/combo'
@@ -85,6 +85,18 @@ import {
   setRememberedSessionId
 } from '../store/session'
 import { onSessionsChanged } from '../store/session-sync'
+import {
+  $activePaneId,
+  $splitOpen,
+  $splitPaneSession,
+  closeSplitPane,
+  openSplitPaneForSession,
+  registerMainPaneRuntimeSessionIdGetter,
+  registerPaneOpenDispatcher,
+  setActivePane,
+  SPLIT_PANE_ID,
+  splitPaneModelSelect
+} from '../store/split'
 import { clearSessionTodos, setSessionTodos, todosForHydration } from '../store/todos'
 import { openUpdatesWindow, startUpdatePoller, stopUpdatePoller } from '../store/updates'
 import { isSecondaryWindow } from '../store/windows'
@@ -92,6 +104,8 @@ import { isSecondaryWindow } from '../store/windows'
 import { ChatView } from './chat'
 import { requestComposerFocus, requestComposerInsert } from './chat/composer/focus'
 import { useComposerActions } from './chat/hooks/use-composer-actions'
+import { createMainPaneRequest } from './chat/pane-request'
+import { bindMainPaneView } from './chat/pane-view'
 import {
   ChatPreviewRail,
   PREVIEW_RAIL_MAX_WIDTH,
@@ -99,8 +113,9 @@ import {
   PREVIEW_RAIL_PANE_WIDTH
 } from './chat/right-rail'
 import { ChatSidebar } from './chat/sidebar'
+import { SplitChatPane } from './chat/split-pane'
 import { CommandPalette } from './command-palette'
-import { profileRestoreSuperseded } from './desktop-controller-utils'
+import { profileRestoreSuperseded, resolveOpenSessionDispatch } from './desktop-controller-utils'
 import { useGatewayBoot } from './gateway/hooks/use-gateway-boot'
 import { useGatewayRequest } from './gateway/hooks/use-gateway-request'
 import { useReconnectReconciliation } from './gateway/hooks/use-reconnect-reconciliation'
@@ -257,6 +272,8 @@ export function DesktopController() {
   const {
     activeSessionIdRef,
     ensureSessionState,
+    publishPaneState,
+    registerPaneView,
     runtimeIdByStoredSessionIdRef,
     selectedStoredSessionIdRef,
     sessionStateByRuntimeIdRef,
@@ -273,6 +290,140 @@ export function DesktopController() {
 
   const { connectionRef, gatewayRef, requestGateway } = useGatewayRequest()
 
+  // ── Split pane (design §3.5/§3.6/§5) ──────────────────────────────────────
+  // Secondary windows (pop-outs, watch windows) never host the split.
+  const splitOpenStore = useStore($splitOpen)
+  const splitOpen = splitOpenStore && !isSecondaryWindow()
+  const activePaneId = useStore($activePaneId)
+
+  // While the split is open the MAIN pane's send path gains the same
+  // swap-settling guard as the split's paneRequest (design §4); with the split
+  // closed it is a pure pass-through — single-pane behavior byte-identical.
+  const mainPaneRequest = useMemo(() => createMainPaneRequest({ requestGateway }), [requestGateway])
+
+  // Late-bind MAIN_PANE_VIEW's router surface + pane refs (design §3.2): the
+  // main bundle's atoms/setters are module-level aliases, but the routing and
+  // the cache refs only exist once this controller mounts.
+  const locationPathnameRef = useRef(location.pathname)
+  locationPathnameRef.current = location.pathname
+  const navigateRef = useRef(navigate)
+  navigateRef.current = navigate
+
+  useEffect(() => {
+    bindMainPaneView({
+      activeSessionIdRef,
+      busyRef,
+      creatingSessionRef,
+      getTargetSessionId: () => routeSessionId(locationPathnameRef.current),
+      navigateToNewChat: replace => void navigateRef.current(NEW_CHAT_ROUTE, { replace: replace ?? false }),
+      navigateToSession: (storedSessionId, replace) =>
+        void navigateRef.current(sessionRoute(storedSessionId), { replace: replace ?? false }),
+      selectedStoredSessionIdRef
+    })
+  }, [activeSessionIdRef, busyRef, creatingSessionRef, selectedStoredSessionIdRef])
+
+  // Open-in-active-pane dispatcher: every session-open entry point funnels
+  // here. The same-session invariant reads the UNMIRRORED main selection (the
+  // cache ref) — while the split is focused the id singletons mirror ITS
+  // session, so they can't be the guard. Split closed → exactly the old
+  // navigate(sessionRoute()) path. A force-collapsed split (narrow viewport)
+  // dispatches as CLOSED: focusing or filling an invisible pane would strand
+  // typing in a hidden editor, so the session opens in the visible main pane
+  // instead (route-resume then closes the hidden split if it held it).
+  const openSessionInActivePane = useCallback(
+    (storedSessionId: string) => {
+      const action = resolveOpenSessionDispatch({
+        activePaneId: $activePaneId.get(),
+        mainSelectedStoredSessionId: selectedStoredSessionIdRef.current,
+        // Secondary windows share localStorage with the main window, so their
+        // pane-state snapshot can claim an open split they never render.
+        splitOpen: $splitOpen.get() && !isSecondaryWindow() && !narrowViewport,
+        splitStoredSessionId: $splitPaneSession.get()?.storedId ?? null,
+        storedSessionId
+      })
+
+      switch (action.kind) {
+        case 'focus-split':
+          setActivePane('split')
+
+          return
+
+        case 'focus-main':
+          setActivePane('main')
+
+          return
+
+        case 'open-in-split':
+          openSplitPaneForSession(storedSessionId)
+
+          return
+
+        default:
+          navigate(sessionRoute(storedSessionId))
+      }
+    },
+    [narrowViewport, navigate, selectedStoredSessionIdRef]
+  )
+
+  // "Open in split" (session menus): enforce the same-session invariant with
+  // unmirrored truth, then raw-open. Opening the split's own session just
+  // focuses it; opening the main pane's focuses the main pane. Narrow
+  // viewport (split force-collapsed) → the visible main pane instead.
+  const openSessionInSplit = useCallback(
+    (storedSessionId: string, profile?: null | string) => {
+      if (narrowViewport) {
+        openSessionInActivePane(storedSessionId)
+
+        return
+      }
+
+      if ($splitPaneSession.get()?.storedId === storedSessionId) {
+        setActivePane('split')
+
+        return
+      }
+
+      if (storedSessionId === selectedStoredSessionIdRef.current) {
+        setActivePane('main')
+
+        return
+      }
+
+      openSplitPaneForSession(storedSessionId, profile)
+    },
+    [narrowViewport, openSessionInActivePane, selectedStoredSessionIdRef]
+  )
+
+  useEffect(() => {
+    registerPaneOpenDispatcher({ openInActivePane: openSessionInActivePane, openInSplit: openSessionInSplit })
+
+    return () => registerPaneOpenDispatcher(null)
+  }, [openSessionInActivePane, openSessionInSplit])
+
+  // Expose the main pane's UNMIRRORED viewed runtime id for non-React
+  // consumers (native notifications): while the split is focused the
+  // $activeSessionId singleton mirrors the SPLIT's session, but the main
+  // pane's transcript is still on-screen and must count as foreground.
+  useEffect(() => {
+    registerMainPaneRuntimeSessionIdGetter(() => activeSessionIdRef.current)
+
+    return () => registerMainPaneRuntimeSessionIdGetter(null)
+  }, [activeSessionIdRef])
+
+  const activateMainPane = useCallback(() => setActivePane('main'), [])
+
+  // Below the collapse breakpoint the split force-collapses (keeping its
+  // session for when the window widens) — an invisible pane must not stay
+  // (or BECOME) the focused one. Watching activePaneId too makes this a
+  // standing guard: any path that flips focus to the hidden split while
+  // narrow (keybind toggle, palette "Split right", a stray focus event) is
+  // reverted immediately, not just on the next viewport change.
+  useEffect(() => {
+    if (narrowViewport && activePaneId === 'split') {
+      setActivePane('main')
+    }
+  }, [activePaneId, narrowViewport])
+
   useEffect(() => {
     window.hermesDesktop?.setPreviewShortcutActive?.(Boolean(chatOpen && (filePreviewTarget || previewTarget)))
   }, [chatOpen, filePreviewTarget, previewTarget])
@@ -336,12 +487,12 @@ export function DesktopController() {
   useEffect(() => {
     const unsubscribe = window.hermesDesktop?.onFocusSession?.(sessionId => {
       if (sessionId) {
-        navigate(sessionRoute(storedSessionIdForNotification(sessionId, runtimeIdByStoredSessionIdRef.current)))
+        openSessionInActivePane(storedSessionIdForNotification(sessionId, runtimeIdByStoredSessionIdRef.current))
       }
     })
 
     return () => unsubscribe?.()
-  }, [navigate, runtimeIdByStoredSessionIdRef])
+  }, [openSessionInActivePane, runtimeIdByStoredSessionIdRef])
 
   // Notification action button (Approve/Reject) — resolve in place, no navigation.
   useEffect(() => {
@@ -512,6 +663,24 @@ export function DesktopController() {
     [gatewayRef, gatewayState, requestGateway, selectModel]
   )
 
+  // The global ModelPickerOverlay serves the ACTIVE pane: while the split is
+  // focused its pick routes to the split's pane-scoped selectModel (registered
+  // by SplitChatPane) so it writes the split's chip — not the main pane's chip
+  // and sticky localStorage keys. Split closed / main focused → exactly the
+  // controller's own selectModel, as before.
+  const selectModelInActivePane = useCallback(
+    async (selection: { model: string; provider: string }): Promise<boolean> => {
+      const splitSelect = splitPaneModelSelect()
+
+      if (splitSelect && $activePaneId.get() === 'split' && !isSecondaryWindow()) {
+        return splitSelect(selection)
+      }
+
+      return selectModel(selection)
+    },
+    [selectModel]
+  )
+
   useContextSuggestions({
     activeSessionId,
     activeSessionIdRef,
@@ -649,7 +818,12 @@ export function DesktopController() {
     ensureSessionState,
     getRouteToken,
     navigate,
-    requestGateway,
+    // The pane-aware wrapper, NOT the raw active-gateway request: the main
+    // pane's resume path also fires while the split is focused (reconnect
+    // route-resume, bounded auto-retry), and those background RPCs must ride
+    // the main session's own profile socket — the active gateway belongs to
+    // the split then. Split closed → pure pass-through, byte-identical.
+    requestGateway: mainPaneRequest,
     runtimeIdByStoredSessionIdRef,
     selectedStoredSessionId,
     selectedStoredSessionIdRef,
@@ -658,10 +832,98 @@ export function DesktopController() {
     updateSessionState
   })
 
+  // Pane-aware list actions. Deleting/archiving re-routes panes FIRST: the
+  // split closes when its own session goes away, and an active split hands
+  // focus back so the identity mirror is torn down before the action reads
+  // the id singletons. The one-macrotask defer lets that pane switch
+  // re-render, so the action's state closures see the restored main-pane ids
+  // rather than the mirrored split ones. Split closed → exactly the old
+  // synchronous call.
+  const removeSessionRef = useRef(removeSession)
+  removeSessionRef.current = removeSession
+  const archiveSessionRef = useRef(archiveSession)
+  archiveSessionRef.current = archiveSession
+
+  const removeSessionAnyPane = useCallback(
+    (sessionId: string) => {
+      if ($splitOpen.get() && !isSecondaryWindow()) {
+        if ($splitPaneSession.get()?.storedId === sessionId) {
+          closeSplitPane()
+        } else if ($activePaneId.get() === 'split') {
+          setActivePane('main')
+        }
+
+        window.setTimeout(() => void removeSessionRef.current(sessionId), 0)
+
+        return
+      }
+
+      void removeSession(sessionId)
+    },
+    [removeSession]
+  )
+
+  const archiveSessionAnyPane = useCallback(
+    (sessionId: string) => {
+      if ($splitOpen.get() && !isSecondaryWindow()) {
+        if ($splitPaneSession.get()?.storedId === sessionId) {
+          closeSplitPane()
+        } else if ($activePaneId.get() === 'split') {
+          setActivePane('main')
+        }
+
+        window.setTimeout(() => void archiveSessionRef.current(sessionId), 0)
+
+        return
+      }
+
+      void archiveSession(sessionId)
+    },
+    [archiveSession]
+  )
+
+  // Branching opens the child in the MAIN pane — focus it first so the
+  // identity mirror is down before forkBranch writes the main view. A no-op
+  // with the split closed.
+  const branchStoredSessionAnyPane = useCallback(
+    (sessionId: string) => {
+      setActivePane('main')
+      void branchStoredSession(sessionId)
+    },
+    [branchStoredSession]
+  )
+
+  // Session picker (/resume, /switch): pre-split this called resumeSession
+  // directly — including for the ALREADY-OPEN session, which is the way to
+  // force a re-resume of a wedged chat from the picker. The dispatcher's
+  // navigate() path would no-op there (same pathname ⇒ route-resume skips),
+  // so with the split closed and the picked session already selected, keep
+  // the forced re-resume. Everything else routes through the dispatcher
+  // (design §1.9).
+  const resumeFromPicker = useCallback(
+    (storedSessionId: string) => {
+      const splitInPlay = $splitOpen.get() && !isSecondaryWindow()
+
+      if (!splitInPlay && storedSessionId === selectedStoredSessionIdRef.current) {
+        void resumeSession(storedSessionId)
+
+        return
+      }
+
+      openSessionInActivePane(storedSessionId)
+    },
+    [openSessionInActivePane, resumeSession, selectedStoredSessionIdRef]
+  )
+
   // Single global listener for every rebindable hotkey (incl. profile switching)
   // plus the on-screen keybind editor's capture mode.
   useKeybinds({
-    startFreshSession: startFreshSessionDraft,
+    startFreshSession: () => {
+      // A keyboard new-chat is a MAIN-pane gesture: hand focus back first so
+      // the fresh draft never runs against mirrored split identity.
+      setActivePane('main')
+      startFreshSessionDraft()
+    },
     toggleCommandCenter,
     toggleSelectedPin
   })
@@ -677,6 +939,8 @@ export function DesktopController() {
     }
 
     lastFreshRef.current = freshSessionRequest
+    // Profile-driven fresh drafts are MAIN-pane context switches.
+    setActivePane('main')
     startFreshSessionDraft()
   }, [freshSessionRequest, startFreshSessionDraft])
 
@@ -699,6 +963,9 @@ export function DesktopController() {
     }
 
     lastProfileRestoreTokenRef.current = request.token
+    // A profile switch restores the MAIN pane's context — focus it first so
+    // the restore's navigate/draft never runs against mirrored split identity.
+    setActivePane('main')
     const remembered = request.sessionId ?? rememberedProfileSession(request.profile)
 
     if (!remembered) {
@@ -767,7 +1034,7 @@ export function DesktopController() {
   const composer = useComposerActions({
     activeSessionId,
     currentCwd,
-    requestGateway
+    requestGateway: mainPaneRequest
   })
 
   const branchInNewChat = useCallback(
@@ -828,6 +1095,8 @@ export function DesktopController() {
 
   const startSessionInWorkspace = useCallback(
     (path: null | string) => {
+      // Workspace "+" seeds the MAIN pane's next chat — focus it first.
+      setActivePane('main')
       startFreshSessionDraft()
 
       // A worktree lane carries its own path; the trunk "+" can be path-less (the
@@ -908,7 +1177,7 @@ export function DesktopController() {
     handleSkinCommand,
     openMemoryGraph: openStarmap,
     refreshSessions,
-    requestGateway,
+    requestGateway: mainPaneRequest,
     resumeStoredSession: resumeSession,
     selectedStoredSessionIdRef,
     startFreshSessionDraft,
@@ -946,6 +1215,9 @@ export function DesktopController() {
       const recent = $sessions.get()[0]
 
       if (recent?.id) {
+        // The pet resumes into the MAIN pane — focus it first so the resume's
+        // view writes never race the split's identity mirror.
+        setActivePane('main')
         void resumeSessionRef.current(recent.id)
       }
     })
@@ -1114,9 +1386,9 @@ export function DesktopController() {
   const sidebar = (
     <ChatSidebar
       currentView={currentView}
-      onArchiveSession={sessionId => void archiveSession(sessionId)}
-      onBranchSession={sessionId => void branchStoredSession(sessionId)}
-      onDeleteSession={sessionId => void removeSession(sessionId)}
+      onArchiveSession={archiveSessionAnyPane}
+      onBranchSession={branchStoredSessionAnyPane}
+      onDeleteSession={removeSessionAnyPane}
       onLoadMoreMessaging={loadMoreMessagingForPlatform}
       onLoadMoreProfileSessions={loadMoreSessionsForProfile}
       onLoadMoreSessions={loadMoreSessions}
@@ -1126,7 +1398,7 @@ export function DesktopController() {
       }}
       onNavigate={selectSidebarItem}
       onNewSessionInWorkspace={startSessionInWorkspace}
-      onResumeSession={sessionId => navigate(sessionRoute(sessionId))}
+      onResumeSession={openSessionInActivePane}
       onTriggerCronJob={jobId => {
         void triggerCronJob(jobId)
           .then(() => refreshCronJobs())
@@ -1157,8 +1429,8 @@ export function DesktopController() {
           requestGateway={requestGateway}
         />
       )}
-      <ModelPickerOverlay gateway={gatewayRef.current || undefined} onSelect={selectModel} />
-      <SessionPickerOverlay onResume={resumeSession} />
+      <ModelPickerOverlay gateway={gatewayRef.current || undefined} onSelect={selectModelInActivePane} />
+      <SessionPickerOverlay onResume={resumeFromPicker} />
       <ModelVisibilityOverlay gateway={gatewayRef.current || undefined} onOpenProviders={openProviderSettings} />
       <UpdatesOverlay />
       <GatewayConnectingOverlay />
@@ -1195,9 +1467,9 @@ export function DesktopController() {
           <CommandCenterView
             initialSection={commandCenterInitialSection}
             onClose={closeOverlayToPreviousRoute}
-            onDeleteSession={removeSession}
+            onDeleteSession={async sessionId => removeSessionAnyPane(sessionId)}
             onNavigateRoute={path => navigate(path)}
-            onOpenSession={sessionId => navigate(sessionRoute(sessionId))}
+            onOpenSession={openSessionInActivePane}
           />
         </Suspense>
       )}
@@ -1210,10 +1482,7 @@ export function DesktopController() {
 
       {cronOpen && (
         <Suspense fallback={null}>
-          <CronView
-            onClose={closeOverlayToPreviousRoute}
-            onOpenSession={sessionId => navigate(sessionRoute(sessionId))}
-          />
+          <CronView onClose={closeOverlayToPreviousRoute} onOpenSession={openSessionInActivePane} />
         </Suspense>
       )}
 
@@ -1250,7 +1519,7 @@ export function DesktopController() {
       onCancel={cancelRun}
       onDeleteSelectedSession={() => {
         if (selectedStoredSessionId) {
-          void removeSession(selectedStoredSessionId)
+          removeSessionAnyPane(selectedStoredSessionId)
         }
       }}
       onDismissError={dismissError}
@@ -1271,6 +1540,69 @@ export function DesktopController() {
     />
   )
 
+  // The chat column hosts an inner, chat-only PaneShell (design §5): main
+  // chat + the split pane. Outer rails are untouched. The PaneShell/PaneMain
+  // wrappers (and the disabled 0px split cell) are ALWAYS mounted so toggling
+  // the split never remounts ChatView (thread/composer state survives); with
+  // the split closed they add two inert wrapper divs around the otherwise
+  // unchanged chat subtree. The main wrapper is a zero-box `display:contents`
+  // shell that only exists while the split is open; its capture handlers make
+  // any interaction focus the main pane BEFORE the subtree's own handlers
+  // run. (display:contents generates no box, so the main pane carries no
+  // focus ring of its own — the split pane's hairline flipping is the v1
+  // active-pane indicator; data-pane-active is provided for tooling.)
+  const chatArea = (
+    <PaneShell>
+      <PaneMain>
+        {splitOpen ? (
+          <div
+            className="contents"
+            data-pane-active={activePaneId === 'main' ? 'true' : 'false'}
+            data-pane-id="chat-main-view"
+            onFocusCapture={activateMainPane}
+            onPointerDownCapture={activateMainPane}
+          >
+            {chatView}
+          </div>
+        ) : (
+          chatView
+        )}
+      </PaneMain>
+      <Pane
+        defaultOpen={false}
+        disabled={!splitOpen}
+        divider
+        forceCollapsed={narrowViewport}
+        id={SPLIT_PANE_ID}
+        maxWidth="70%"
+        minWidth={380}
+        resizable
+        side="right"
+        width="44%"
+      >
+        {splitOpen ? (
+          <SplitChatPane
+            ensureSessionState={ensureSessionState}
+            gateway={gatewayRef.current}
+            maxVoiceRecordingSeconds={voiceMaxRecordingSeconds}
+            onRemoveSession={removeSessionAnyPane}
+            onToggleSelectedPin={toggleSelectedPin}
+            openMemoryGraph={openStarmap}
+            publishPaneState={publishPaneState}
+            refreshSessions={refreshSessions}
+            registerPaneView={registerPaneView}
+            requestGateway={requestGateway}
+            runtimeIdByStoredSessionIdRef={runtimeIdByStoredSessionIdRef}
+            sessionStateByRuntimeIdRef={sessionStateByRuntimeIdRef}
+            sttEnabled={sttEnabled}
+            syncSessionStateToView={syncSessionStateToView}
+            updateSessionState={updateSessionState}
+          />
+        ) : null}
+      </Pane>
+    </PaneShell>
+  )
+
   // Flipped layout mirrors the default: sessions sidebar → right, file
   // browser + preview rail → left. Same panes, swapped sides.
   const sidebarSide = panesFlipped ? 'right' : 'left'
@@ -1416,8 +1748,8 @@ export function DesktopController() {
       )}
       <PaneMain>
         <Routes>
-          <Route element={chatView} index />
-          <Route element={chatView} path=":sessionId" />
+          <Route element={chatArea} index />
+          <Route element={chatArea} path=":sessionId" />
           <Route
             element={
               <Suspense fallback={null}>
diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.keep-set.test.ts b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.keep-set.test.ts
new file mode 100644
index 0000000000000..55f8352edc8cc
--- /dev/null
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.keep-set.test.ts
@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, it } from 'vitest'
+
+import type { SessionInfo } from '@/hermes'
+import { $attentionSessionIds, $workingSessionIds, setSessions, setSessionWorking } from '@/store/session'
+import { $splitPaneSession } from '@/store/split'
+
+import { keptGatewayProfiles } from './use-gateway-boot'
+
+// The prune keep-set (design §4.4 / §6 step 13): an idle split session's
+// profile must keep its background socket, or the pane's next stream/steer
+// dies with a reaped backend.
+
+function storedSession(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    ended_at: null,
+    id: 'stored-1',
+    input_tokens: 0,
+    is_active: false,
+    last_active: 1,
+    message_count: 0,
+    model: null,
+    output_tokens: 0,
+    preview: null,
+    source: 'desktop',
+    started_at: 1,
+    title: 'stored',
+    tool_call_count: 0,
+    ...overrides
+  }
+}
+
+function resetStores() {
+  for (const id of $workingSessionIds.get()) {
+    setSessionWorking(id, false)
+  }
+
+  $attentionSessionIds.set([])
+  setSessions([])
+  $splitPaneSession.set(null)
+}
+
+describe('keptGatewayProfiles', () => {
+  afterEach(resetStores)
+
+  it('keeps profiles with a running session (baseline behavior unchanged)', () => {
+    setSessions([storedSession({ id: 'stored-a', profile: 'coder' })])
+    setSessionWorking('stored-a', true)
+
+    expect(keptGatewayProfiles()).toEqual(new Set(['coder']))
+  })
+
+  it("includes the split pane's session profile even while that session is idle", () => {
+    setSessions([storedSession({ id: 'stored-a', profile: 'coder' })])
+    setSessionWorking('stored-a', true)
+    $splitPaneSession.set({ profile: 'analyst', storedId: 'stored-split' })
+
+    expect(keptGatewayProfiles()).toEqual(new Set(['coder', 'analyst']))
+  })
+
+  it("normalizes an untagged split session to the default profile's key", () => {
+    $splitPaneSession.set({ profile: null, storedId: 'stored-split' })
+
+    expect(keptGatewayProfiles()).toEqual(new Set(['default']))
+  })
+
+  it('drops the split profile once the split closes (no leaked keep-alive)', () => {
+    $splitPaneSession.set({ profile: 'analyst', storedId: 'stored-split' })
+    expect(keptGatewayProfiles()).toEqual(new Set(['analyst']))
+
+    $splitPaneSession.set(null)
+    expect(keptGatewayProfiles()).toEqual(new Set())
+  })
+})
diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
index e8d73afa8926f..f38956ae440f2 100644
--- a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
@@ -38,6 +38,7 @@ import {
   setCurrentCwd,
   setSessionsLoading
 } from '@/store/session'
+import { $splitPaneSession } from '@/store/split'
 import type { RpcEvent } from '@/types/hermes'
 
 // After this many consecutive failed reconnects (≈45s with the 1→15s backoff)
@@ -60,6 +61,32 @@ const bootRetryDelay = (attempt: number): number => {
   return Math.round(base * (0.8 + Math.random() * 0.4))
 }
 
+/**
+ * Profiles whose background socket must survive pruning: any profile with a
+ * running (working) or blocked (needs-input) session, plus the split pane's
+ * session profile — an idle split session must keep its socket so its next
+ * stream/steer doesn't die with a reaped backend (design §4.4). Exported for
+ * tests; reads the stores directly so the subscriptions below can share it.
+ */
+export function keptGatewayProfiles(): Set<string> {
+  const live = new Set([...$workingSessionIds.get(), ...$attentionSessionIds.get()])
+  const keep = new Set<string>()
+
+  for (const session of $sessions.get()) {
+    if (live.has(session.id)) {
+      keep.add(normalizeProfileKey(session.profile))
+    }
+  }
+
+  const splitSession = $splitPaneSession.get()
+
+  if (splitSession) {
+    keep.add(normalizeProfileKey(splitSession.profile))
+  }
+
+  return keep
+}
+
 interface GatewayBootOptions {
   handleGatewayEvent: (event: RpcEvent) => void
   onConnectionReady: (
@@ -363,31 +390,31 @@ export function useGatewayBoot({
 
     // Keep live pool backends alive while this window is open (the main process
     // can't observe the direct renderer↔backend WS). No-op for the primary.
+    // The split pane's backend is touched explicitly too: its socket may not
+    // exist yet (restore pending), and the backend must not idle-reap first.
     const keepaliveTimer = setInterval(() => {
       touchActiveGatewayBackend()
       touchSecondaryGateways()
+      const splitSession = $splitPaneSession.get()
+
+      if (splitSession) {
+        void desktop.touchBackend?.(normalizeProfileKey(splitSession.profile)).catch(() => undefined)
+      }
     }, 60_000)
 
     // Bound concurrency cost to live work: keep a background socket only while
-    // its profile has a running (working) or blocked (needs-input) session.
-    // Once that profile goes idle its socket is dropped and its backend is free
-    // to idle-reap. The active profile is always spared.
+    // its profile has a running (working) or blocked (needs-input) session —
+    // or holds the split pane's session. Once a profile drops out of that set
+    // its socket is closed and its backend is free to idle-reap. The active
+    // profile is always spared.
     const recomputeKeptGateways = () => {
-      const live = new Set([...$workingSessionIds.get(), ...$attentionSessionIds.get()])
-      const keep = new Set<string>()
-
-      for (const session of $sessions.get()) {
-        if (live.has(session.id)) {
-          keep.add(normalizeProfileKey(session.profile))
-        }
-      }
-
-      pruneSecondaryGateways(keep)
+      pruneSecondaryGateways(keptGatewayProfiles())
     }
 
     const offWorking = $workingSessionIds.subscribe(() => recomputeKeptGateways())
     const offAttention = $attentionSessionIds.subscribe(() => recomputeKeptGateways())
     const offActiveProfile = $activeGatewayProfile.subscribe(() => recomputeKeptGateways())
+    const offSplitPane = $splitPaneSession.subscribe(() => recomputeKeptGateways())
 
     const offWindowState = desktop.onWindowStateChanged?.(payload => {
       const current = $connection.get()
@@ -523,6 +550,7 @@ export function useGatewayBoot({
       offWorking()
       offAttention()
       offActiveProfile()
+      offSplitPane()
       window.removeEventListener('online', onOnline)
       document.removeEventListener('visibilitychange', onVisible)
       offPowerResume?.()
diff --git a/apps/desktop/src/app/hooks/use-keybinds.ts b/apps/desktop/src/app/hooks/use-keybinds.ts
index 68dbb4ceafad7..8e6017f9b15e2 100644
--- a/apps/desktop/src/app/hooks/use-keybinds.ts
+++ b/apps/desktop/src/app/hooks/use-keybinds.ts
@@ -41,7 +41,8 @@ import {
   switcherActive,
   switcherJustClosed
 } from '@/store/session-switcher'
-import { openNewSessionInNewWindow } from '@/store/windows'
+import { dispatchOpenSession, toggleSplitPane } from '@/store/split'
+import { isSecondaryWindow, openNewSessionInNewWindow } from '@/store/windows'
 import { useTheme } from '@/themes/context'
 
 import { requestComposerFocus, requestVoiceToggle } from '../chat/composer/focus'
@@ -86,8 +87,12 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void {
     profileSwitchHandlers[`profile.switch.${slot}`] = () => switchProfileToSlot(slot)
   }
 
+  // Session jumps route through the open-in-active-pane dispatcher (⌃Tab
+  // switcher + ⌃1..9 slots land in whichever pane is focused; duplicates focus
+  // the pane already showing the session). The navigate() fallback only runs
+  // before DesktopController registers the dispatcher — same path as before.
   const goToSession = (sessionId: null | string) => {
-    if (sessionId) {
+    if (sessionId && !dispatchOpenSession(sessionId)) {
       navigate(sessionRoute(sessionId))
     }
   }
@@ -179,6 +184,8 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void {
     'view.prevTerminal': () => $terminalTakeover.get() && cycleTerminal(-1),
     'view.closeTerminal': () => $terminalTakeover.get() && closeActiveTerminal(),
     'view.flipPanes': togglePanesFlipped,
+    // Secondary windows (pop-outs, watch windows) never host the split pane.
+    'view.toggleSplit': () => !isSecondaryWindow() && toggleSplitPane(),
 
     'appearance.toggleMode': () => setMode(resolvedMode === 'dark' ? 'light' : 'dark'),
 
diff --git a/apps/desktop/src/app/session/hooks/use-model-controls.ts b/apps/desktop/src/app/session/hooks/use-model-controls.ts
index 9b6b060a67768..a34b8f5d9ecdc 100644
--- a/apps/desktop/src/app/session/hooks/use-model-controls.ts
+++ b/apps/desktop/src/app/session/hooks/use-model-controls.ts
@@ -5,9 +5,10 @@ import { getGlobalModelInfo } from '@/hermes'
 import { useI18n } from '@/i18n'
 import { notifyError } from '@/store/notifications'
 import { activeProfileQueryKey } from '@/store/profile'
-import { $activeSessionId, $currentModel, $currentProvider, setCurrentModel, setCurrentProvider } from '@/store/session'
 import type { ModelOptionsResponse } from '@/types/hermes'
 
+import { MAIN_PANE_VIEW, type PaneSessionView } from '../../chat/pane-view'
+
 interface ModelSelection {
   model: string
   provider: string
@@ -17,9 +18,21 @@ interface ModelControlsOptions {
   activeSessionId: string | null
   queryClient: QueryClient
   requestGateway: <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>
+  /** The pane view whose model chip a pick writes. Defaults to the main
+   *  bundle — the exact global atoms/persisting setters this hook always
+   *  used — so the controller's instance is unchanged; SplitChatPane runs a
+   *  second instance bound to its own bundle (plain, non-persisting setters)
+   *  and its profile-pinned request, so a split pick can never clobber the
+   *  main chip or the sticky composer-model localStorage keys. */
+  view?: PaneSessionView
 }
 
-export function useModelControls({ activeSessionId, queryClient, requestGateway }: ModelControlsOptions) {
+export function useModelControls({
+  activeSessionId,
+  queryClient,
+  requestGateway,
+  view = MAIN_PANE_VIEW
+}: ModelControlsOptions) {
   const { t } = useI18n()
   const copy = t.desktop
 
@@ -46,33 +59,36 @@ export function useModelControls({ activeSessionId, queryClient, requestGateway
   // only fills an EMPTY selection so a user's pick (plain UI state in
   // $currentModel) survives the lifecycle refreshes that fire on boot / fresh
   // draft / session events. A live session owns the footer, so skip entirely.
-  const refreshCurrentModel = useCallback(async (force = false) => {
-    try {
-      if ($activeSessionId.get()) {
-        return
-      }
+  const refreshCurrentModel = useCallback(
+    async (force = false) => {
+      try {
+        if (view.$activeSessionId.get()) {
+          return
+        }
 
-      if (!force && $currentModel.get()) {
-        return
-      }
+        if (!force && view.$currentModel.get()) {
+          return
+        }
 
-      const result = await getGlobalModelInfo()
+        const result = await getGlobalModelInfo()
 
-      if ($activeSessionId.get() || (!force && $currentModel.get())) {
-        return
-      }
+        if (view.$activeSessionId.get() || (!force && view.$currentModel.get())) {
+          return
+        }
 
-      if (typeof result.model === 'string') {
-        setCurrentModel(result.model)
-      }
+        if (typeof result.model === 'string') {
+          view.setCurrentModel(result.model)
+        }
 
-      if (typeof result.provider === 'string') {
-        setCurrentProvider(result.provider)
+        if (typeof result.provider === 'string') {
+          view.setCurrentProvider(result.provider)
+        }
+      } catch {
+        // The delayed session.info event still updates this once the agent is ready.
       }
-    } catch {
-      // The delayed session.info event still updates this once the agent is ready.
-    }
-  }, [])
+    },
+    [view]
+  )
 
   // Returns whether the switch succeeded so callers can await it before applying
   // follow-up changes. The composer model is plain UI state: with no live
@@ -85,11 +101,11 @@ export function useModelControls({ activeSessionId, queryClient, requestGateway
       // Snapshot for rollback: the switch is applied optimistically, so a
       // failure must restore the prior model/provider (store + query cache)
       // rather than leave the UI showing a model the backend never selected.
-      const prevModel = $currentModel.get()
-      const prevProvider = $currentProvider.get()
+      const prevModel = view.$currentModel.get()
+      const prevProvider = view.$currentProvider.get()
 
-      setCurrentModel(selection.model)
-      setCurrentProvider(selection.provider)
+      view.setCurrentModel(selection.model)
+      view.setCurrentProvider(selection.provider)
       updateModelOptionsCache(selection.provider, selection.model, !activeSessionId)
 
       // No live session yet: the pick is pure UI state. session.create reads
@@ -109,15 +125,15 @@ export function useModelControls({ activeSessionId, queryClient, requestGateway
 
         return true
       } catch (err) {
-        setCurrentModel(prevModel)
-        setCurrentProvider(prevProvider)
+        view.setCurrentModel(prevModel)
+        view.setCurrentProvider(prevProvider)
         updateModelOptionsCache(prevProvider, prevModel, !activeSessionId)
         notifyError(err, copy.modelSwitchFailed)
 
         return false
       }
     },
-    [activeSessionId, copy.modelSwitchFailed, queryClient, requestGateway, updateModelOptionsCache]
+    [activeSessionId, copy.modelSwitchFailed, queryClient, requestGateway, updateModelOptionsCache, view]
   )
 
   return { refreshCurrentModel, selectModel, updateModelOptionsCache }
diff --git a/apps/desktop/src/app/session/hooks/use-prompt-actions/index.ts b/apps/desktop/src/app/session/hooks/use-prompt-actions/index.ts
index 5928bae6fd876..5f426687fc862 100644
--- a/apps/desktop/src/app/session/hooks/use-prompt-actions/index.ts
+++ b/apps/desktop/src/app/session/hooks/use-prompt-actions/index.ts
@@ -11,20 +11,16 @@ import { triggerHaptic } from '@/lib/haptics'
 import { setMutableRef } from '@/lib/mutable-ref'
 import { normalize } from '@/lib/text'
 import { clearClarifyRequest } from '@/store/clarify'
-import {
-  $composerAttachments,
-  type ComposerAttachment,
-  setComposerAttachmentUploadState,
-  updateComposerAttachment
-} from '@/store/composer'
+import { type ComposerAttachment, setComposerAttachmentUploadState, updateComposerAttachment } from '@/store/composer'
 import { resetSessionBackground } from '@/store/composer-status'
 import { clearNotifications, notify, notifyError } from '@/store/notifications'
 import { clearPreviewArtifacts } from '@/store/preview-status'
 import { clearAllPrompts } from '@/store/prompts'
-import { $busy, $connection, $messages, setAwaitingResponse, setBusy, setMessages } from '@/store/session'
+import { $connection } from '@/store/session'
 import { clearSessionSubagents } from '@/store/subagents'
 import { clearSessionTodos } from '@/store/todos'
 
+import { MAIN_PANE_VIEW, type PaneSessionView } from '../../../chat/pane-view'
 import type {
   ClientSessionState,
   FileAttachResponse,
@@ -171,6 +167,10 @@ interface PromptActionsOptions {
     updater: (state: ClientSessionState) => ClientSessionState,
     storedSessionId?: string | null
   ) => ClientSessionState
+  /** The pane view this instance drives. Defaults to the main bundle — i.e.
+   *  the pre-split global atoms — so every existing caller is unchanged; the
+   *  split pane passes its own factory-created bundle. */
+  view?: PaneSessionView
 }
 
 /** Everything a slash handler needs about the invocation it's serving. */
@@ -194,7 +194,8 @@ export function usePromptActions({
   selectedStoredSessionIdRef,
   startFreshSessionDraft,
   sttEnabled,
-  updateSessionState
+  updateSessionState,
+  view = MAIN_PANE_VIEW
 }: PromptActionsOptions) {
   const { t } = useI18n()
   const copy = t.desktop
@@ -257,7 +258,7 @@ export function usePromptActions({
 
         if (inFlight) {
           await inFlight
-          attachment = $composerAttachments.get().find(item => item.id === attachment.id) ?? attachment
+          attachment = view.$composerAttachments.get().find(item => item.id === attachment.id) ?? attachment
         }
 
         // Already-synced or pathless refs (terminal, url, etc.) pass through.
@@ -274,7 +275,7 @@ export function usePromptActions({
 
           // Update-only: never resurrect a chip the user removed mid-upload.
           if (updateComposerAttachments) {
-            updateComposerAttachment(nextAttachment)
+            updateComposerAttachment(nextAttachment, view.$composerAttachments)
           }
 
           synced.push(nextAttachment)
@@ -287,7 +288,7 @@ export function usePromptActions({
 
       return synced
     },
-    [requestGateway]
+    [requestGateway, view]
   )
 
   // Stage a freshly dropped file as soon as it lands (when a session already
@@ -304,24 +305,27 @@ export function usePromptActions({
     async (sessionId: string, attachment: ComposerAttachment) => {
       const remote = $connection.get()?.mode === 'remote'
 
-      setComposerAttachmentUploadState(attachment.id, 'uploading')
+      setComposerAttachmentUploadState(attachment.id, 'uploading', view.$composerAttachments)
 
       try {
         // Update-only: if the user removed the chip while this was uploading,
         // don't resurrect it — just drop the staged result on the floor.
-        updateComposerAttachment(await uploadComposerAttachment(attachment, { remote, requestGateway, sessionId }))
+        updateComposerAttachment(
+          await uploadComposerAttachment(attachment, { remote, requestGateway, sessionId }),
+          view.$composerAttachments
+        )
       } catch (err) {
         // Leave the chip in place so submit-time sync can retry (or the user can
         // remove it) and flag the card; also toast so a hard failure (unreadable
         // file, gateway perms) isn't swallowed while the user keeps typing.
-        setComposerAttachmentUploadState(attachment.id, 'error')
+        setComposerAttachmentUploadState(attachment.id, 'error', view.$composerAttachments)
         notifyError(err, copy.dropFiles)
       }
     },
-    [copy.dropFiles, requestGateway]
+    [copy.dropFiles, requestGateway, view]
   )
 
-  const composerAttachments = useStore($composerAttachments)
+  const composerAttachments = useStore(view.$composerAttachments)
 
   useEffect(() => {
     if (!activeSessionId) {
@@ -357,7 +361,8 @@ export function usePromptActions({
     requestGateway,
     selectedStoredSessionIdRef,
     syncAttachmentsForSubmit,
-    updateSessionState
+    updateSessionState,
+    view
   })
 
   // Queue a handoff of this session to a messaging platform and watch it to
@@ -461,7 +466,7 @@ export function usePromptActions({
   const submitText = useCallback(
     async (rawText: string, options?: SubmitTextOptions) => {
       const visibleText = rawText.trim()
-      const attachments = options?.attachments ?? $composerAttachments.get()
+      const attachments = options?.attachments ?? view.$composerAttachments.get()
 
       if (!attachments.length && SLASH_COMMAND_RE.test(visibleText)) {
         triggerHaptic('selection')
@@ -472,7 +477,7 @@ export function usePromptActions({
 
       return await submitPromptText(rawText, options)
     },
-    [executeSlashCommand, submitPromptText]
+    [executeSlashCommand, submitPromptText, view]
   )
 
   const transcribeVoiceAudio = useCallback(
@@ -494,10 +499,10 @@ export function usePromptActions({
 
     const releaseBusy = () => {
       setMutableRef(busyRef, false)
-      setBusy(false)
+      view.setBusy(false)
     }
 
-    setAwaitingResponse(false)
+    view.setAwaitingResponse(false)
 
     const finalizeMessages = (messages: ChatMessage[], streamId?: string | null) =>
       messages
@@ -506,7 +511,7 @@ export function usePromptActions({
 
     if (!sessionId) {
       releaseBusy()
-      setMessages(finalizeMessages($messages.get()))
+      view.setMessages(finalizeMessages(view.$messages.get()))
 
       return
     }
@@ -573,7 +578,8 @@ export function usePromptActions({
     copy.stopFailed,
     requestGateway,
     selectedStoredSessionIdRef,
-    updateSessionState
+    updateSessionState,
+    view
   ])
 
   // Steer = nudge the live turn without interrupting: the gateway appends the
@@ -612,11 +618,11 @@ export function usePromptActions({
 
   const reloadFromMessage = useCallback(
     async (parentId: string | null) => {
-      if (!activeSessionId || $busy.get()) {
+      if (!activeSessionId || view.$busy.get()) {
         return
       }
 
-      const messages = $messages.get()
+      const messages = view.$messages.get()
       const parentIndex = parentId ? messages.findIndex(message => message.id === parentId) : messages.length - 1
 
       const userIndex =
@@ -687,7 +693,7 @@ export function usePromptActions({
         notifyError(err, copy.regenerateFailed)
       }
     },
-    [activeSessionId, copy.regenerateFailed, requestGateway, updateSessionState]
+    [activeSessionId, copy.regenerateFailed, requestGateway, updateSessionState, view]
   )
 
   // Cursor-style "restore checkpoint": rewind the conversation to a past user
@@ -746,7 +752,7 @@ export function usePromptActions({
         throw new Error('No active session to restore.')
       }
 
-      const messages = $messages.get()
+      const messages = view.$messages.get()
       const idIndex = messages.findIndex(m => m.id === messageId && m.role === 'user')
 
       const fallbackIndex =
@@ -781,8 +787,8 @@ export function usePromptActions({
 
       clearNotifications()
       setMutableRef(busyRef, true)
-      setBusy(true)
-      setAwaitingResponse(true)
+      view.setBusy(true)
+      view.setAwaitingResponse(true)
       updateSessionState(sessionId, state => ({
         ...state,
         busy: true,
@@ -794,15 +800,15 @@ export function usePromptActions({
       }))
 
       try {
-        await submitRewindPrompt(sessionId, text, truncateBeforeUserOrdinal, busyRef.current || $busy.get())
+        await submitRewindPrompt(sessionId, text, truncateBeforeUserOrdinal, busyRef.current || view.$busy.get())
       } catch (err) {
         // The rewind never landed (e.g. the gateway stayed busy past the retry
         // deadline). Roll the optimistic truncation back to the full original
         // history so the UI doesn't desync from what's persisted — leaving it
         // truncated is what made subsequent sends look duplicative.
         setMutableRef(busyRef, false)
-        setBusy(false)
-        setAwaitingResponse(false)
+        view.setBusy(false)
+        view.setAwaitingResponse(false)
         updateSessionState(sessionId, state => ({
           ...state,
           busy: false,
@@ -812,7 +818,7 @@ export function usePromptActions({
         throw err
       }
     },
-    [activeSessionId, activeSessionIdRef, busyRef, submitRewindPrompt, updateSessionState]
+    [activeSessionId, activeSessionIdRef, busyRef, submitRewindPrompt, updateSessionState, view]
   )
 
   const editMessage = useCallback(
@@ -825,7 +831,7 @@ export function usePromptActions({
         return
       }
 
-      const messages = $messages.get()
+      const messages = view.$messages.get()
       const sourceIndex = messages.findIndex(m => m.id === sourceId)
       const source = messages[sourceIndex]
 
@@ -852,8 +858,8 @@ export function usePromptActions({
 
       clearNotifications()
       setMutableRef(busyRef, true)
-      setBusy(true)
-      setAwaitingResponse(true)
+      view.setBusy(true)
+      view.setAwaitingResponse(true)
       updateSessionState(sessionId, state => ({
         ...state,
         busy: true,
@@ -872,7 +878,7 @@ export function usePromptActions({
           sessionId,
           text,
           isFailedTurn ? undefined : visibleUserOrdinal(messages, sourceIndex),
-          busyRef.current || $busy.get()
+          busyRef.current || view.$busy.get()
         )
       } catch (err) {
         let surfaced = err
@@ -892,13 +898,13 @@ export function usePromptActions({
         // UI stays in sync with what's persisted instead of stranding a partial
         // timeline.
         setMutableRef(busyRef, false)
-        setBusy(false)
-        setAwaitingResponse(false)
+        view.setBusy(false)
+        view.setAwaitingResponse(false)
         updateSessionState(sessionId, state => ({ ...state, busy: false, awaitingResponse: false, messages }))
         notifyError(surfaced, copy.editFailed)
       }
     },
-    [activeSessionId, activeSessionIdRef, busyRef, copy.editFailed, submitRewindPrompt, updateSessionState]
+    [activeSessionId, activeSessionIdRef, busyRef, copy.editFailed, submitRewindPrompt, updateSessionState, view]
   )
 
   const handleThreadMessagesChange = useCallback(
diff --git a/apps/desktop/src/app/session/hooks/use-prompt-actions/submit.ts b/apps/desktop/src/app/session/hooks/use-prompt-actions/submit.ts
index 5127b534f1c28..ca197d2d38246 100644
--- a/apps/desktop/src/app/session/hooks/use-prompt-actions/submit.ts
+++ b/apps/desktop/src/app/session/hooks/use-prompt-actions/submit.ts
@@ -5,16 +5,11 @@ import type { Translations } from '@/i18n'
 import { type ChatMessage, textPart } from '@/lib/chat-messages'
 import { optimisticAttachmentRef } from '@/lib/chat-runtime'
 import { setMutableRef } from '@/lib/mutable-ref'
-import {
-  $composerAttachments,
-  clearComposerAttachments,
-  type ComposerAttachment,
-  terminalContextBlocksFromDraft
-} from '@/store/composer'
+import { clearComposerAttachments, type ComposerAttachment, terminalContextBlocksFromDraft } from '@/store/composer'
 import { clearNotifications, notify, notifyError } from '@/store/notifications'
 import { requestDesktopOnboarding } from '@/store/onboarding'
-import { setAwaitingResponse, setBusy, setMessages } from '@/store/session'
 
+import type { PaneSessionView } from '../../../chat/pane-view'
 import type { ClientSessionState } from '../../../types'
 
 import {
@@ -46,6 +41,8 @@ interface SubmitPromptDeps {
     updater: (state: ClientSessionState) => ClientSessionState,
     storedSessionId?: string | null
   ) => ClientSessionState
+  /** The pane view this pipeline publishes into (threaded by usePromptActions). */
+  view: PaneSessionView
 }
 
 /** The prompt submit pipeline, extracted from usePromptActions. */
@@ -59,7 +56,8 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
     requestGateway,
     selectedStoredSessionIdRef,
     syncAttachmentsForSubmit,
-    updateSessionState
+    updateSessionState,
+    view
   } = deps
 
   return useCallback(
@@ -72,8 +70,8 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
       // this, the sibling iterations below (a.kind / a.label / a.refText, and the
       // sync step) throw "Cannot read properties of undefined (reading 'refText')"
       // and break the chat surface.
-      const attachments = (options?.attachments ?? $composerAttachments.get()).filter((a): a is ComposerAttachment =>
-        Boolean(a)
+      const attachments = (options?.attachments ?? view.$composerAttachments.get()).filter(
+        (a): a is ComposerAttachment => Boolean(a)
       )
 
       const terminalContextBlocks = terminalContextBlocksFromDraft(rawText).join('\n\n')
@@ -142,8 +140,8 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
       const releaseBusy = () => {
         releaseSubmitLock()
         setMutableRef(busyRef, false)
-        setBusy(false)
-        setAwaitingResponse(false)
+        view.setBusy(false)
+        view.setAwaitingResponse(false)
       }
 
       // Idempotent optimistic insert — re-running with the resolved sessionId
@@ -182,7 +180,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
 
       const dropOptimistic = (sid: null | string) => {
         if (!sid) {
-          setMessages(current => current.filter(m => m.id !== optimisticId))
+          view.setMessages(current => current.filter(m => m.id !== optimisticId))
 
           return
         }
@@ -201,8 +199,8 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
       }
 
       setMutableRef(busyRef, true)
-      setBusy(true)
-      setAwaitingResponse(true)
+      view.setBusy(true)
+      view.setAwaitingResponse(true)
       clearNotifications()
 
       let sessionId: null | string = activeSessionId
@@ -210,7 +208,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
       if (sessionId) {
         seedOptimistic(sessionId)
       } else {
-        setMessages(current => [...current, buildUserMessage()])
+        view.setMessages(current => [...current, buildUserMessage()])
       }
 
       if (!sessionId) {
@@ -283,7 +281,7 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
         }
 
         if (usingComposerAttachments) {
-          clearComposerAttachments()
+          clearComposerAttachments(view.$composerAttachments)
         }
 
         // Submit landed — the turn now runs (busy stays true), but the submit
@@ -341,7 +339,8 @@ export function useSubmitPrompt(deps: SubmitPromptDeps) {
       requestGateway,
       selectedStoredSessionIdRef,
       syncAttachmentsForSubmit,
-      updateSessionState
+      updateSessionState,
+      view
     ]
   )
 }
diff --git a/apps/desktop/src/app/session/hooks/use-route-resume.ts b/apps/desktop/src/app/session/hooks/use-route-resume.ts
index 588f614a533ff..b8aa004f7bea9 100644
--- a/apps/desktop/src/app/session/hooks/use-route-resume.ts
+++ b/apps/desktop/src/app/session/hooks/use-route-resume.ts
@@ -2,6 +2,8 @@ import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import { isNewChatRoute } from '@/app/routes'
 import { setResumeExhaustedSessionId } from '@/store/session'
+import { $activePaneId, $splitOpen, $splitPaneSession, closeSplitPane } from '@/store/split'
+import { isSecondaryWindow } from '@/store/windows'
 
 interface RouteResumeOptions {
   activeSessionId: string | null
@@ -113,6 +115,18 @@ export function useRouteResume({
     }
 
     if (routedSessionId) {
+      // Same-session-never-in-both-panes vs. the router itself: every
+      // dispatcher entry point enforces the invariant, but history navigation
+      // (Back/Forward) bypasses it and can land the URL on the session the
+      // split pane holds. The URL wins — close the split rather than
+      // double-mounting one session in two panes. Secondary windows share the
+      // persisted split state without rendering the split, so they must not
+      // clobber it. Split closed → the condition is never true (single-pane
+      // path untouched).
+      if (!isSecondaryWindow() && $splitOpen.get() && $splitPaneSession.get()?.storedId === routedSessionId) {
+        closeSplitPane()
+      }
+
       const cachedRuntime = runtimeIdByStoredSessionIdRef.current.get(routedSessionId)
 
       const alreadyActive =
@@ -153,9 +167,16 @@ export function useRouteResume({
       return
     }
 
+    // Pane gate: while the SPLIT pane is focused, the identity singletons
+    // mirror ITS session (split-mirror.ts), so a main pane sitting on a fresh
+    // /new draft would read as "left the draft" and get spuriously reset.
+    // Defer the check until the main pane is active again — the mirror
+    // teardown rewrites the id atoms, which re-runs this effect. Single-pane
+    // the active pane is always 'main', so this is inert.
     if (
       isNewChatRoute(locationPathname) &&
       !creatingSessionRef.current &&
+      $activePaneId.get() === 'main' &&
       (selectedStoredSessionId || activeSessionId || !freshDraftReady) &&
       !rawHashLooksLikeSession()
     ) {
diff --git a/apps/desktop/src/app/session/hooks/use-session-actions.split-profile.test.tsx b/apps/desktop/src/app/session/hooks/use-session-actions.split-profile.test.tsx
new file mode 100644
index 0000000000000..656d24918e652
--- /dev/null
+++ b/apps/desktop/src/app/session/hooks/use-session-actions.split-profile.test.tsx
@@ -0,0 +1,159 @@
+import { cleanup, render, waitFor } from '@testing-library/react'
+import { useEffect } from 'react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createSplitPaneView, type PaneSessionView } from '@/app/chat/pane-view'
+import type { SessionInfo } from '@/hermes'
+import { $activeSessionId, setSessions } from '@/store/session'
+import { $activePaneId } from '@/store/split'
+
+import type { ClientSessionState } from '../../types'
+
+import { useSessionActions } from './use-session-actions'
+
+// Inactive-pane profile pinning (design §4 row 3): the split pane's boot
+// restore resumes while the MAIN pane is focused, so it must open its
+// profile's socket WITHOUT stealing the active gateway swap — and the resume
+// RPC must carry the session's profile explicitly. Once the pane is ACTIVE,
+// resumes swap the gateway exactly like selecting a session does today.
+
+const ensureGatewayProfile = vi.fn<(profile: string | null | undefined) => Promise<undefined>>(async () => undefined)
+
+const ensureProfileSocketOpen = vi.fn<(profile: string | null | undefined) => Promise<never>>(
+  async () => ({}) as never
+)
+
+vi.mock('@/hermes', async importOriginal => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  getSessionMessages: vi.fn(async () => ({ messages: [] })),
+  setApiRequestProfile: vi.fn()
+}))
+
+vi.mock('@/store/profile', async importOriginal => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  ensureGatewayProfile: (profile: string | null | undefined) => ensureGatewayProfile(profile)
+}))
+
+vi.mock('@/store/gateway', async importOriginal => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  ensureProfileSocketOpen: (profile: string | null | undefined) => ensureProfileSocketOpen(profile)
+}))
+
+function storedSession(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    ended_at: null,
+    id: 'stored-split',
+    input_tokens: 0,
+    is_active: false,
+    last_active: 1,
+    message_count: 0,
+    model: null,
+    output_tokens: 0,
+    preview: null,
+    source: 'desktop',
+    started_at: 1,
+    title: 'split session',
+    tool_call_count: 0,
+    ...overrides
+  }
+}
+
+function Harness({
+  onReady,
+  requestGateway,
+  view
+}: {
+  onReady: (resume: (storedSessionId: string) => Promise<void>) => void
+  requestGateway: <T>(method: string, params?: Record<string, unknown>) => Promise<T>
+  view: PaneSessionView
+}) {
+  const actions = useSessionActions({
+    activeSessionId: null,
+    activeSessionIdRef: view.activeSessionIdRef,
+    busyRef: view.busyRef,
+    creatingSessionRef: view.creatingSessionRef,
+    ensureSessionState: () => ({}) as ClientSessionState,
+    getRouteToken: () => 'split:token',
+    navigate: vi.fn() as never,
+    requestGateway,
+    runtimeIdByStoredSessionIdRef: { current: new Map<string, string>() },
+    selectedStoredSessionId: null,
+    selectedStoredSessionIdRef: view.selectedStoredSessionIdRef,
+    sessionStateByRuntimeIdRef: { current: new Map<string, ClientSessionState>() },
+    syncSessionStateToView: vi.fn(),
+    updateSessionState: () => ({}) as ClientSessionState,
+    view
+  })
+
+  useEffect(() => {
+    onReady(actions.resumeSession)
+  }, [actions.resumeSession, onReady])
+
+  return null
+}
+
+async function resumeWith(view: PaneSessionView) {
+  const resumeParamsByCall: Record<string, unknown>[] = []
+
+  const requestGateway = vi.fn(async (method: string, params?: Record<string, unknown>) => {
+    if (method === 'session.resume') {
+      resumeParamsByCall.push(params ?? {})
+
+      return { info: {}, messages: [], session_id: 'rt-split-1' } as never
+    }
+
+    return {} as never
+  })
+
+  let resume: ((storedSessionId: string) => Promise<void>) | null = null
+  render(<Harness onReady={r => (resume = r)} requestGateway={requestGateway} view={view} />)
+  await waitFor(() => expect(resume).not.toBeNull())
+  await resume!('stored-split')
+
+  return resumeParamsByCall
+}
+
+describe('split-pane resume profile routing', () => {
+  afterEach(() => {
+    cleanup()
+    ensureGatewayProfile.mockClear()
+    ensureProfileSocketOpen.mockClear()
+    setSessions([])
+    $activePaneId.set('main')
+    $activeSessionId.set(null)
+    vi.restoreAllMocks()
+  })
+
+  it('INACTIVE split resume opens the profile socket, never the active swap, and pins the RPC profile', async () => {
+    setSessions([storedSession({ profile: 'coder' })])
+    $activePaneId.set('main')
+    const view = createSplitPaneView()
+
+    const resumeParams = await resumeWith(view)
+
+    // Background restore: socket opened for the session's profile…
+    expect(ensureProfileSocketOpen).toHaveBeenCalledWith('coder')
+    // …without moving the active gateway out from under the main pane.
+    expect(ensureGatewayProfile).not.toHaveBeenCalled()
+
+    // session.resume carries the profile explicitly (socket routing alone
+    // isn't trusted for resumes — design §4 payload rules).
+    expect(resumeParams).toHaveLength(1)
+    expect(resumeParams[0]).toMatchObject({ profile: 'coder', session_id: 'stored-split' })
+
+    // The resumed runtime id landed in the PANE's bundle, not the globals.
+    expect(view.$activeSessionId.get()).toBe('rt-split-1')
+    expect($activeSessionId.get()).toBeNull()
+  })
+
+  it('ACTIVE split resume swaps the live gateway — identical to selecting a session today', async () => {
+    setSessions([storedSession({ profile: 'coder' })])
+    $activePaneId.set('split')
+    const view = createSplitPaneView()
+
+    await resumeWith(view)
+
+    expect(ensureGatewayProfile).toHaveBeenCalledWith('coder')
+    expect(ensureProfileSocketOpen).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/index.ts b/apps/desktop/src/app/session/hooks/use-session-actions/index.ts
index 0f88fc9481003..5c9a3ae289487 100644
--- a/apps/desktop/src/app/session/hooks/use-session-actions/index.ts
+++ b/apps/desktop/src/app/session/hooks/use-session-actions/index.ts
@@ -7,44 +7,24 @@ import { useI18n } from '@/i18n'
 import { preserveLocalAssistantErrors, toChatMessages } from '@/lib/chat-messages'
 import { setSessionYolo } from '@/lib/yolo-session'
 import { clearQueuedPrompts } from '@/store/composer-queue'
+import { ensureProfileSocketOpen } from '@/store/gateway'
 import { $pinnedSessionIds } from '@/store/layout'
 import { clearNotifications, notify, notifyError } from '@/store/notifications'
 import { $activeGatewayProfile, $newChatProfile, ensureGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import { resolveNewSessionCwd, tombstoneSessions, untombstoneSessions } from '@/store/projects'
 import {
-  $currentCwd,
-  $currentFastMode,
-  $currentModel,
-  $currentProvider,
-  $currentReasoningEffort,
-  $messages,
   $sessions,
-  $yoloActive,
   sessionPinId,
-  setActiveSessionId,
-  setAwaitingResponse,
-  setBusy,
-  setCurrentBranch,
-  setCurrentCwd,
-  setCurrentServiceTier,
-  setCurrentUsage,
-  setFreshDraftReady,
   setIntroSeed,
-  setMessages,
-  setResumeExhaustedSessionId,
-  setResumeFailedSessionId,
-  setSelectedStoredSessionId,
   setSessions,
-  setSessionStartedAt,
   setSessionsTotal,
-  setTurnStartedAt,
-  setYoloActive,
   workspaceCwdForNewSession
 } from '@/store/session'
 import { broadcastSessionsChanged } from '@/store/session-sync'
 import { isWatchWindow } from '@/store/windows'
 import type { SessionCreateResponse, SessionResumeResponse, UsageStats } from '@/types/hermes'
 
+import { MAIN_PANE_VIEW, type PaneSessionView } from '../../../chat/pane-view'
 import { NEW_CHAT_ROUTE, sessionRoute, SETTINGS_ROUTE } from '../../../routes'
 import type { ClientSessionState, SidebarNavItem } from '../../../types'
 
@@ -82,6 +62,10 @@ interface SessionActionsOptions {
     updater: (state: ClientSessionState) => ClientSessionState,
     storedSessionId?: string | null
   ) => ClientSessionState
+  /** The pane view this instance drives. Defaults to the main bundle — i.e.
+   *  the pre-split global atoms — so every existing caller is unchanged; the
+   *  split pane passes its own factory-created bundle. */
+  view?: PaneSessionView
 }
 
 export function useSessionActions({
@@ -98,50 +82,91 @@ export function useSessionActions({
   selectedStoredSessionIdRef,
   sessionStateByRuntimeIdRef,
   syncSessionStateToView,
-  updateSessionState
+  updateSessionState,
+  view = MAIN_PANE_VIEW
 }: SessionActionsOptions) {
   const { t } = useI18n()
   const copy = t.desktop
   const resumeRequestRef = useRef(0)
 
+  // Pane-aware navigation: the main pane routes through the URL — byte-for-byte
+  // the pre-split path — while the split pane swaps its pane-local session
+  // pointer (the URL stays the main pane's).
+  const navigateToSession = useCallback(
+    (storedId: string, replace = false) => {
+      if (view.paneId === 'main') {
+        navigate(sessionRoute(storedId), { replace })
+      } else {
+        view.navigateToSession(storedId, replace)
+      }
+    },
+    [navigate, view]
+  )
+
+  const navigateToNewChat = useCallback(
+    (replace = false) => {
+      if (view.paneId === 'main') {
+        navigate(NEW_CHAT_ROUTE, { replace })
+      } else {
+        view.navigateToNewChat(replace)
+      }
+    },
+    [navigate, view]
+  )
+
+  // Profile hook for gateway-bound work: the ACTIVE pane swaps the live gateway
+  // (exactly what selecting a session does today); a background pane only makes
+  // sure its profile's socket is open, so e.g. the split's boot restore can
+  // never steal the active gateway from the pane the user is typing in.
+  const ensurePaneGatewayProfile = useCallback(
+    async (profile: string | null | undefined) => {
+      if (view.isActive()) {
+        await ensureGatewayProfile(profile)
+      } else {
+        await ensureProfileSocketOpen(profile)
+      }
+    },
+    [view]
+  )
+
   const startFreshSessionDraft = useCallback(
     (replaceRoute = false) => {
       busyRef.current = false
-      setBusy(false)
-      setAwaitingResponse(false)
+      view.setBusy(false)
+      view.setAwaitingResponse(false)
       clearNotifications()
       setIntroSeed(seed => seed + 1)
-      navigate(NEW_CHAT_ROUTE, { replace: replaceRoute })
-      setActiveSessionId(null)
+      navigateToNewChat(replaceRoute)
+      view.setActiveSessionId(null)
       activeSessionIdRef.current = null
-      setSelectedStoredSessionId(null)
+      view.setSelectedStoredSessionId(null)
       selectedStoredSessionIdRef.current = null
-      setMessages([])
-      setCurrentUsage({
+      view.setMessages([])
+      view.setCurrentUsage({
         calls: 0,
         input: 0,
         output: 0,
         total: 0
       })
-      setSessionStartedAt(null)
-      setTurnStartedAt(null)
+      view.setSessionStartedAt(null)
+      view.setTurnStartedAt(null)
       // The composer's model/effort/fast is sticky UI state (persisted in
       // localStorage) — a new chat FOLLOWS your last pick instead of snapping
       // back to the profile default, so we deliberately don't reset it here. The
       // profile default still owns first-run seeding and profile switches (see
       // refreshCurrentModel). Only $currentServiceTier (a live-session mirror)
       // is cleared.
-      setCurrentServiceTier('')
-      setYoloActive(false)
+      view.setCurrentServiceTier('')
+      view.setYoloActive(false)
       // In a project → the repo's default-branch (main worktree) checkout; not in
       // a project → detached. So cmd-n "knows" the project instead of inheriting
       // whatever linked worktree the last session drifted into.
-      setCurrentCwd(resolveNewSessionCwd())
-      setCurrentBranch('')
+      view.setCurrentCwd(resolveNewSessionCwd())
+      view.setCurrentBranch('')
       // Never clear the composer here — ChatBar's per-thread draft swap owns it.
-      setFreshDraftReady(true)
+      view.setFreshDraftReady(true)
     },
-    [activeSessionIdRef, busyRef, navigate, selectedStoredSessionIdRef]
+    [activeSessionIdRef, busyRef, navigateToNewChat, selectedStoredSessionIdRef, view]
   )
 
   const createBackendSessionForSend = useCallback(
@@ -162,17 +187,17 @@ export function useSessionActions({
         // default" bug. This is a no-op for single-profile/local-pooled users:
         // a backend resolves its own launch profile to None (_profile_home).
         const newChatProfile = $newChatProfile.get() ?? normalizeProfileKey($activeGatewayProfile.get())
-        await ensureGatewayProfile(newChatProfile)
-        const cwd = $currentCwd.get().trim() || workspaceCwdForNewSession()
+        await ensurePaneGatewayProfile(newChatProfile)
+        const cwd = view.$currentCwd.get().trim() || workspaceCwdForNewSession()
         // The composer's model/effort/fast is sticky UI state ($currentModel,
         // $currentProvider, $currentReasoningEffort, $currentFastMode). Ship it
         // with every session.create so the new chat opens on whatever the picker
         // shows — applied as per-session overrides, never written to the profile
         // default (that lives in Settings → Model).
-        const uiModel = $currentModel.get().trim()
-        const uiProvider = $currentProvider.get().trim()
-        const uiEffort = $currentReasoningEffort.get().trim()
-        const uiFast = $currentFastMode.get()
+        const uiModel = view.$currentModel.get().trim()
+        const uiProvider = view.$currentProvider.get().trim()
+        const uiEffort = view.$currentReasoningEffort.get().trim()
+        const uiFast = view.$currentFastMode.get()
 
         const created = await requestGateway<SessionCreateResponse>('session.create', {
           cols: 96,
@@ -205,17 +230,17 @@ export function useSessionActions({
           // "Untitled session" until the turn persists and auto-title runs. The
           // server later returns its own preview/title and supersedes this.
           upsertOptimisticSession(created, stored, null, preview?.trim() || null)
-          navigate(sessionRoute(stored), { replace: true })
+          navigateToSession(stored, true)
           // Other windows (e.g. the main window when this is the pop-out) can't
           // see this session until they re-pull the shared list.
           broadcastSessionsChanged()
         }
 
-        setFreshDraftReady(false)
-        setActiveSessionId(created.session_id)
-        setSelectedStoredSessionId(stored)
-        setSessionStartedAt(Date.now())
-        const yoloArmed = $yoloActive.get()
+        view.setFreshDraftReady(false)
+        view.setActiveSessionId(created.session_id)
+        view.setSelectedStoredSessionId(stored)
+        view.setSessionStartedAt(Date.now())
+        const yoloArmed = view.$yoloActive.get()
         const runtimeInfo = applyRuntimeInfo(created.info)
 
         if (runtimeInfo) {
@@ -238,12 +263,14 @@ export function useSessionActions({
     [
       activeSessionIdRef,
       creatingSessionRef,
+      ensurePaneGatewayProfile,
       ensureSessionState,
       getRouteToken,
-      navigate,
+      navigateToSession,
       requestGateway,
       selectedStoredSessionIdRef,
-      updateSessionState
+      updateSessionState,
+      view
     ]
   )
 
@@ -292,19 +319,19 @@ export function useSessionActions({
       // the cached fast-path repaints it this same tick. Setting the ref here is
       // also what use-route-resume's self-heal assumes ("set synchronously at
       // resume entry").
-      setFreshDraftReady(false)
+      view.setFreshDraftReady(false)
       clearNotifications()
-      setSelectedStoredSessionId(storedSessionId)
+      view.setSelectedStoredSessionId(storedSessionId)
       selectedStoredSessionIdRef.current = storedSessionId
       // Optimistically clear any prior resume-failure latch for this session:
       // we're attempting a fresh resume, so the self-heal in use-route-resume
       // must not keep treating it as stranded. It's re-armed below only if THIS
       // attempt fails terminally (RPC reject + REST fallback failure).
-      setResumeFailedSessionId(current => (current === storedSessionId ? null : current))
+      view.setResumeFailedSessionId(current => (current === storedSessionId ? null : current))
       // Also clear the exhausted-latch: a fresh attempt (manual Retry, reconnect,
       // reselect) gives the bounded auto-retry counter a clean cycle, so the
       // chat view drops the error state and shows the loader again.
-      setResumeExhaustedSessionId(current => (current === storedSessionId ? null : current))
+      view.setResumeExhaustedSessionId(current => (current === storedSessionId ? null : current))
 
       // A warm cache entry is only trustworthy when it still BELONGS to the
       // session being resumed. A pooled profile backend that gets idle-reaped
@@ -334,13 +361,15 @@ export function useSessionActions({
       }
 
       if (!takeWarmCache()) {
-        setActiveSessionId(null)
+        view.setActiveSessionId(null)
         activeSessionIdRef.current = null
-        setMessages([])
+        view.setMessages([])
       }
 
       // Swap the single live gateway to this session's profile before any
       // gateway call (no-op when it's already on that profile / single-profile).
+      // An INACTIVE pane (split boot restore) only opens its profile's socket
+      // instead, so it can't steal the active gateway mid-interaction.
       // resolveStoredSession finds the row by id (cheap), so an uncached pasted
       // id loads as fast as a sidebar click instead of hanging on a list scan.
       const storedForProfile = await resolveStoredSession(storedSessionId)
@@ -350,7 +379,7 @@ export function useSessionActions({
         return
       }
 
-      await ensureGatewayProfile(sessionProfile)
+      await ensurePaneGatewayProfile(sessionProfile)
 
       // Re-check after the profile-resolve / gateway-swap awaits above: the
       // cache may have changed, and takeWarmCache re-validates belongs-to and
@@ -380,16 +409,16 @@ export function useSessionActions({
           runtimeIdByStoredSessionIdRef.current.delete(storedSessionId)
           sessionStateByRuntimeIdRef.current.delete(cachedRuntimeId)
         } else {
-          setFreshDraftReady(false)
+          view.setFreshDraftReady(false)
           clearNotifications()
-          setSelectedStoredSessionId(storedSessionId)
+          view.setSelectedStoredSessionId(storedSessionId)
           selectedStoredSessionIdRef.current = storedSessionId
-          setActiveSessionId(cachedRuntimeId)
+          view.setActiveSessionId(cachedRuntimeId)
           activeSessionIdRef.current = cachedRuntimeId
           syncSessionStateToView(cachedRuntimeId, cachedViewState)
-          setCurrentCwd(cachedViewState.cwd)
-          setCurrentBranch(cachedViewState.branch)
-          setSessionStartedAt(Date.now())
+          view.setCurrentCwd(cachedViewState.cwd)
+          view.setCurrentBranch(cachedViewState.branch)
+          view.setSessionStartedAt(Date.now())
 
           try {
             const usage = await requestGateway<UsageStats>('session.usage', { session_id: cachedRuntimeId })
@@ -399,7 +428,7 @@ export function useSessionActions({
             }
 
             if (usage) {
-              setCurrentUsage(current => ({ ...current, ...usage }))
+              view.setCurrentUsage(current => ({ ...current, ...usage }))
             }
 
             return
@@ -419,24 +448,24 @@ export function useSessionActions({
         }
       }
 
-      setFreshDraftReady(false)
-      setActiveSessionId(null)
+      view.setFreshDraftReady(false)
+      view.setActiveSessionId(null)
       activeSessionIdRef.current = null
       busyRef.current = true
-      setBusy(true)
-      setAwaitingResponse(false)
+      view.setBusy(true)
+      view.setAwaitingResponse(false)
       clearNotifications()
-      setSelectedStoredSessionId(storedSessionId)
+      view.setSelectedStoredSessionId(storedSessionId)
       selectedStoredSessionIdRef.current = storedSessionId
-      setSessionStartedAt(Date.now())
+      view.setSessionStartedAt(Date.now())
 
       const stored =
         $sessions.get().find(session => sessionMatchesStoredId(session, storedSessionId)) ?? storedForProfile
 
-      applyStoredSessionPreviewRuntimeInfo(stored)
+      applyStoredSessionPreviewRuntimeInfo(stored, view)
 
       if (stored) {
-        setCurrentUsage(current => ({
+        view.setCurrentUsage(current => ({
           ...current,
           input: stored.input_tokens || 0,
           output: stored.output_tokens || 0,
@@ -448,7 +477,7 @@ export function useSessionActions({
 
       try {
         const watchWindow = isWatchWindow()
-        let localSnapshot = $messages.get()
+        let localSnapshot = view.$messages.get()
 
         // REST transcript prefetch and the gateway resume RPC are independent
         // — run them concurrently so a big session's wall time is
@@ -478,10 +507,13 @@ export function useSessionActions({
             const storedMessages = await prefetchPromise
 
             if (isCurrentResume()) {
-              localSnapshot = preserveLocalAssistantErrors(toChatMessages(storedMessages.messages), $messages.get())
+              localSnapshot = preserveLocalAssistantErrors(
+                toChatMessages(storedMessages.messages),
+                view.$messages.get()
+              )
 
-              if (!chatMessageArraysEquivalent($messages.get(), localSnapshot)) {
-                setMessages(localSnapshot)
+              if (!chatMessageArraysEquivalent(view.$messages.get(), localSnapshot)) {
+                view.setMessages(localSnapshot)
               }
             }
           }
@@ -495,7 +527,7 @@ export function useSessionActions({
           return
         }
 
-        const currentMessages = $messages.get()
+        const currentMessages = view.$messages.get()
 
         // Keep the local snapshot when resume would only reshuffle runtime
         // projection. When the REST prefetch already hydrated the transcript,
@@ -523,17 +555,17 @@ export function useSessionActions({
             : preserveLocalAssistantErrors(preferredMessages, currentMessages)
 
         if (sessionShouldHaveTranscript(stored) && messagesForView.length === 0) {
-          setActiveSessionId(null)
+          view.setActiveSessionId(null)
           activeSessionIdRef.current = null
-          setResumeFailedSessionId(storedSessionId)
+          view.setResumeFailedSessionId(storedSessionId)
           resumedRunning = false
 
           return
         }
 
-        setActiveSessionId(resumed.session_id)
+        view.setActiveSessionId(resumed.session_id)
         activeSessionIdRef.current = resumed.session_id
-        const runtimeInfo = applyRuntimeInfo(resumed.info)
+        const runtimeInfo = applyRuntimeInfo(resumed.info, view)
 
         patchSessionWorkspace(storedSessionId, runtimeInfo?.cwd)
 
@@ -572,7 +604,7 @@ export function useSessionActions({
             return
           }
 
-          setMessages(preserveLocalAssistantErrors(toChatMessages(fallback.messages), $messages.get()))
+          view.setMessages(preserveLocalAssistantErrors(toChatMessages(fallback.messages), view.$messages.get()))
         } catch (e) {
           // Fallback also failed: nothing to paint. Leave whatever messages are
           // already shown and fall through to arm the resume-failure latch so
@@ -591,13 +623,13 @@ export function useSessionActions({
         // instead of toasting an error and hot-looping the bounded retry on a
         // permanently-dead id. (Booting straight into a no-longer-existent
         // last-session id is the common trigger.)
-        if ($messages.get().length === 0 && isSessionGoneError(fallbackError)) {
+        if (view.$messages.get().length === 0 && isSessionGoneError(fallbackError)) {
           startFreshSessionDraft(true)
 
           return
         }
 
-        if ($messages.get().length === 0) {
+        if (view.$messages.get().length === 0) {
           // Arm the self-heal ONLY when the window is still empty: the gateway
           // resume rejected AND the REST fallback failed to paint a transcript.
           // That is the exact stranded state the loader latches on
@@ -606,15 +638,15 @@ export function useSessionActions({
           // window is readable — arming here would needlessly auto-retry and,
           // once retries exhaust, blank that visible transcript behind the
           // exhausted-state error overlay (a regression vs. plain fallback success).
-          setResumeFailedSessionId(storedSessionId)
+          view.setResumeFailedSessionId(storedSessionId)
         }
 
         notifyError(err, copy.resumeFailed)
       } finally {
         if (isCurrentResume()) {
           busyRef.current = resumedRunning
-          setBusy(resumedRunning)
-          setAwaitingResponse(resumedRunning)
+          view.setBusy(resumedRunning)
+          view.setAwaitingResponse(resumedRunning)
         }
       }
     },
@@ -622,13 +654,15 @@ export function useSessionActions({
       activeSessionIdRef,
       busyRef,
       copy,
+      ensurePaneGatewayProfile,
       requestGateway,
       runtimeIdByStoredSessionIdRef,
       selectedStoredSessionIdRef,
       sessionStateByRuntimeIdRef,
       startFreshSessionDraft,
       syncSessionStateToView,
-      updateSessionState
+      updateSessionState,
+      view
     ]
   )
 
@@ -659,7 +693,7 @@ export function useSessionActions({
           ? rows.filter(session => session.parent_session_id?.trim() === parentStoredId).length
           : 0
 
-        setFreshDraftReady(false)
+        view.setFreshDraftReady(false)
         upsertOptimisticSession(
           branched,
           routedSessionId,
@@ -669,7 +703,7 @@ export function useSessionActions({
           parent ? parent.last_active || parent.started_at : undefined
         )
         ensureSessionState(branched.session_id, routedSessionId)
-        setActiveSessionId(branched.session_id)
+        view.setActiveSessionId(branched.session_id)
         activeSessionIdRef.current = branched.session_id
         updateSessionState(
           branched.session_id,
@@ -681,11 +715,11 @@ export function useSessionActions({
           }),
           routedSessionId
         )
-        setSelectedStoredSessionId(routedSessionId)
+        view.setSelectedStoredSessionId(routedSessionId)
         selectedStoredSessionIdRef.current = routedSessionId
-        navigate(sessionRoute(routedSessionId))
+        navigateToSession(routedSessionId)
 
-        const runtimeInfo = applyRuntimeInfo(branched.info)
+        const runtimeInfo = applyRuntimeInfo(branched.info, view)
         patchSessionWorkspace(routedSessionId, runtimeInfo?.cwd)
 
         if (runtimeInfo) {
@@ -708,10 +742,11 @@ export function useSessionActions({
       copy,
       creatingSessionRef,
       ensureSessionState,
-      navigate,
+      navigateToSession,
       requestGateway,
       selectedStoredSessionIdRef,
-      updateSessionState
+      updateSessionState,
+      view
     ]
   )
 
@@ -730,7 +765,7 @@ export function useSessionActions({
         return false
       }
 
-      const messages = $messages.get()
+      const messages = view.$messages.get()
 
       const at = messageId
         ? messages.findIndex(message => message.id === messageId)
@@ -748,9 +783,9 @@ export function useSessionActions({
 
       clearNotifications()
 
-      return forkBranch(branchMessages, selectedStoredSessionIdRef.current, $currentCwd.get().trim())
+      return forkBranch(branchMessages, selectedStoredSessionIdRef.current, view.$currentCwd.get().trim())
     },
-    [activeSessionIdRef, busyRef, copy, forkBranch, selectedStoredSessionIdRef]
+    [activeSessionIdRef, busyRef, copy, forkBranch, selectedStoredSessionIdRef, view]
   )
 
   // Branch any listed session, not just the open one. Reads the target's stored
@@ -791,7 +826,7 @@ export function useSessionActions({
       const removed = $sessions.get().find(session => sessionMatchesStoredId(session, storedSessionId))
       const wasSelected = selectedStoredSessionId === storedSessionId
       const closingRuntimeId = wasSelected ? activeSessionId : null
-      const previousMessages = $messages.get()
+      const previousMessages = view.$messages.get()
       const previousPinned = $pinnedSessionIds.get()
       // Pins are keyed on the durable lineage-root id; the stored id may be the
       // live tip after compression. Drop both so the pin can't linger.
@@ -834,13 +869,13 @@ export function useSessionActions({
         $pinnedSessionIds.set(previousPinned)
 
         if (wasSelected) {
-          setFreshDraftReady(false)
-          setSelectedStoredSessionId(storedSessionId)
+          view.setFreshDraftReady(false)
+          view.setSelectedStoredSessionId(storedSessionId)
           selectedStoredSessionIdRef.current = storedSessionId
           const stored = $sessions.get().find(session => sessionMatchesStoredId(session, storedSessionId))
 
           if (stored) {
-            setCurrentUsage(current => ({
+            view.setCurrentUsage(current => ({
               ...current,
               input: stored.input_tokens || 0,
               output: stored.output_tokens || 0,
@@ -848,11 +883,11 @@ export function useSessionActions({
             }))
           }
 
-          setMessages(previousMessages)
-          navigate(sessionRoute(storedSessionId), { replace: true })
+          view.setMessages(previousMessages)
+          navigateToSession(storedSessionId, true)
 
           if (closingRuntimeId) {
-            setActiveSessionId(closingRuntimeId)
+            view.setActiveSessionId(closingRuntimeId)
             activeSessionIdRef.current = closingRuntimeId
           }
         }
@@ -864,11 +899,12 @@ export function useSessionActions({
       activeSessionId,
       activeSessionIdRef,
       copy,
-      navigate,
+      navigateToSession,
       requestGateway,
       selectedStoredSessionId,
       selectedStoredSessionIdRef,
-      startFreshSessionDraft
+      startFreshSessionDraft,
+      view
     ]
   )
 
diff --git a/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts b/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts
index 254a58e1298a5..ceea8425a834c 100644
--- a/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts
+++ b/apps/desktop/src/app/session/hooks/use-session-actions/utils.ts
@@ -4,24 +4,11 @@ import { normalizePersonalityValue } from '@/lib/chat-runtime'
 import { embeddedImageUrls, textWithoutEmbeddedImages } from '@/lib/embedded-images'
 import { requestDesktopOnboarding } from '@/store/onboarding'
 import { $activeGatewayProfile, $profiles, normalizeProfileKey } from '@/store/profile'
-import {
-  $currentCwd,
-  $sessions,
-  setCurrentBranch,
-  setCurrentCwd,
-  setCurrentFastMode,
-  setCurrentModel,
-  setCurrentPersonality,
-  setCurrentProvider,
-  setCurrentReasoningEffort,
-  setCurrentServiceTier,
-  setCurrentUsage,
-  setSessions,
-  setYoloActive
-} from '@/store/session'
+import { $currentCwd, $sessions, setSessions } from '@/store/session'
 import { reportBackendContract } from '@/store/updates'
 import type { SessionCreateResponse, SessionInfo, SessionRuntimeInfo } from '@/types/hermes'
 
+import { MAIN_PANE_VIEW, type PaneSessionView } from '../../../chat/pane-view'
 import type { ClientSessionState } from '../../../types'
 
 function withAppendedText(message: ChatMessage, suffix: string): ChatMessage {
@@ -190,7 +177,10 @@ export function sessionShouldHaveTranscript(session: SessionInfo | undefined): b
   return (session?.message_count ?? 0) > 0
 }
 
-function upsertResolvedSession(session: SessionInfo, storedSessionId: string) {
+// Exported for the split pane's tagged boot probe (split-pane.tsx), which
+// fetches the row with an EXPLICIT profile and must land it in $sessions the
+// same way resolveStoredSession does, so the follow-up resume finds it cached.
+export function upsertResolvedSession(session: SessionInfo, storedSessionId: string) {
   const lineage = session._lineage_root_id ?? session.id
 
   setSessions(prev => [
@@ -257,7 +247,13 @@ type SessionRuntimeStatePatch = Partial<
   >
 >
 
-export function applyRuntimeInfo(info: SessionRuntimeInfo | undefined): SessionRuntimeStatePatch | null {
+// Both projections below write the CALLING pane's view bundle. The default is
+// the main bundle — the exact global setters this file imported pre-split — so
+// existing callers are byte-identical; the split pane passes its own view.
+export function applyRuntimeInfo(
+  info: SessionRuntimeInfo | undefined,
+  view: PaneSessionView = MAIN_PANE_VIEW
+): SessionRuntimeStatePatch | null {
   if (!info) {
     return null
   }
@@ -271,66 +267,69 @@ export function applyRuntimeInfo(info: SessionRuntimeInfo | undefined): SessionR
   }
 
   if (typeof info.model === 'string') {
-    setCurrentModel(info.model)
+    view.setCurrentModel(info.model)
     sessionState.model = info.model
   }
 
   if (typeof info.provider === 'string') {
-    setCurrentProvider(info.provider)
+    view.setCurrentProvider(info.provider)
     sessionState.provider = info.provider
   }
 
   if (info.cwd) {
-    setCurrentCwd(info.cwd)
+    view.setCurrentCwd(info.cwd)
     sessionState.cwd = info.cwd
   }
 
   if (info.branch !== undefined) {
-    setCurrentBranch(info.branch || '')
+    view.setCurrentBranch(info.branch || '')
     sessionState.branch = info.branch || ''
   }
 
   if (typeof info.personality === 'string') {
     const personality = normalizePersonalityValue(info.personality)
-    setCurrentPersonality(personality)
+    view.setCurrentPersonality(personality)
     sessionState.personality = personality
   }
 
   if (typeof info.reasoning_effort === 'string') {
-    setCurrentReasoningEffort(info.reasoning_effort)
+    view.setCurrentReasoningEffort(info.reasoning_effort)
     sessionState.reasoningEffort = info.reasoning_effort
   }
 
   if (typeof info.service_tier === 'string') {
-    setCurrentServiceTier(info.service_tier)
+    view.setCurrentServiceTier(info.service_tier)
     sessionState.serviceTier = info.service_tier
   }
 
   if (typeof info.fast === 'boolean') {
-    setCurrentFastMode(info.fast)
+    view.setCurrentFastMode(info.fast)
     sessionState.fast = info.fast
   }
 
   if (typeof info.yolo === 'boolean') {
-    setYoloActive(info.yolo)
+    view.setYoloActive(info.yolo)
     sessionState.yolo = info.yolo
   }
 
   if (info.usage) {
-    setCurrentUsage(current => ({ ...current, ...info.usage }))
+    view.setCurrentUsage(current => ({ ...current, ...info.usage }))
   }
 
   return sessionState
 }
 
-export function applyStoredSessionPreviewRuntimeInfo(stored: { model?: null | string } | undefined) {
-  setCurrentModel(stored?.model || '')
-  setCurrentProvider('')
-  setCurrentReasoningEffort('')
-  setCurrentServiceTier('')
-  setCurrentFastMode(false)
-  setYoloActive(false)
-  setCurrentPersonality('')
+export function applyStoredSessionPreviewRuntimeInfo(
+  stored: { model?: null | string } | undefined,
+  view: PaneSessionView = MAIN_PANE_VIEW
+) {
+  view.setCurrentModel(stored?.model || '')
+  view.setCurrentProvider('')
+  view.setCurrentReasoningEffort('')
+  view.setCurrentServiceTier('')
+  view.setCurrentFastMode(false)
+  view.setYoloActive(false)
+  view.setCurrentPersonality('')
 }
 
 // A "session genuinely doesn't exist" failure (deleted, or an id from a wiped /
diff --git a/apps/desktop/src/app/session/hooks/use-session-state-cache.fanout.test.tsx b/apps/desktop/src/app/session/hooks/use-session-state-cache.fanout.test.tsx
new file mode 100644
index 0000000000000..50d8be3bfd21d
--- /dev/null
+++ b/apps/desktop/src/app/session/hooks/use-session-state-cache.fanout.test.tsx
@@ -0,0 +1,235 @@
+import { act, cleanup, render } from '@testing-library/react'
+import type { MutableRefObject } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { createSplitPaneView, type PaneSessionView } from '@/app/chat/pane-view'
+import type { ChatMessage } from '@/lib/chat-messages'
+import { $currentModel, $messages, $turnStartedAt, setCurrentModel, setTurnStartedAt } from '@/store/session'
+
+import { useSessionStateCache } from './use-session-state-cache'
+
+// Multi-view fan-out: the cache projects each session's truth into EVERY
+// registered pane view whose gate matches — the split pane's bundle next to
+// the main (options-built) view — without the panes bleeding into each other.
+
+type Cache = ReturnType<typeof useSessionStateCache>
+
+interface HarnessProps {
+  activeSessionId: string | null
+  onReady: (cache: Cache) => void
+}
+
+function Harness({ activeSessionId, onReady }: HarnessProps) {
+  const busyRef: MutableRefObject<boolean> = { current: false }
+
+  const cache = useSessionStateCache({
+    activeSessionId,
+    busyRef,
+    selectedStoredSessionId: null,
+    setAwaitingResponse: () => undefined,
+    setBusy: () => undefined,
+    // Wire the published main view back into the real $messages atom so the
+    // main-pane round-trip matches production.
+    setMessages: messages => $messages.set(messages)
+  })
+
+  onReady(cache)
+
+  return null
+}
+
+function userMessage(id: string, text: string): ChatMessage {
+  return { id, role: 'user', parts: [{ type: 'text', text }] }
+}
+
+function assistantText(id: string, text: string): ChatMessage {
+  return { id, role: 'assistant', parts: [{ type: 'text', text }] }
+}
+
+describe('useSessionStateCache — multi-view fan-out', () => {
+  let splitView: PaneSessionView
+
+  beforeEach(() => {
+    // Synchronous rAF (returning null) mirrors the single-view suite's stub —
+    // see use-session-state-cache.test.tsx for why null is load-bearing.
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb: FrameRequestCallback) => {
+      cb(0)
+
+      return null as unknown as number
+    })
+
+    splitView = createSplitPaneView()
+    splitView.activeSessionIdRef.current = 'rt-split'
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+    $messages.set([])
+    setCurrentModel('')
+    setTurnStartedAt(null)
+  })
+
+  it("routes a session's update to the registered pane viewing it — and only there", () => {
+    let cache!: Cache
+    render(<Harness activeSessionId="rt-main" onReady={c => (cache = c)} />)
+
+    const off = cache.registerPaneView(splitView)
+
+    act(() => {
+      cache.updateSessionState(
+        'rt-split',
+        state => ({
+          ...state,
+          busy: true,
+          messages: [userMessage('m1', 'hi from the split')],
+          model: 'model-x',
+          turnStartedAt: 1_700_000_000_000
+        }),
+        'stored-split'
+      )
+    })
+
+    // The split bundle received the projection...
+    expect(splitView.$messages.get().map(message => message.id)).toEqual(['m1'])
+    expect(splitView.$busy.get()).toBe(true)
+    expect(splitView.$currentModel.get()).toBe('model-x')
+    expect(splitView.$turnStartedAt.get()).toBe(1_700_000_000_000)
+    expect(splitView.busyRef.current).toBe(true)
+    // ...and the main/global view stayed untouched: no transcript bleed, no
+    // statusbar metadata or turn-clock crosstalk.
+    expect($messages.get()).toEqual([])
+    expect($currentModel.get()).toBe('')
+    expect($turnStartedAt.get()).toBeNull()
+
+    off()
+  })
+
+  it('keeps the main single-view path intact while a second view is registered', () => {
+    let cache!: Cache
+    render(<Harness activeSessionId="rt-main" onReady={c => (cache = c)} />)
+
+    const off = cache.registerPaneView(splitView)
+
+    act(() => {
+      cache.updateSessionState(
+        'rt-main',
+        state => ({ ...state, busy: false, messages: [userMessage('u1', 'hello main')] }),
+        'stored-main'
+      )
+    })
+
+    expect($messages.get().map(message => message.id)).toEqual(['u1'])
+    expect(splitView.$messages.get()).toEqual([])
+
+    off()
+  })
+
+  it('flushes a critical transition synchronously per pane even when rAF never fires', () => {
+    // Electron parks rAF for occluded windows; the settle edge must not wait.
+    vi.mocked(window.requestAnimationFrame).mockImplementation(() => 42)
+
+    let cache!: Cache
+    render(<Harness activeSessionId="rt-main" onReady={c => (cache = c)} />)
+
+    const off = cache.registerPaneView(splitView)
+
+    act(() => {
+      cache.updateSessionState(
+        'rt-split',
+        state => ({ ...state, busy: true, messages: [userMessage('m1', 'streaming…')] }),
+        'stored-split'
+      )
+    })
+
+    // Plain busy heartbeat stays rAF-batched → still staged, not visible.
+    expect(splitView.$messages.get()).toEqual([])
+
+    act(() => {
+      cache.updateSessionState('rt-split', state => ({
+        ...state,
+        busy: false,
+        messages: [userMessage('m1', 'streaming…'), assistantText('a1', 'done')]
+      }))
+    })
+
+    // busy→false is a critical transition → synchronous flush, no rAF needed.
+    expect(splitView.$messages.get().map(message => message.id)).toEqual(['m1', 'a1'])
+    expect(splitView.$busy.get()).toBe(false)
+
+    off()
+  })
+
+  it('unregistering a pane view stops its publishes (session keeps caching as background truth)', () => {
+    let cache!: Cache
+    render(<Harness activeSessionId="rt-main" onReady={c => (cache = c)} />)
+
+    const off = cache.registerPaneView(splitView)
+
+    act(() => {
+      cache.updateSessionState(
+        'rt-split',
+        state => ({ ...state, busy: false, messages: [userMessage('m1', 'first')] }),
+        'stored-split'
+      )
+    })
+
+    expect(splitView.$messages.get().map(message => message.id)).toEqual(['m1'])
+
+    off()
+
+    act(() => {
+      cache.updateSessionState('rt-split', state => ({
+        ...state,
+        busy: false,
+        messages: [userMessage('m1', 'first'), assistantText('a1', 'late reply')]
+      }))
+    })
+
+    // View frozen at unregister time; the truth layer still advanced.
+    expect(splitView.$messages.get().map(message => message.id)).toEqual(['m1'])
+    expect(cache.sessionStateByRuntimeIdRef.current.get('rt-split')?.messages.map(m => m.id)).toEqual(['m1', 'a1'])
+  })
+
+  it('publishPaneState repaints a pane synchronously from the cached truth (warm activation)', () => {
+    let cache!: Cache
+    render(<Harness activeSessionId="rt-main" onReady={c => (cache = c)} />)
+
+    const off = cache.registerPaneView(splitView)
+
+    // Truth accrues while the split pane is NOT viewing the session — the
+    // staging gate must hold it back.
+    splitView.activeSessionIdRef.current = null
+
+    act(() => {
+      cache.updateSessionState(
+        'rt-split',
+        state => ({ ...state, busy: false, messages: [userMessage('m1', 'hello')], model: 'cached-model' }),
+        'stored-split'
+      )
+    })
+
+    expect(splitView.$messages.get()).toEqual([])
+
+    // The pane switches onto the session → warm repaint from cache.
+    splitView.activeSessionIdRef.current = 'rt-split'
+
+    act(() => {
+      cache.publishPaneState('split')
+    })
+
+    expect(splitView.$messages.get().map(message => message.id)).toEqual(['m1'])
+    expect(splitView.$currentModel.get()).toBe('cached-model')
+
+    // No-ops: unknown pane, or a pane with no cached session.
+    splitView.activeSessionIdRef.current = 'rt-unknown'
+
+    act(() => {
+      cache.publishPaneState('split')
+    })
+
+    expect(splitView.$messages.get().map(message => message.id)).toEqual(['m1'])
+
+    off()
+  })
+})
diff --git a/apps/desktop/src/app/session/hooks/use-session-state-cache.ts b/apps/desktop/src/app/session/hooks/use-session-state-cache.ts
index 3f8e02c8ca8a2..3a1381efd2b8d 100644
--- a/apps/desktop/src/app/session/hooks/use-session-state-cache.ts
+++ b/apps/desktop/src/app/session/hooks/use-session-state-cache.ts
@@ -21,6 +21,7 @@ import {
   setTurnStartedAt,
   setYoloActive
 } from '@/store/session'
+import type { PaneId } from '@/store/split'
 
 import type { ClientSessionState } from '../../types'
 
@@ -55,14 +56,51 @@ interface SessionStateCacheOptions {
   setMessages: (messages: ChatMessage[]) => void
 }
 
-function syncRuntimeMetadataToView(state: ClientSessionState) {
-  setCurrentModel(state.model ?? '')
-  setCurrentProvider(state.provider ?? '')
-  setCurrentReasoningEffort(state.reasoningEffort ?? '')
-  setCurrentServiceTier(state.serviceTier ?? '')
-  setCurrentFastMode(state.fast ?? false)
-  setYoloActive(state.yolo ?? false)
-  setCurrentPersonality(state.personality ?? '')
+/**
+ * The projection surface one registered pane exposes to the cache: its view
+ * atoms' setters, the messages atom it publishes into, and the refs its
+ * staging gate reads. `PaneSessionView` (app/chat/pane-view.ts) satisfies this
+ * structurally; the MAIN pane's entry is assembled from the hook options so
+ * the constructor contract (setMessages/setBusy/setAwaitingResponse/busyRef)
+ * is unchanged.
+ */
+export interface RegisteredSessionView {
+  paneId: PaneId
+  $messages: { get: () => ChatMessage[] }
+  activeSessionIdRef: MutableRefObject<string | null>
+  busyRef: MutableRefObject<boolean>
+  /** Runtime id whose transcript currently occupies the view's `$messages` —
+   *  lets the flush tell a same-session refresh from a thread switch. */
+  viewSessionIdRef: MutableRefObject<string | null>
+  setMessages: (messages: ChatMessage[]) => void
+  setBusy: (busy: boolean) => void
+  setAwaitingResponse: (awaiting: boolean) => void
+  setTurnStartedAt: (turnStartedAt: number | null) => void
+  setCurrentModel: (model: string) => void
+  setCurrentProvider: (provider: string) => void
+  setCurrentReasoningEffort: (effort: string) => void
+  setCurrentServiceTier: (tier: string) => void
+  setCurrentFastMode: (fast: boolean) => void
+  setYoloActive: (yolo: boolean) => void
+  setCurrentPersonality: (personality: string) => void
+}
+
+// One registered pane = one staging slot + one RAF handle. Per-pane batching
+// keeps a busy background pane's flush cadence independent of the active one.
+interface RegisteredPaneView {
+  view: RegisteredSessionView
+  pending: { sessionId: string; state: ClientSessionState } | null
+  raf: number | null
+}
+
+function syncRuntimeMetadataToView(view: RegisteredSessionView, state: ClientSessionState) {
+  view.setCurrentModel(state.model ?? '')
+  view.setCurrentProvider(state.provider ?? '')
+  view.setCurrentReasoningEffort(state.reasoningEffort ?? '')
+  view.setCurrentServiceTier(state.serviceTier ?? '')
+  view.setCurrentFastMode(state.fast ?? false)
+  view.setYoloActive(state.yolo ?? false)
+  view.setCurrentPersonality(state.personality ?? '')
 }
 
 export function useSessionStateCache({
@@ -78,12 +116,51 @@ export function useSessionStateCache({
   const selectedStoredSessionIdRef = useRef<string | null>(null)
   const sessionStateByRuntimeIdRef = useRef(new Map<string, ClientSessionState>())
   const runtimeIdByStoredSessionIdRef = useRef(new Map<string, string>())
-  const pendingViewStateRef = useRef<{ sessionId: string; state: ClientSessionState } | null>(null)
-  const viewSyncRafRef = useRef<number | null>(null)
-  // Runtime id whose transcript currently occupies `$messages` — lets the
-  // flush below tell a same-session refresh from a thread switch.
+  // Runtime id whose transcript currently occupies the MAIN `$messages` view.
   const viewSessionIdRef = useRef<string | null>(null)
 
+  // Latest options snapshot, refreshed every render, so the (stable) main
+  // pane-view entry below always flushes through the caller's current setters —
+  // exactly like the old useCallback deps did.
+  const mainOptionsRef = useRef({ busyRef, setAwaitingResponse, setBusy, setMessages })
+  mainOptionsRef.current = { busyRef, setAwaitingResponse, setBusy, setMessages }
+
+  // The MAIN pane registered from the hook options: reads the global $messages,
+  // publishes through the option setters, and writes the global metadata
+  // singletons — line-for-line the old single-view projection.
+  const mainPaneViewRef = useRef<RegisteredSessionView | null>(null)
+
+  if (mainPaneViewRef.current === null) {
+    mainPaneViewRef.current = {
+      paneId: 'main',
+      $messages,
+      activeSessionIdRef,
+      get busyRef() {
+        return mainOptionsRef.current.busyRef
+      },
+      viewSessionIdRef,
+      setMessages: messages => mainOptionsRef.current.setMessages(messages),
+      setBusy: value => mainOptionsRef.current.setBusy(value),
+      setAwaitingResponse: value => mainOptionsRef.current.setAwaitingResponse(value),
+      setTurnStartedAt,
+      setCurrentModel,
+      setCurrentProvider,
+      setCurrentReasoningEffort,
+      setCurrentServiceTier,
+      setCurrentFastMode,
+      setYoloActive,
+      setCurrentPersonality
+    }
+  }
+
+  const paneViewsRef = useRef<Map<PaneId, RegisteredPaneView> | null>(null)
+
+  if (paneViewsRef.current === null) {
+    paneViewsRef.current = new Map([['main', { pending: null, raf: null, view: mainPaneViewRef.current }]])
+  }
+
+  const paneViews = paneViewsRef as MutableRefObject<Map<PaneId, RegisteredPaneView>>
+
   useEffect(() => {
     activeSessionIdRef.current = activeSessionId
   }, [activeSessionId])
@@ -130,11 +207,11 @@ export function useSessionStateCache({
     return created
   }, [])
 
-  const flushPendingViewState = useCallback(() => {
-    const pending = pendingViewStateRef.current
-    pendingViewStateRef.current = null
+  const flushPendingPaneState = useCallback((entry: RegisteredPaneView) => {
+    const pending = entry.pending
+    entry.pending = null
 
-    if (!pending || pending.sessionId !== activeSessionIdRef.current) {
+    if (!pending || pending.sessionId !== entry.view.activeSessionIdRef.current) {
       return
     }
 
@@ -145,58 +222,58 @@ export function useSessionStateCache({
     // assistant-ui runtime → the virtualizer, which re-measures and visibly
     // jerks the scroll position while the user is reading. Skip the publish when
     // the merged result is content-identical to what's already on screen.
-    const currentMessages = $messages.get()
+    const currentMessages = entry.view.$messages.get()
 
-    // On a thread switch `$messages` still holds the *previous* thread, so
+    // On a thread switch the view still holds the *previous* thread, so
     // preserving its local errors would graft that thread's failed turn (e.g.
     // an out-of-funds error) onto this one — then cascade it everywhere as the
     // polluted view becomes the next switch's baseline. Only carry errors
     // across a same-session refresh; our cached state already keeps its own.
     const nextMessages =
-      viewSessionIdRef.current === pending.sessionId
+      entry.view.viewSessionIdRef.current === pending.sessionId
         ? preserveLocalAssistantErrors(pending.state.messages, currentMessages)
         : pending.state.messages
 
     if (!sameMessageList(nextMessages, currentMessages)) {
-      setMessages(nextMessages)
+      entry.view.setMessages(nextMessages)
     }
 
-    viewSessionIdRef.current = pending.sessionId
+    entry.view.viewSessionIdRef.current = pending.sessionId
 
-    syncRuntimeMetadataToView(pending.state)
-    setBusy(pending.state.busy)
-    setMutableRef(busyRef, pending.state.busy)
-    setAwaitingResponse(pending.state.awaitingResponse)
-    // Mirror the focused session's per-session turn clock into the global
-    // atom the statusbar timer reads. Keeps a backgrounded turn's elapsed
-    // time intact on focus instead of zeroing it (the "timer restarts" bug).
-    setTurnStartedAt(pending.state.turnStartedAt)
-  }, [busyRef, setAwaitingResponse, setBusy, setMessages])
+    syncRuntimeMetadataToView(entry.view, pending.state)
+    entry.view.setBusy(pending.state.busy)
+    setMutableRef(entry.view.busyRef, pending.state.busy)
+    entry.view.setAwaitingResponse(pending.state.awaitingResponse)
+    // Mirror the focused session's per-session turn clock into the atom the
+    // statusbar timer reads. Keeps a backgrounded turn's elapsed time intact
+    // on focus instead of zeroing it (the "timer restarts" bug).
+    entry.view.setTurnStartedAt(pending.state.turnStartedAt)
+  }, [])
 
-  const syncSessionStateToView = useCallback(
-    (sessionId: string, state: ClientSessionState) => {
-      // Only the currently-viewed session may stage into the shared `$messages`
-      // view. A background session (e.g. one still busy and emitting stream /
-      // error updates after the user toggled away) must update its own cache
-      // entry but never the view — otherwise its messages clobber the
-      // foreground transcript and appear to "bleed" into every other session.
-      // The flush below also re-checks the active id, but staging here is what
+  const syncPaneStateToView = useCallback(
+    (entry: RegisteredPaneView, sessionId: string, state: ClientSessionState) => {
+      // Only the pane's currently-viewed session may stage into its view. A
+      // background session (e.g. one still busy and emitting stream / error
+      // updates after the user toggled away) must update its own cache entry
+      // but never a view — otherwise its messages clobber the foreground
+      // transcript and appear to "bleed" into every other session. The flush
+      // above also re-checks the pane's active id, but staging here is what
       // prevents a background write from overwriting an already-pending
       // foreground write within the same animation frame (only one RAF is
-      // scheduled, so the last `pendingViewStateRef` writer would otherwise win).
-      if (sessionId !== activeSessionIdRef.current) {
+      // scheduled per pane, so the last `pending` writer would otherwise win).
+      if (sessionId !== entry.view.activeSessionIdRef.current) {
         return
       }
 
-      syncRuntimeMetadataToView(state)
-      pendingViewStateRef.current = { sessionId, state }
+      syncRuntimeMetadataToView(entry.view, state)
+      entry.pending = { sessionId, state }
 
       // Terminal / attention transitions (turn finished, error, or the agent is
       // now waiting on the user) MUST reach the view immediately. Electron
       // throttles `requestAnimationFrame` to ~0 while the window is
       // backgrounded, occluded, or unfocused, so an RAF-deferred flush can be
-      // stranded in `pendingViewStateRef` indefinitely — that's the "new chat
-      // stuck on Thinking until I refocus / F5" bug. Flush these synchronously
+      // stranded in `pending` indefinitely — that's the "new chat stuck on
+      // Thinking until I refocus / F5" bug. Flush these synchronously
       // (cancelling any in-flight RAF, since we're about to publish the latest
       // state anyway). The plain busy heartbeat stays RAF-batched: that
       // coalescing exists only to keep periodic `session.info` updates from
@@ -204,42 +281,103 @@ export function useSessionStateCache({
       const isCriticalTransition = !state.busy || state.needsInput
 
       if (isCriticalTransition) {
-        if (viewSyncRafRef.current !== null && typeof window !== 'undefined') {
-          window.cancelAnimationFrame(viewSyncRafRef.current)
-          viewSyncRafRef.current = null
+        if (entry.raf !== null && typeof window !== 'undefined') {
+          window.cancelAnimationFrame(entry.raf)
+          entry.raf = null
         }
 
-        flushPendingViewState()
+        flushPendingPaneState(entry)
 
         return
       }
 
-      if (viewSyncRafRef.current !== null) {
+      if (entry.raf !== null) {
         return
       }
 
       if (typeof window === 'undefined') {
-        flushPendingViewState()
+        flushPendingPaneState(entry)
 
         return
       }
 
-      viewSyncRafRef.current = window.requestAnimationFrame(() => {
-        viewSyncRafRef.current = null
-        flushPendingViewState()
+      entry.raf = window.requestAnimationFrame(() => {
+        entry.raf = null
+        flushPendingPaneState(entry)
       })
     },
-    [flushPendingViewState]
+    [flushPendingPaneState]
+  )
+
+  // Fan a session's fresh truth out to every registered pane view. With only
+  // the main pane registered (single-pane mode) this is exactly the old
+  // single-view staging + flush.
+  const syncSessionStateToView = useCallback(
+    (sessionId: string, state: ClientSessionState) => {
+      for (const entry of paneViews.current.values()) {
+        syncPaneStateToView(entry, sessionId, state)
+      }
+    },
+    [paneViews, syncPaneStateToView]
+  )
+
+  /** Mount a pane's view for fan-out. Returns the unregister disposer —
+   *  SplitChatPane registers on mount and unregisters on close, after which
+   *  its session keeps streaming in the truth layer like any background one. */
+  const registerPaneView = useCallback(
+    (view: RegisteredSessionView) => {
+      const entry: RegisteredPaneView = { pending: null, raf: null, view }
+      paneViews.current.set(view.paneId, entry)
+
+      return () => {
+        if (entry.raf !== null && typeof window !== 'undefined') {
+          window.cancelAnimationFrame(entry.raf)
+          entry.raf = null
+        }
+
+        if (paneViews.current.get(view.paneId) === entry) {
+          paneViews.current.delete(view.paneId)
+        }
+      }
+    },
+    [paneViews]
+  )
+
+  /** Re-project a pane's cached session truth into its view synchronously —
+   *  the warm repaint used on pane activation and split-open (mirrors the
+   *  warm-cache repaint in resumeSession). No-op when the pane isn't
+   *  registered or holds no cached session. */
+  const publishPaneState = useCallback(
+    (paneId: PaneId) => {
+      const entry = paneViews.current.get(paneId)
+      const runtimeId = entry?.view.activeSessionIdRef.current
+      const state = runtimeId ? sessionStateByRuntimeIdRef.current.get(runtimeId) : undefined
+
+      if (!entry || !runtimeId || !state) {
+        return
+      }
+
+      if (entry.raf !== null && typeof window !== 'undefined') {
+        window.cancelAnimationFrame(entry.raf)
+        entry.raf = null
+      }
+
+      entry.pending = { sessionId: runtimeId, state }
+      flushPendingPaneState(entry)
+    },
+    [flushPendingPaneState, paneViews]
   )
 
   useEffect(
     () => () => {
-      if (viewSyncRafRef.current !== null && typeof window !== 'undefined') {
-        window.cancelAnimationFrame(viewSyncRafRef.current)
-        viewSyncRafRef.current = null
+      for (const entry of paneViews.current.values()) {
+        if (entry.raf !== null && typeof window !== 'undefined') {
+          window.cancelAnimationFrame(entry.raf)
+          entry.raf = null
+        }
       }
     },
-    []
+    [paneViews]
   )
 
   const updateSessionState = useCallback(
@@ -306,6 +444,8 @@ export function useSessionStateCache({
   return {
     activeSessionIdRef,
     ensureSessionState,
+    publishPaneState,
+    registerPaneView,
     runtimeIdByStoredSessionIdRef,
     selectedStoredSessionIdRef,
     sessionStateByRuntimeIdRef,
diff --git a/apps/desktop/src/components/assistant-ui/thread/list.tsx b/apps/desktop/src/components/assistant-ui/thread/list.tsx
index 8f2856e3dfa7e..2a6d8d3cb843b 100644
--- a/apps/desktop/src/components/assistant-ui/thread/list.tsx
+++ b/apps/desktop/src/components/assistant-ui/thread/list.tsx
@@ -13,15 +13,10 @@ import {
 } from 'react'
 import { useStickToBottom } from 'use-stick-to-bottom'
 
+import { usePaneView } from '@/app/chat/pane-view'
 import { useI18n } from '@/i18n'
 import { cn } from '@/lib/utils'
-import {
-  onScrollToBottomRequest,
-  onThreadEditClose,
-  onThreadEditOpen,
-  resetThreadScroll,
-  setThreadAtBottom
-} from '@/store/thread-scroll'
+import { onThreadEditClose, onThreadEditOpen } from '@/store/thread-scroll'
 import { isSecondaryWindow } from '@/store/windows'
 
 import { MessageRenderBoundary } from '../message-render-boundary'
@@ -103,6 +98,10 @@ const ThreadMessageListInner: FC<ThreadMessageListProps> = ({
   )
 
   const { t } = useI18n()
+  // Pane-scoped scroll mirror: each mounted thread writes ITS pane's atoms
+  // (composer dim + jump button), so two panes never fight over one flag.
+  // Unwrapped (single-pane) this is the same module singleton as before.
+  const { onScrollToBottomRequest, resetThreadScroll, setThreadAtBottom } = usePaneView()
   const groups = buildGroups(messageSignature)
   const renderEmpty = groups.length === 0 && Boolean(emptyPlaceholder)
 
@@ -150,11 +149,11 @@ const ThreadMessageListInner: FC<ThreadMessageListProps> = ({
     ? 'pt-[calc(var(--titlebar-height)+0.75rem)]'
     : 'pt-[calc(var(--titlebar-height)-0.5rem)]'
 
-  useEffect(() => setThreadAtBottom(isAtBottom), [isAtBottom])
-  useEffect(() => () => resetThreadScroll(), [])
+  useEffect(() => setThreadAtBottom(isAtBottom), [isAtBottom, setThreadAtBottom])
+  useEffect(() => () => resetThreadScroll(), [resetThreadScroll])
 
   // Floating jump button (outside this subtree) → return to the bottom.
-  useEffect(() => onScrollToBottomRequest(() => void scrollToBottom()), [scrollToBottom])
+  useEffect(() => onScrollToBottomRequest(() => void scrollToBottom()), [onScrollToBottomRequest, scrollToBottom])
 
   const endEditHold = useCallback(() => {
     scrollRef.current?.removeAttribute('data-editing')
diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts
index 1aaac14817e28..0f33edeca40eb 100644
--- a/apps/desktop/src/i18n/en.ts
+++ b/apps/desktop/src/i18n/en.ts
@@ -246,6 +246,7 @@ export const en: Translations = {
       'view.terminalSelection': 'Send terminal selection to composer',
       'view.closePreviewTab': 'Close preview tab',
       'view.flipPanes': 'Swap sidebar sides',
+      'view.toggleSplit': 'Toggle split pane',
       'appearance.toggleMode': 'Toggle light / dark',
       'profile.default': 'Switch to default profile',
       'profile.switch.1': 'Switch to profile 1',
@@ -942,6 +943,8 @@ export const en: Translations = {
     goToSession: 'Go to session',
     branches: 'Branches',
     startInBranch: branch => `New conversation in ${branch}`,
+    splitRight: 'Split right',
+    closeSplit: 'Close split',
     commandCenter: 'Command Center',
     appearance: 'Appearance',
     settings: 'Settings',
@@ -1661,6 +1664,7 @@ export const en: Translations = {
       rename: 'Rename',
       archive: 'Archive',
       newWindow: 'New window',
+      openInSplit: 'Open in split',
       copyIdFailed: 'Could not copy session ID',
       actionsFor: title => `Actions for ${title}`,
       sessionActions: 'Session actions',
diff --git a/apps/desktop/src/i18n/ja.ts b/apps/desktop/src/i18n/ja.ts
index 853a16f07c65c..6761f9cbbaad2 100644
--- a/apps/desktop/src/i18n/ja.ts
+++ b/apps/desktop/src/i18n/ja.ts
@@ -245,6 +245,7 @@ export const ja = defineLocale({
       'view.terminalSelection': 'ターミナルの選択範囲をコンポーザーへ送信',
       'view.closePreviewTab': 'プレビュータブを閉じる',
       'view.flipPanes': 'サイドバーの位置を入れ替え',
+      'view.toggleSplit': '分割ペインを切り替え',
       'appearance.toggleMode': 'ライト / ダークを切り替え',
       'profile.default': 'デフォルトプロファイルに切り替え',
       'profile.switch.1': 'プロファイル 1 に切り替え',
@@ -1194,6 +1195,8 @@ export const ja = defineLocale({
     goToSession: 'セッションへ移動',
     branches: 'ブランチ',
     startInBranch: branch => `${branch} で新しい会話`,
+    splitRight: '右に分割',
+    closeSplit: '分割を閉じる',
     commandCenter: 'コマンドセンター',
     appearance: '外観',
     settings: '設定',
@@ -1923,6 +1926,7 @@ export const ja = defineLocale({
       rename: '名前を変更',
       archive: 'アーカイブ',
       newWindow: '新しいウィンドウ',
+      openInSplit: '分割ペインで開く',
       copyIdFailed: 'セッション ID をコピーできませんでした',
       actionsFor: title => `${title} のアクション`,
       sessionActions: 'セッションアクション',
diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts
index 1fc3e1b0a71f1..678cf962a10e2 100644
--- a/apps/desktop/src/i18n/types.ts
+++ b/apps/desktop/src/i18n/types.ts
@@ -827,6 +827,8 @@ export interface Translations {
     goToSession: string
     branches: string
     startInBranch: (branch: string) => string
+    splitRight: string
+    closeSplit: string
     commandCenter: string
     appearance: string
     settings: string
@@ -1380,6 +1382,7 @@ export interface Translations {
       rename: string
       archive: string
       newWindow: string
+      openInSplit: string
       copyIdFailed: string
       actionsFor: (title: string) => string
       sessionActions: string
diff --git a/apps/desktop/src/i18n/zh-hant.ts b/apps/desktop/src/i18n/zh-hant.ts
index 37024404e182a..a349711964f33 100644
--- a/apps/desktop/src/i18n/zh-hant.ts
+++ b/apps/desktop/src/i18n/zh-hant.ts
@@ -239,6 +239,7 @@ export const zhHant = defineLocale({
       'view.terminalSelection': '將終端機選取範圍傳送到輸入框',
       'view.closePreviewTab': '關閉預覽分頁',
       'view.flipPanes': '交換側邊欄位置',
+      'view.toggleSplit': '切換分割窗格',
       'appearance.toggleMode': '切換淺色/深色',
       'profile.default': '切換到預設設定檔',
       'profile.switch.1': '切換到設定檔 1',
@@ -1160,6 +1161,8 @@ export const zhHant = defineLocale({
     goToSession: '前往工作階段',
     branches: '分支',
     startInBranch: branch => `在 ${branch} 中開始新對話`,
+    splitRight: '向右分割',
+    closeSplit: '關閉分割窗格',
     commandCenter: '命令中心',
     appearance: '外觀',
     settings: '設定',
@@ -1866,6 +1869,7 @@ export const zhHant = defineLocale({
       rename: '重新命名',
       archive: '封存',
       newWindow: '新視窗',
+      openInSplit: '在分割窗格中開啟',
       copyIdFailed: '無法複製工作階段 ID',
       actionsFor: title => `${title} 的動作`,
       sessionActions: '工作階段動作',
diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts
index 202cdb450dac2..5c5c9f6c1d0c3 100644
--- a/apps/desktop/src/i18n/zh.ts
+++ b/apps/desktop/src/i18n/zh.ts
@@ -237,6 +237,7 @@ export const zh: Translations = {
       'view.terminalSelection': '将终端选区发送到输入框',
       'view.closePreviewTab': '关闭预览标签',
       'view.flipPanes': '交换侧边栏位置',
+      'view.toggleSplit': '切换分屏',
       'appearance.toggleMode': '切换浅色/深色',
       'profile.default': '切换到默认配置',
       'profile.switch.1': '切换到配置 1',
@@ -1124,6 +1125,8 @@ export const zh: Translations = {
     goToSession: '前往会话',
     branches: '分支',
     startInBranch: branch => `在 ${branch} 中开始新对话`,
+    splitRight: '向右分屏',
+    closeSplit: '关闭分屏',
     commandCenter: '命令中心',
     appearance: '外观',
     settings: '设置',
@@ -1837,6 +1840,7 @@ export const zh: Translations = {
       rename: '重命名',
       archive: '归档',
       newWindow: '新窗口',
+      openInSplit: '在分屏中打开',
       copyIdFailed: '无法复制会话 ID',
       actionsFor: title => `${title} 的操作`,
       sessionActions: '会话操作',
diff --git a/apps/desktop/src/lib/icons.ts b/apps/desktop/src/lib/icons.ts
index 392c6f1730a03..a61bb0a1be0de 100644
--- a/apps/desktop/src/lib/icons.ts
+++ b/apps/desktop/src/lib/icons.ts
@@ -27,6 +27,7 @@ import {
   IconCircle as CircleIcon,
   IconClipboard as Clipboard,
   IconClock as Clock,
+  IconLayoutColumns as Columns2,
   IconCommand as Command,
   IconCopy as Copy,
   IconCopy as CopyIcon,
@@ -143,6 +144,7 @@ export {
   CircleIcon,
   Clipboard,
   Clock,
+  Columns2,
   Command,
   Copy,
   CopyIcon,
diff --git a/apps/desktop/src/lib/keybinds/actions.test.ts b/apps/desktop/src/lib/keybinds/actions.test.ts
new file mode 100644
index 0000000000000..fdd86b4a06282
--- /dev/null
+++ b/apps/desktop/src/lib/keybinds/actions.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+
+import { $comboIndex } from '@/store/keybinds'
+
+import { defaultBindings, KEYBIND_ACTIONS, keybindAction } from './actions'
+import { canonicalizeCombo } from './combo'
+
+// The split-pane toggle keybind (design §6 step 14): registered in the action
+// registry, shipped on ⌘⇧\ — and cleanly distinct from ⌘\ (view.flipPanes).
+
+describe('view.toggleSplit keybind', () => {
+  it('is registered in the rebindable registry under the view category', () => {
+    const action = keybindAction('view.toggleSplit')
+
+    expect(action).toBeDefined()
+    expect(action?.category).toBe('view')
+    expect(action?.defaults).toEqual(['mod+shift+\\'])
+  })
+
+  it('ships its default combo through defaultBindings()', () => {
+    expect(defaultBindings()['view.toggleSplit']).toEqual(['mod+shift+\\'])
+  })
+
+  it('resolves through the live combo index without clashing with view.flipPanes', () => {
+    const index = $comboIndex.get()
+
+    expect(index.get(canonicalizeCombo('mod+shift+\\'))).toBe('view.toggleSplit')
+    expect(index.get(canonicalizeCombo('mod+\\'))).toBe('view.flipPanes')
+  })
+
+  it('collides with no other shipped default', () => {
+    const combo = canonicalizeCombo('mod+shift+\\')
+
+    const owners = KEYBIND_ACTIONS.filter(action =>
+      action.defaults.some(candidate => canonicalizeCombo(candidate) === combo)
+    ).map(action => action.id)
+
+    expect(owners).toEqual(['view.toggleSplit'])
+  })
+})
diff --git a/apps/desktop/src/lib/keybinds/actions.ts b/apps/desktop/src/lib/keybinds/actions.ts
index be0c53a0b68fa..a244b29921705 100644
--- a/apps/desktop/src/lib/keybinds/actions.ts
+++ b/apps/desktop/src/lib/keybinds/actions.ts
@@ -112,6 +112,9 @@ export const KEYBIND_ACTIONS: readonly KeybindActionMeta[] = [
   { id: 'view.closeTerminal', category: 'view', defaults: ['ctrl+shift+w'] },
   // ⌘\ — the backslash reads like a mirror line flipping the layout.
   { id: 'view.flipPanes', category: 'view', defaults: ['mod+\\'] },
+  // ⌘⇧\ — the split-pane sibling of ⌘\: same backslash "divider" mnemonic,
+  // shifted. Toggles the second chat pane (never in secondary windows).
+  { id: 'view.toggleSplit', category: 'view', defaults: ['mod+shift+\\'] },
   { id: 'appearance.toggleMode', category: 'view', defaults: ['shift+x'] },
   { id: 'keybinds.openPanel', category: 'view', defaults: ['mod+/'] }
 ]
diff --git a/apps/desktop/src/store/composer.ts b/apps/desktop/src/store/composer.ts
index c40cf867735be..4c693dfe1754d 100644
--- a/apps/desktop/src/store/composer.ts
+++ b/apps/desktop/src/store/composer.ts
@@ -1,4 +1,4 @@
-import { atom } from 'nanostores'
+import { atom, type WritableAtom } from 'nanostores'
 
 import { triggerHaptic } from '@/lib/haptics'
 
@@ -133,20 +133,29 @@ export function clearComposerDraft() {
   $composerDraft.set('')
 }
 
-export function addComposerAttachment(attachment: ComposerAttachment) {
-  const previous = $composerAttachments.get()
+// Every attachment mutator takes an optional `target` atom, defaulting to the
+// module singleton — the split pane owns a second attachments atom (see
+// app/chat/pane-view.ts), and its composer routes these same operations at it.
+// Existing callers pass nothing, so single-pane behavior is unchanged.
+type AttachmentsAtom = WritableAtom<ComposerAttachment[]>
+
+export function addComposerAttachment(attachment: ComposerAttachment, target: AttachmentsAtom = $composerAttachments) {
+  const previous = target.get()
   const next = upsertAttachment(previous, attachment)
-  $composerAttachments.set(next)
+  target.set(next)
 
   if (next.length > previous.length && attachment.kind !== 'url') {
     triggerHaptic('selection')
   }
 }
 
-export function removeComposerAttachment(id: string): ComposerAttachment | null {
-  const current = $composerAttachments.get()
+export function removeComposerAttachment(
+  id: string,
+  target: AttachmentsAtom = $composerAttachments
+): ComposerAttachment | null {
+  const current = target.get()
   const removed = current.find(attachment => attachment.id === id) || null
-  $composerAttachments.set(current.filter(attachment => attachment.id !== id))
+  target.set(current.filter(attachment => attachment.id !== id))
 
   return removed
 }
@@ -155,8 +164,11 @@ export function removeComposerAttachment(id: string): ComposerAttachment | null
  * id is gone — e.g. the user removed the chip while an eager upload was still in
  * flight, so a late success must NOT resurrect it. Use this instead of
  * addComposerAttachment for async results that may land after a removal. */
-export function updateComposerAttachment(attachment: ComposerAttachment): boolean {
-  const current = $composerAttachments.get()
+export function updateComposerAttachment(
+  attachment: ComposerAttachment,
+  target: AttachmentsAtom = $composerAttachments
+): boolean {
+  const current = target.get()
   const index = current.findIndex(item => item.id === attachment.id)
 
   if (index < 0) {
@@ -165,19 +177,23 @@ export function updateComposerAttachment(attachment: ComposerAttachment): boolea
 
   const next = [...current]
   next[index] = attachment
-  $composerAttachments.set(next)
+  target.set(next)
 
   return true
 }
 
-export function clearComposerAttachments() {
-  $composerAttachments.set([])
+export function clearComposerAttachments(target: AttachmentsAtom = $composerAttachments) {
+  target.set([])
 }
 
 /** Update only the upload state of an existing attachment (no-op if it's gone,
  * e.g. the user removed it mid-upload). Pass `undefined` to clear it. */
-export function setComposerAttachmentUploadState(id: string, uploadState?: ComposerAttachment['uploadState']) {
-  const current = $composerAttachments.get()
+export function setComposerAttachmentUploadState(
+  id: string,
+  uploadState?: ComposerAttachment['uploadState'],
+  target: AttachmentsAtom = $composerAttachments
+) {
+  const current = target.get()
   const index = current.findIndex(attachment => attachment.id === id)
 
   if (index < 0) {
@@ -186,7 +202,7 @@ export function setComposerAttachmentUploadState(id: string, uploadState?: Compo
 
   const next = [...current]
   next[index] = { ...next[index]!, uploadState }
-  $composerAttachments.set(next)
+  target.set(next)
 }
 
 const TERMINAL_REF_RE = /@terminal:(`[^`\n]+`|"[^"\n]+"|'[^'\n]+'|\S+)/g
diff --git a/apps/desktop/src/store/gateway.test.ts b/apps/desktop/src/store/gateway.test.ts
new file mode 100644
index 0000000000000..1c3d2a51b2f49
--- /dev/null
+++ b/apps/desktop/src/store/gateway.test.ts
@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { HermesGateway } from '@/hermes'
+import { $gatewayState, setGatewayState } from '@/store/session'
+
+import {
+  $gateway,
+  closeSecondaryGateways,
+  ensureGatewayForProfile,
+  ensureProfileSocketOpen,
+  gatewayForProfile,
+  pruneSecondaryGateways,
+  setPrimaryGateway
+} from './gateway'
+
+// No window.hermesDesktop in jsdom, so openSecondary() is a no-op: sockets are
+// created + registered but never actually connect — exactly what these tests
+// need (routing/pointer semantics, not transport).
+
+describe('gateway registry profile-socket accessors', () => {
+  const primary = new HermesGateway()
+
+  beforeEach(async () => {
+    setPrimaryGateway(primary, 'default')
+    // Pin the active pointer to the primary so each test starts from the
+    // single-profile baseline.
+    await ensureGatewayForProfile('default')
+  })
+
+  afterEach(async () => {
+    closeSecondaryGateways()
+    await ensureGatewayForProfile('default')
+    setPrimaryGateway(null)
+    $gateway.set(null)
+    setGatewayState('idle')
+  })
+
+  describe('gatewayForProfile', () => {
+    it('passes the primary through for the primary key and blank/null keys', () => {
+      expect(gatewayForProfile('default')).toBe(primary)
+      expect(gatewayForProfile(null)).toBe(primary)
+      expect(gatewayForProfile(undefined)).toBe(primary)
+      expect(gatewayForProfile('   ')).toBe(primary)
+    })
+
+    it('returns null for a profile with no live secondary', () => {
+      expect(gatewayForProfile('beta')).toBeNull()
+    })
+
+    it('returns the secondary once one exists', async () => {
+      const socket = await ensureProfileSocketOpen('beta')
+
+      expect(gatewayForProfile('beta')).toBe(socket)
+    })
+  })
+
+  describe('ensureProfileSocketOpen', () => {
+    it('opens a secondary WITHOUT moving the active gateway or its reported state', async () => {
+      setGatewayState('open')
+      const activeBefore = $gateway.get()
+
+      const socket = await ensureProfileSocketOpen('beta')
+
+      expect(socket).toBeInstanceOf(HermesGateway)
+      expect(socket).not.toBe(primary)
+      // The active pointer and the composer's gateway-state mirror are exactly
+      // where they were — a background pane's socket must be invisible to the
+      // foreground surfaces.
+      expect($gateway.get()).toBe(activeBefore)
+      expect($gatewayState.get()).toBe('open')
+    })
+
+    it('reuses the existing secondary on repeat calls', async () => {
+      const first = await ensureProfileSocketOpen('beta')
+      const second = await ensureProfileSocketOpen('beta')
+
+      expect(second).toBe(first)
+    })
+
+    it('is a passthrough for the primary profile', async () => {
+      setGatewayState('open')
+
+      expect(await ensureProfileSocketOpen('default')).toBe(primary)
+      expect(await ensureProfileSocketOpen(null)).toBe(primary)
+      expect($gatewayState.get()).toBe('open')
+    })
+  })
+
+  describe('ensureGatewayForProfile (the swap, by contrast)', () => {
+    it('moves the active gateway to the profile socket', async () => {
+      const socket = await ensureProfileSocketOpen('beta')
+
+      await ensureGatewayForProfile('beta')
+
+      expect($gateway.get()).toBe(socket)
+
+      await ensureGatewayForProfile('default')
+
+      expect($gateway.get()).toBe(primary)
+    })
+  })
+
+  describe('pruneSecondaryGateways', () => {
+    it('spares profiles in the keep set and evicts the rest', async () => {
+      const kept = await ensureProfileSocketOpen('beta')
+      await ensureProfileSocketOpen('gamma')
+
+      pruneSecondaryGateways(new Set(['beta']))
+
+      expect(gatewayForProfile('beta')).toBe(kept)
+      expect(gatewayForProfile('gamma')).toBeNull()
+
+      pruneSecondaryGateways(new Set())
+
+      expect(gatewayForProfile('beta')).toBeNull()
+    })
+  })
+})
diff --git a/apps/desktop/src/store/gateway.ts b/apps/desktop/src/store/gateway.ts
index 9d920717a4795..84cb2ce4dac7f 100644
--- a/apps/desktop/src/store/gateway.ts
+++ b/apps/desktop/src/store/gateway.ts
@@ -185,15 +185,32 @@ function createSecondary(profile: string): Secondary {
   return entry
 }
 
-// Make `profile` the active gateway, lazily opening its socket if needed. The
-// primary is a no-op fast path. Background sockets are never closed here.
-export async function ensureGatewayForProfile(profile: string): Promise<void> {
+// The socket that serves `profile`, WITHOUT touching the active pointer. For
+// operations that must run against a specific profile's backend while another
+// profile stays active — e.g. restoring the split pane's session at boot, or
+// keeping a background pane's socket alive. Null when the profile has no
+// primary claim and no live secondary (use ensureProfileSocketOpen to mint one).
+export function gatewayForProfile(profile: string | null | undefined): HermesGateway | null {
   const key = normKey(profile)
 
   if (key === primaryProfile) {
-    setActive(key)
+    return primaryGateway
+  }
 
-    return
+  return secondaries.get(key)?.gateway ?? null
+}
+
+// Open (or reuse) `profile`'s socket WITHOUT making it the active gateway —
+// the open-only body of ensureGatewayForProfile. Background-pane plumbing
+// (split boot restore, keepalive) needs the socket live but must never steal
+// the active pointer, `$gatewayState`, or `$connection` from the pane the user
+// is looking at. The primary's lifecycle is owned by use-gateway-boot, so it
+// passes through untouched.
+export async function ensureProfileSocketOpen(profile: string | null | undefined): Promise<HermesGateway | null> {
+  const key = normKey(profile)
+
+  if (key === primaryProfile) {
+    return primaryGateway
   }
 
   let entry = secondaries.get(key)
@@ -215,6 +232,18 @@ export async function ensureGatewayForProfile(profile: string): Promise<void> {
     }
   }
 
+  return entry.gateway
+}
+
+// Make `profile` the active gateway, lazily opening its socket if needed. The
+// primary is a no-op fast path. Background sockets are never closed here.
+export async function ensureGatewayForProfile(profile: string): Promise<void> {
+  const key = normKey(profile)
+
+  if (key !== primaryProfile) {
+    await ensureProfileSocketOpen(key)
+  }
+
   setActive(key)
 }
 
diff --git a/apps/desktop/src/store/native-notifications.split.test.ts b/apps/desktop/src/store/native-notifications.split.test.ts
new file mode 100644
index 0000000000000..e0d46dd4bed22
--- /dev/null
+++ b/apps/desktop/src/store/native-notifications.split.test.ts
@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  dispatchNativeNotification,
+  NATIVE_NOTIFICATION_KINDS,
+  setNativeNotifyEnabled,
+  setNativeNotifyKind
+} from './native-notifications'
+import { setActiveSessionId } from './session'
+import { $splitPaneRuntimeSessionId, registerMainPaneRuntimeSessionIdGetter } from './split'
+
+// Step 14's foreground amendment: a session visible in the SPLIT pane is as
+// on-screen as the active one — completion kinds may fire for it while the
+// user is away, and attention kinds stop breaking through while the user is
+// literally looking at it. With the split closed the runtime-id atom is null
+// and every path below reduces to the pinned single-pane suite.
+
+const desktopWindow = window as unknown as { hermesDesktop?: Window['hermesDesktop'] }
+const initialHermesDesktop = desktopWindow.hermesDesktop
+
+const notify = vi.fn().mockResolvedValue(true)
+
+function setWindowState({ focused = true, hidden = false }: { focused?: boolean; hidden?: boolean }) {
+  Object.defineProperty(document, 'hidden', { configurable: true, value: hidden })
+  Object.defineProperty(document, 'hasFocus', { configurable: true, value: () => focused })
+}
+
+let counter = 0
+
+// Unique session id per call dodges the per-(kind,session) throttle so each
+// assertion starts clean.
+function freshSession(): string {
+  counter += 1
+
+  return `split-session-${counter}`
+}
+
+beforeEach(() => {
+  notify.mockClear()
+  desktopWindow.hermesDesktop = { notify } as unknown as Window['hermesDesktop']
+  setNativeNotifyEnabled(true)
+
+  for (const kind of NATIVE_NOTIFICATION_KINDS) {
+    setNativeNotifyKind(kind, true)
+  }
+
+  setActiveSessionId('rt-main')
+  $splitPaneRuntimeSessionId.set(null)
+  setWindowState({ focused: false, hidden: true })
+})
+
+afterEach(() => {
+  setActiveSessionId(null)
+  $splitPaneRuntimeSessionId.set(null)
+
+  if (initialHermesDesktop) {
+    desktopWindow.hermesDesktop = initialHermesDesktop
+  } else {
+    delete desktopWindow.hermesDesktop
+  }
+})
+
+describe('split-visible sessions count as foreground', () => {
+  it('fires a completion notification for the split session while the user is away', () => {
+    const sessionId = freshSession()
+    $splitPaneRuntimeSessionId.set(sessionId)
+
+    dispatchNativeNotification({ kind: 'turnDone', sessionId, title: 'done' })
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  it('still suppresses completion notifications for genuinely background sessions', () => {
+    $splitPaneRuntimeSessionId.set(freshSession())
+
+    dispatchNativeNotification({ kind: 'turnDone', sessionId: freshSession(), title: 'done' })
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('does NOT break an attention notification through for the split session while focused', () => {
+    const sessionId = freshSession()
+    $splitPaneRuntimeSessionId.set(sessionId)
+    setWindowState({ focused: true, hidden: false })
+
+    // Pre-amendment this fired: the session wasn't the ACTIVE one, so the
+    // attention kind treated it as off-screen even though it fills a pane.
+    dispatchNativeNotification({ kind: 'approval', sessionId, title: 'approve?' })
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('keeps breaking attention kinds through for off-screen sessions while focused', () => {
+    $splitPaneRuntimeSessionId.set(freshSession())
+    setWindowState({ focused: true, hidden: false })
+
+    dispatchNativeNotification({ kind: 'approval', sessionId: freshSession(), title: 'approve?' })
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  it('split closed (null runtime id): completion gating is exactly the single-pane rule', () => {
+    dispatchNativeNotification({ kind: 'turnDone', sessionId: 'rt-main', title: 'done' })
+    expect(notify).toHaveBeenCalledTimes(1)
+
+    notify.mockClear()
+    dispatchNativeNotification({ kind: 'turnDone', sessionId: freshSession(), title: 'done' })
+    expect(notify).not.toHaveBeenCalled()
+  })
+})
+
+describe('main pane stays foreground while the SPLIT is focused (identity mirrored)', () => {
+  // While the split is focused, split-mirror points $activeSessionId at the
+  // SPLIT's runtime id; the main pane's on-screen session is then only
+  // reachable through the controller-registered unmirrored getter.
+  afterEach(() => registerMainPaneRuntimeSessionIdGetter(null))
+
+  it('does NOT break an attention notification through for the main pane session', () => {
+    const mainSessionId = freshSession()
+    const splitSessionId = freshSession()
+    // Mirror in effect: the ACTIVE singleton carries the split's id.
+    setActiveSessionId(splitSessionId)
+    $splitPaneRuntimeSessionId.set(splitSessionId)
+    registerMainPaneRuntimeSessionIdGetter(() => mainSessionId)
+    setWindowState({ focused: true, hidden: false })
+
+    dispatchNativeNotification({ kind: 'approval', sessionId: mainSessionId, title: 'approve?' })
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  it('fires a completion notification for the main pane session while the user is away', () => {
+    const mainSessionId = freshSession()
+    const splitSessionId = freshSession()
+    setActiveSessionId(splitSessionId)
+    $splitPaneRuntimeSessionId.set(splitSessionId)
+    registerMainPaneRuntimeSessionIdGetter(() => mainSessionId)
+    setWindowState({ focused: false, hidden: true })
+
+    dispatchNativeNotification({ kind: 'turnDone', sessionId: mainSessionId, title: 'done' })
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/apps/desktop/src/store/native-notifications.ts b/apps/desktop/src/store/native-notifications.ts
index 5e659d061b40d..088f6d07f819f 100644
--- a/apps/desktop/src/store/native-notifications.ts
+++ b/apps/desktop/src/store/native-notifications.ts
@@ -5,6 +5,7 @@ import { persistString, storedString } from '@/lib/storage'
 import { $gateway } from './gateway'
 import { clearApprovalRequest } from './prompts'
 import { $activeSessionId } from './session'
+import { $splitPaneRuntimeSessionId, mainPaneRuntimeSessionId } from './split'
 
 // Native OS notifications (Electron `Notification`), separate from the in-app
 // toast feed in `notifications.ts`. Each kind toggles independently.
@@ -113,6 +114,33 @@ function isBackgrounded(): boolean {
   return typeof document.hasFocus === 'function' && !document.hasFocus()
 }
 
+// A session shown in either chat pane counts as foreground: the split pane's
+// transcript is exactly as on-screen as the main one. With the split closed
+// ($splitPaneRuntimeSessionId null, no divergent main-pane id) this reduces to
+// the pre-split active check. While the split is FOCUSED, $activeSessionId
+// mirrors the SPLIT's session — the main pane's on-screen transcript is then
+// only reachable through the controller-registered unmirrored getter, so both
+// pane ids are consulted.
+function isPaneVisibleSession(sessionId: null | string | undefined): boolean {
+  if (!sessionId) {
+    return false
+  }
+
+  if (sessionId === $activeSessionId.get()) {
+    return true
+  }
+
+  const splitRuntimeId = $splitPaneRuntimeSessionId.get()
+
+  if (splitRuntimeId !== null && sessionId === splitRuntimeId) {
+    return true
+  }
+
+  const mainRuntimeId = mainPaneRuntimeSessionId()
+
+  return mainRuntimeId !== null && sessionId === mainRuntimeId
+}
+
 function shouldFire(kind: NativeNotificationKind, sessionId?: null | string, global = false): boolean {
   // Global notifications aren't tied to a chat session (e.g. pet generation,
   // which runs from the command center with no active conversation). They fire
@@ -124,12 +152,12 @@ function shouldFire(kind: NativeNotificationKind, sessionId?: null | string, glo
 
   // Attention kinds break through for an off-screen session even while focused.
   if (ATTENTION_KINDS.has(kind)) {
-    return isBackgrounded() || (Boolean(sessionId) && sessionId !== $activeSessionId.get())
+    return isBackgrounded() || (Boolean(sessionId) && !isPaneVisibleSession(sessionId))
   }
 
-  // Completion kinds: only the active session, only while away — so a busy
+  // Completion kinds: only a pane-visible session, only while away — so a busy
   // gateway (messaging, kanban, cron) can't spam a toast per background session.
-  return isBackgrounded() && Boolean(sessionId) && sessionId === $activeSessionId.get()
+  return isBackgrounded() && isPaneVisibleSession(sessionId)
 }
 
 export interface NativeNotificationAction {
diff --git a/apps/desktop/src/store/split.test.ts b/apps/desktop/src/store/split.test.ts
new file mode 100644
index 0000000000000..6b70b8b2bd17b
--- /dev/null
+++ b/apps/desktop/src/store/split.test.ts
@@ -0,0 +1,242 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { SessionInfo } from '@/hermes'
+import { setSelectedStoredSessionId, setSessions } from '@/store/session'
+
+import { $paneStates, getPaneStateSnapshot } from './panes'
+import {
+  $activePaneId,
+  $splitFreshDraft,
+  $splitOpen,
+  $splitPaneSession,
+  closeSplitPane,
+  openSplitPane,
+  restoreSplitPaneSession,
+  setActivePane,
+  setSplitPaneFreshDraft,
+  setSplitPaneSession,
+  SPLIT_PANE_ID,
+  toggleSplitPane
+} from './split'
+
+const SPLIT_SESSION_KEY = 'hermes.desktop.splitPane.v1'
+
+function resetSplitState() {
+  $paneStates.set({})
+  $splitPaneSession.set(null)
+  $splitFreshDraft.set(false)
+  $activePaneId.set('main')
+  setSelectedStoredSessionId(null)
+  setSessions([])
+  window.localStorage.clear()
+}
+
+function sessionRow(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    ended_at: null,
+    id: 'stored-row',
+    input_tokens: 0,
+    is_active: false,
+    last_active: 1,
+    message_count: 0,
+    model: null,
+    output_tokens: 0,
+    preview: null,
+    source: 'desktop',
+    started_at: 1,
+    title: 'row',
+    tool_call_count: 0,
+    ...overrides
+  }
+}
+
+describe('split store', () => {
+  beforeEach(resetSplitState)
+
+  afterEach(() => {
+    resetSplitState()
+    vi.restoreAllMocks()
+  })
+
+  describe('openSplitPane / closeSplitPane', () => {
+    it('opens on a session: pane snapshot open, session set, split focused', () => {
+      const opened = openSplitPane({ storedId: 'stored-2', profile: 'coder' })
+
+      expect(opened).toBe(true)
+      expect(getPaneStateSnapshot(SPLIT_PANE_ID)?.open).toBe(true)
+      expect($splitPaneSession.get()).toEqual({ storedId: 'stored-2', profile: 'coder' })
+      expect($activePaneId.get()).toBe('split')
+      expect($splitOpen.get()).toBe(true)
+    })
+
+    it('opens without a session as a fresh draft', () => {
+      expect(openSplitPane()).toBe(true)
+
+      expect($splitPaneSession.get()).toBeNull()
+      expect($splitFreshDraft.get()).toBe(true)
+      expect($splitOpen.get()).toBe(true)
+    })
+
+    it('re-opening without a session keeps the split session it already holds', () => {
+      openSplitPane({ storedId: 'stored-2', profile: null })
+      closeSplitPane()
+      setSplitPaneSession('stored-3')
+
+      openSplitPane()
+
+      expect($splitPaneSession.get()).toEqual({ storedId: 'stored-3', profile: null })
+      expect($splitFreshDraft.get()).toBe(false)
+    })
+
+    it('same-session guard: asking for the main pane’s session focuses main instead', () => {
+      setSelectedStoredSessionId('stored-dup')
+      setActivePane('split')
+
+      const opened = openSplitPane({ storedId: 'stored-dup', profile: null })
+
+      expect(opened).toBe(false)
+      expect($splitOpen.get()).toBe(false)
+      expect($splitPaneSession.get()).toBeNull()
+      expect($activePaneId.get()).toBe('main')
+    })
+
+    it('close clears the session + fresh flag and hands focus back to main', () => {
+      openSplitPane({ storedId: 'stored-2', profile: null })
+      closeSplitPane()
+
+      expect(getPaneStateSnapshot(SPLIT_PANE_ID)?.open).toBe(false)
+      expect($splitPaneSession.get()).toBeNull()
+      expect($splitFreshDraft.get()).toBe(false)
+      expect($activePaneId.get()).toBe('main')
+      expect($splitOpen.get()).toBe(false)
+    })
+
+    it('toggleSplitPane round-trips open and closed', () => {
+      toggleSplitPane()
+      expect($splitOpen.get()).toBe(true)
+
+      toggleSplitPane()
+      expect($splitOpen.get()).toBe(false)
+    })
+
+    it('a stale open snapshot without a session or draft does NOT count as open', () => {
+      // e.g. relaunch after the split session was deleted: the pane snapshot
+      // still says open, but there is nothing to mount.
+      openSplitPane({ storedId: 'stored-2', profile: null })
+      $splitPaneSession.set(null)
+
+      expect(getPaneStateSnapshot(SPLIT_PANE_ID)?.open).toBe(true)
+      expect($splitOpen.get()).toBe(false)
+    })
+  })
+
+  describe('setSplitPaneSession', () => {
+    it('keeps the profile tag when re-setting the same stored id without one', () => {
+      setSplitPaneSession('stored-5', 'coder')
+      setSplitPaneSession('stored-5')
+
+      expect($splitPaneSession.get()).toEqual({ storedId: 'stored-5', profile: 'coder' })
+    })
+
+    it('re-resolves the profile tag from $sessions when pointing at a different session', () => {
+      // Pane-local navigation (fresh-draft send / branch in the split) never
+      // carries a profile — the optimistic row upserted just before it does.
+      // Carrying the OLD tag or nulling it would unpin the pane's request
+      // wrapper and drop the profile from the gateway keep-set.
+      setSessions([sessionRow({ id: 'stored-6', profile: 'analyst' })])
+      setSplitPaneSession('stored-5', 'coder')
+      setSplitPaneSession('stored-6')
+
+      expect($splitPaneSession.get()).toEqual({ storedId: 'stored-6', profile: 'analyst' })
+    })
+
+    it('resolves via the lineage-root id and falls back to null for an unknown row', () => {
+      setSessions([sessionRow({ id: 'tip-7', _lineage_root_id: 'stored-7', profile: 'coder' })])
+
+      setSplitPaneSession('stored-7')
+      expect($splitPaneSession.get()).toEqual({ storedId: 'stored-7', profile: 'coder' })
+
+      setSplitPaneSession('stored-unknown')
+      expect($splitPaneSession.get()).toEqual({ storedId: 'stored-unknown', profile: null })
+    })
+
+    it('clears the fresh-draft flag when a session takes the pane', () => {
+      setSplitPaneFreshDraft()
+      setSplitPaneSession('stored-5')
+
+      expect($splitFreshDraft.get()).toBe(false)
+    })
+  })
+
+  describe('persistence', () => {
+    it('persists the split session (with profile) and clears the key on close', () => {
+      openSplitPane({ storedId: 'stored-7', profile: 'analyst' })
+
+      expect(JSON.parse(window.localStorage.getItem(SPLIT_SESSION_KEY) ?? 'null')).toEqual({
+        storedId: 'stored-7',
+        profile: 'analyst'
+      })
+
+      closeSplitPane()
+
+      expect(window.localStorage.getItem(SPLIT_SESSION_KEY)).toBeNull()
+    })
+
+    it('restores a persisted split session on module load', async () => {
+      window.localStorage.setItem(SPLIT_SESSION_KEY, JSON.stringify({ storedId: 'stored-9', profile: 'coder' }))
+      vi.resetModules()
+
+      const fresh = await import('./split')
+
+      expect(fresh.$splitPaneSession.get()).toEqual({ storedId: 'stored-9', profile: 'coder' })
+    })
+
+    it('treats malformed / storedId-less persisted state as closed', async () => {
+      window.localStorage.setItem(SPLIT_SESSION_KEY, '{not json')
+      vi.resetModules()
+      expect((await import('./split')).$splitPaneSession.get()).toBeNull()
+
+      window.localStorage.setItem(SPLIT_SESSION_KEY, JSON.stringify({ profile: 'coder' }))
+      vi.resetModules()
+      expect((await import('./split')).$splitPaneSession.get()).toBeNull()
+    })
+  })
+
+  describe('restoreSplitPaneSession', () => {
+    it('resolves null without probing when the split holds no session', async () => {
+      const resolve = vi.fn(async () => ({ id: 'x' }))
+
+      expect(await restoreSplitPaneSession(resolve)).toBeNull()
+      expect(resolve).not.toHaveBeenCalled()
+    })
+
+    it('keeps the split when the probe resolves the session', async () => {
+      openSplitPane({ storedId: 'stored-2', profile: null })
+
+      const restored = await restoreSplitPaneSession(async () => ({ id: 'stored-2' }))
+
+      expect(restored).toEqual({ storedId: 'stored-2', profile: null })
+      expect($splitOpen.get()).toBe(true)
+    })
+
+    it('closes the split on a probe miss (deleted/archived session)', async () => {
+      openSplitPane({ storedId: 'stored-2', profile: null })
+
+      expect(await restoreSplitPaneSession(async () => undefined)).toBeNull()
+      expect($splitOpen.get()).toBe(false)
+      expect($splitPaneSession.get()).toBeNull()
+    })
+
+    it('closes the split when the probe throws (backend 404 path)', async () => {
+      openSplitPane({ storedId: 'stored-2', profile: null })
+
+      expect(
+        await restoreSplitPaneSession(async () => {
+          throw new Error('404: Session not found')
+        })
+      ).toBeNull()
+
+      expect($splitOpen.get()).toBe(false)
+    })
+  })
+})
diff --git a/apps/desktop/src/store/split.ts b/apps/desktop/src/store/split.ts
new file mode 100644
index 0000000000000..0c7e188ba6416
--- /dev/null
+++ b/apps/desktop/src/store/split.ts
@@ -0,0 +1,294 @@
+import { atom, computed } from 'nanostores'
+
+import { readKey, writeKey } from '@/lib/storage'
+import { $paneStates, setPaneOpen } from '@/store/panes'
+import { $selectedStoredSessionId, $sessions } from '@/store/session'
+
+// ── Split-pane (two-pane chat) state ────────────────────────────────────────
+// The split pane is a SECOND chat view inside the main window. Which pane the
+// user last interacted with is runtime-only ($activePaneId); which session the
+// split holds is persisted so a relaunch restores it without a list scan. The
+// split's open flag + width ride the existing store/panes.ts snapshot under
+// SPLIT_PANE_ID, so resize/persistence come for free.
+
+export type PaneId = 'main' | 'split'
+
+/** store/panes.ts snapshot id for the split pane (open state + width). */
+export const SPLIT_PANE_ID = 'chat-split'
+
+const SPLIT_SESSION_KEY = 'hermes.desktop.splitPane.v1'
+
+export interface SplitPaneSession {
+  storedId: string
+  /** Profile tag captured at open time so boot restore can route the probe
+   *  without scanning every profile's session list. */
+  profile: string | null
+}
+
+/** The pane the user last interacted with. Global surfaces (statusbar, rail,
+ *  model menus) mirror this pane's session. Runtime-only — a relaunch always
+ *  starts focused on the main pane. */
+export const $activePaneId = atom<PaneId>('main')
+
+function loadSplitSession(): SplitPaneSession | null {
+  try {
+    const raw = readKey(SPLIT_SESSION_KEY)
+
+    if (!raw) {
+      return null
+    }
+
+    const parsed = JSON.parse(raw) as { storedId?: unknown; profile?: unknown }
+
+    if (typeof parsed.storedId !== 'string' || !parsed.storedId.trim()) {
+      return null
+    }
+
+    return {
+      storedId: parsed.storedId,
+      profile: typeof parsed.profile === 'string' && parsed.profile.trim() ? parsed.profile : null
+    }
+  } catch {
+    return null
+  }
+}
+
+/** Which stored session the split pane holds, or null (closed / fresh draft). */
+export const $splitPaneSession = atom<SplitPaneSession | null>(loadSplitSession())
+
+$splitPaneSession.subscribe(value => {
+  writeKey(SPLIT_SESSION_KEY, value ? JSON.stringify(value) : null)
+})
+
+// A split showing a brand-new draft (no stored session yet). Runtime-only: an
+// unsent draft has nothing to restore, so a relaunch drops it.
+export const $splitFreshDraft = atom(false)
+
+/** Runtime id of the session the split pane currently VIEWS (maintained by the
+ *  mounted SplitChatPane, null while the split is closed). Lets non-React
+ *  modules — native notifications foremost — treat a split-visible session as
+ *  on-screen without reaching into the pane's view bundle. Runtime-only. */
+export const $splitPaneRuntimeSessionId = atom<string | null>(null)
+
+// The MAIN pane's viewed runtime id, UNMIRRORED. While the split is focused
+// the $activeSessionId singleton mirrors the SPLIT's session, so non-React
+// consumers (native notifications) that must classify the main pane's
+// on-screen transcript as foreground need the cache-ref truth. The controller
+// registers a getter over its activeSessionIdRef (same pattern as the pane
+// dispatcher below); null before it mounts, which reduces every consumer to
+// the pre-split active-only logic.
+let mainPaneRuntimeSessionIdGetter: (() => string | null) | null = null
+
+export function registerMainPaneRuntimeSessionIdGetter(getter: (() => string | null) | null): void {
+  mainPaneRuntimeSessionIdGetter = getter
+}
+
+export function mainPaneRuntimeSessionId(): string | null {
+  return mainPaneRuntimeSessionIdGetter?.() ?? null
+}
+
+// Open = the pane snapshot says open AND there is something to show (a session
+// or a fresh draft). Guards against a stale open flag surviving a session
+// delete/restore-miss and mounting an empty split.
+export const $splitOpen = computed(
+  [$paneStates, $splitPaneSession, $splitFreshDraft],
+  (paneStates, session, freshDraft) => Boolean(paneStates[SPLIT_PANE_ID]?.open) && (session !== null || freshDraft)
+)
+
+export function setActivePane(id: PaneId): void {
+  if ($activePaneId.get() !== id) {
+    $activePaneId.set(id)
+  }
+}
+
+function sessionProfileTag(storedId: string): null | string {
+  return (
+    $sessions.get().find(session => session.id === storedId || session._lineage_root_id === storedId)?.profile ?? null
+  )
+}
+
+/** Point the split pane at a stored session (pane-local "navigation").
+ *
+ * When the caller carries no profile, the tag is resolved rather than dropped:
+ * same session → keep the current tag; different session → the $sessions row's
+ * tag. Pane-local navigations that CREATE a session (fresh-draft send, branch
+ * in the split) upsert the optimistic row — stamped with the live gateway
+ * profile — before navigating, so the lookup lands even before a refresh. A
+ * null tag would silently unpin the pane's request wrapper and drop the
+ * profile from the gateway keep-set. */
+export function setSplitPaneSession(storedId: string, profile?: string | null): void {
+  const current = $splitPaneSession.get()
+
+  $splitFreshDraft.set(false)
+  $splitPaneSession.set({
+    storedId,
+    profile:
+      profile !== undefined
+        ? profile
+        : current?.storedId === storedId
+          ? current.profile
+          : sessionProfileTag(storedId)
+  })
+}
+
+/** Swap the split pane to a fresh new-chat draft (no stored session). */
+export function setSplitPaneFreshDraft(): void {
+  $splitPaneSession.set(null)
+  $splitFreshDraft.set(true)
+}
+
+/**
+ * Open the split pane. With a session → show that session; without → a fresh
+ * draft. Enforces the "same session may not be open in both panes" invariant:
+ * asking the split to show the main pane's current session just focuses the
+ * main pane (the dispatcher applies the mirror rule for the other direction).
+ */
+export function openSplitPane(session?: SplitPaneSession | null): boolean {
+  if (session) {
+    if (session.storedId === $selectedStoredSessionId.get()) {
+      setActivePane('main')
+
+      return false
+    }
+
+    setSplitPaneSession(session.storedId, session.profile)
+  } else if (!$splitPaneSession.get()) {
+    setSplitPaneFreshDraft()
+  }
+
+  setPaneOpen(SPLIT_PANE_ID, true)
+  setActivePane('split')
+
+  return true
+}
+
+/** Close the split pane and hand focus back to the main pane. */
+export function closeSplitPane(): void {
+  setPaneOpen(SPLIT_PANE_ID, false)
+  $splitPaneSession.set(null)
+  $splitFreshDraft.set(false)
+  setActivePane('main')
+}
+
+export function toggleSplitPane(): void {
+  if ($splitOpen.get()) {
+    closeSplitPane()
+  } else {
+    openSplitPane()
+  }
+}
+
+/**
+ * Point the split pane at a stored session, resolving the profile tag from the
+ * loaded session list when the caller doesn't carry one — so the pane's
+ * profile-pinned request wrapper and the gateway keep-set route correctly.
+ * Raw open: the same-session invariant is enforced by openSplitPane against
+ * the identity singletons; the controller's dispatcher (which also knows the
+ * unmirrored main-pane selection) wraps this with its own guard.
+ */
+export function openSplitPaneForSession(storedId: string, profile?: string | null): boolean {
+  const resolved = profile !== undefined ? profile : sessionProfileTag(storedId)
+
+  return openSplitPane({ storedId, profile: resolved ?? null })
+}
+
+// ── Pane-open dispatcher registration ───────────────────────────────────────
+// Session-open entry points that live outside DesktopController (command
+// palette, keybind slots/switcher, session menus) can't reach its dispatcher
+// through props. The controller registers it here; callers fall back to their
+// legacy paths when no controller is mounted (early boot frames only).
+
+interface PaneOpenDispatcher {
+  /** §3.5 dispatcher: open in the focused pane; duplicates focus their pane. */
+  openInActivePane: (storedId: string) => void
+  /** "Open in split" with the controller's unmirrored same-session guard. */
+  openInSplit: (storedId: string, profile?: string | null) => void
+}
+
+let paneOpenDispatcher: PaneOpenDispatcher | null = null
+
+export function registerPaneOpenDispatcher(dispatcher: PaneOpenDispatcher | null): void {
+  paneOpenDispatcher = dispatcher
+}
+
+/** Route a session open through the active-pane dispatcher. Returns false when
+ *  none is registered — the caller then uses its legacy navigate() path. */
+export function dispatchOpenSession(storedId: string): boolean {
+  if (!paneOpenDispatcher) {
+    return false
+  }
+
+  paneOpenDispatcher.openInActivePane(storedId)
+
+  return true
+}
+
+/** "Open in split" entry point (session menus). Prefers the controller's
+ *  dispatcher — it guards the same-session invariant against the UNMIRRORED
+ *  main-pane selection — and falls back to the raw open before it mounts. */
+export function openSessionInSplitPane(storedId: string, profile?: string | null): boolean {
+  if (paneOpenDispatcher) {
+    paneOpenDispatcher.openInSplit(storedId, profile)
+
+    return true
+  }
+
+  return openSplitPaneForSession(storedId, profile)
+}
+
+// ── Split-pane model-selection delegate ─────────────────────────────────────
+// The global ModelPickerOverlay lives outside any PaneViewContext, but its
+// pick must land on the ACTIVE pane's model chip. The mounted SplitChatPane
+// registers its pane-scoped selectModel here; the controller routes overlay
+// picks through it while the split pane is focused. Null while the split is
+// closed — overlay picks then take the main path, exactly as pre-split.
+
+export interface PaneModelSelection {
+  model: string
+  provider: string
+}
+
+let splitPaneModelDelegate: ((selection: PaneModelSelection) => Promise<boolean>) | null = null
+
+export function registerSplitPaneModelDelegate(
+  delegate: ((selection: PaneModelSelection) => Promise<boolean>) | null
+): void {
+  splitPaneModelDelegate = delegate
+}
+
+export function splitPaneModelSelect(): ((selection: PaneModelSelection) => Promise<boolean>) | null {
+  return splitPaneModelDelegate
+}
+
+/**
+ * Boot-restore guard: keep the persisted split session only if it still
+ * resolves. `resolve` is the caller's session probe (resolveStoredSession) —
+ * injected so the store stays free of REST plumbing. A miss (null / throw)
+ * closes the split instead of mounting a pane that can never resume.
+ * Returns the validated session, or null when the split was (or is now) closed.
+ */
+export async function restoreSplitPaneSession(
+  resolve: (storedId: string) => Promise<unknown>
+): Promise<SplitPaneSession | null> {
+  const session = $splitPaneSession.get()
+
+  if (!session) {
+    return null
+  }
+
+  try {
+    const stored = await resolve(session.storedId)
+
+    if (!stored) {
+      closeSplitPane()
+
+      return null
+    }
+  } catch {
+    closeSplitPane()
+
+    return null
+  }
+
+  return $splitPaneSession.get()
+}
diff --git a/apps/desktop/src/store/thread-scroll.ts b/apps/desktop/src/store/thread-scroll.ts
index 976cf4b4e14a1..56f642e542dc3 100644
--- a/apps/desktop/src/store/thread-scroll.ts
+++ b/apps/desktop/src/store/thread-scroll.ts
@@ -8,38 +8,70 @@ import { atom, type WritableAtom } from 'nanostores'
 // `$threadScrolledUp` dims the composer / status stack; `$threadJumpButtonVisible`
 // shows the floating jump control. Both track `!isAtBottom` today, but stay
 // separate so their thresholds can diverge again without touching consumers.
-export const $threadScrolledUp = atom(false)
-export const $threadJumpButtonVisible = atom(false)
-
-// Skip no-op writes so subscribers don't churn on every scroll tick.
-const setter = (target: WritableAtom<boolean>) => (value: boolean) => {
-  if (target.get() !== value) {
-    target.set(value)
-  }
+//
+// Factory-shaped for the split pane: each mounted thread + its chrome share ONE
+// instance (two threads writing a shared atom would fight over it), delivered
+// through the pane bundle (see app/chat/pane-view.ts). The module-level exports
+// below stay the MAIN pane's instance, so every existing consumer is untouched.
+
+export interface ThreadScrollInstance {
+  $threadScrolledUp: WritableAtom<boolean>
+  $threadJumpButtonVisible: WritableAtom<boolean>
+  setThreadAtBottom: (isAtBottom: boolean) => void
+  resetThreadScroll: () => void
+  /** Fire the registered viewport handler(s) — the jump button's click path. */
+  requestScrollToBottom: () => void
+  /** Cross-component bridge: the jump button lives by the composer, the
+   *  viewport's `scrollToBottom` lives inside the thread. The thread registers
+   *  a handler; the button fires it. Mirrors the composer focus/insert emitter
+   *  pattern, scoped per pane so one pane's jump can't scroll the other. */
+  onScrollToBottomRequest: (handler: () => void) => () => void
 }
 
-const setScrolledUp = setter($threadScrolledUp)
-const setJumpButtonVisible = setter($threadJumpButtonVisible)
+export function createThreadScrollAtoms(): ThreadScrollInstance {
+  const $threadScrolledUp = atom(false)
+  const $threadJumpButtonVisible = atom(false)
 
-export const setThreadAtBottom = (isAtBottom: boolean) => {
-  setScrolledUp(!isAtBottom)
-  setJumpButtonVisible(!isAtBottom)
-}
+  // Skip no-op writes so subscribers don't churn on every scroll tick.
+  const setter = (target: WritableAtom<boolean>) => (value: boolean) => {
+    if (target.get() !== value) {
+      target.set(value)
+    }
+  }
 
-export const resetThreadScroll = () => setThreadAtBottom(true)
+  const setScrolledUp = setter($threadScrolledUp)
+  const setJumpButtonVisible = setter($threadJumpButtonVisible)
 
-// Cross-component bridge: the jump button lives by the composer, the viewport's
-// `scrollToBottom` lives inside the thread. The bridge registers a handler; the
-// button fires it. Mirrors the composer focus/insert emitter pattern.
-const handlers = new Set<() => void>()
+  const setThreadAtBottom = (isAtBottom: boolean) => {
+    setScrolledUp(!isAtBottom)
+    setJumpButtonVisible(!isAtBottom)
+  }
+
+  const handlers = new Set<() => void>()
 
-export const onScrollToBottomRequest = (handler: () => void) => {
-  handlers.add(handler)
+  return {
+    $threadScrolledUp,
+    $threadJumpButtonVisible,
+    setThreadAtBottom,
+    resetThreadScroll: () => setThreadAtBottom(true),
+    requestScrollToBottom: () => handlers.forEach(handler => handler()),
+    onScrollToBottomRequest: handler => {
+      handlers.add(handler)
 
-  return () => void handlers.delete(handler)
+      return () => void handlers.delete(handler)
+    }
+  }
 }
 
-export const requestScrollToBottom = () => handlers.forEach(handler => handler())
+/** The main pane's instance — the atoms every pre-split consumer imported. */
+export const mainThreadScroll = createThreadScrollAtoms()
+
+export const $threadScrolledUp = mainThreadScroll.$threadScrolledUp
+export const $threadJumpButtonVisible = mainThreadScroll.$threadJumpButtonVisible
+export const setThreadAtBottom = mainThreadScroll.setThreadAtBottom
+export const resetThreadScroll = mainThreadScroll.resetThreadScroll
+export const onScrollToBottomRequest = mainThreadScroll.onScrollToBottomRequest
+export const requestScrollToBottom = mainThreadScroll.requestScrollToBottom
 
 // Inline edit grows a sticky human bubble. Fire on pointerdown so the viewport
 // escapes stick-to-bottom before focus/layout; close clears the edit flag when